EDIT

	 * @param person the person

	 * @return a count of InstitutionalMembership instances

	 */

	/**

	 * Return a List of members of a given team

	 * @param team the team

	 * @return a count of Person instances

	 */

	/**

	 * Return a count of addresses of a given agent

	 * @param agent the agent

	 * @return a count of Address instances

	 */

	/**

	 * Return a List of addresses of a given agent

	 * @param identifiableEntity The identifiable entity

	 * @return a count of OriginalSource instances

	 */

	/**

	 * Return a List of the sources for this identifiable entity

	 * @param identifiableEntity The identifiable entity

	 * @return a count of Rights instances

	 */

	/**

	 * @return a count of the matching entities

	 * @see <a href="http://lucene.apache.org/java/2_4_0/queryparsersyntax.html">Apache Lucene - Query Parser Syntax</a>

	 */

	/**

	 * Returns a List of T instances where the default field matches the String queryString (as interpreted by the Lucene QueryParser)

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

package eu.etaxonomy.cdm.persistence.dao.common;

import eu.etaxonomy.cdm.model.view.AuditEventRecord;

public interface IVersionableDao<T extends VersionableEntity> extends ICdmEntityDao<T> {

	/**

	 * Returns a list of audit events (in order) which affected the state of an entity t.

	 * AuditEventContext is set to null, or to AuditEvent.CURRENT_VIEW, then all relevant

	 * AuditEvents are returned.

	 * @param t The versionable entity which was affected by the audit events

	 * @param pageSize The maximum number of audit event records returned (can be null for all audit event records)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a list of AuditEventRecords, containing the AuditEvent, the state of the entity at that event, and the type of modification

	 */

    public List<AuditEventRecord<T>> getAuditEvents(T t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths);

    /**

     * Returns  a count of audit events which affected the state of an entity t.

	 * AuditEventContext is set to null, or to AuditEvent.CURRENT_VIEW, then all relevant

	 * AuditEvents are considered.

	 * @param t The versionable entity which was affected by the audit events

     * @param sort should the events considered start now and go forward in time (AuditEventSort.FORWARDS) or backwards (AuditEventSort.BACKWARDS)

     * @return a count of audit events

     */

	/**

	 * A convenience method which returns a record of the next (relative to the audit event in context)

	 * audit event to affect the entity t.

	 * @param t The versionable entity affected by these audit events

	 * @return a record of the next audit event to affect t, or null if the current event is the last to affect t

	 */

	public AuditEventRecord<T> getNextAuditEvent(T t);

	/**

	 * A convenience method which returns a record of the previous (relative to the audit event in context)

	 * audit event to affect the entity t.

	 * @param t The versionable entity affected by these audit events

	 * @return a record of the previous audit event to affect t, or null if the current event is the first to affect t

	 */

	public AuditEventRecord<T> getPreviousAuditEvent(T t);

	/**

	 * Returns a count of the total number of audit events affecting objects of class T, optionally restricted to objects of

	 * class clazz, the AuditEvents from and to, inclusive, optionally filtered by other criteria

	 * @param clazz Restrict the results returned to objects of this class

	 * @param from The audit event to start from (or pass null to start from the beginning of the recordset)

	 * @param to The audit event to continue until (or pass null to return audit events up to the time of the query)

	 * @param criteria Extra criteria to filter by

	 * @return the count of audit events

	 */

	/**

	 * Returns a list of all audit events occurring to objects of type T, optionally restricted to objects of type clazz

	 * between the AuditEvents from and to, inclusive, optionally filtered by other criteria

	 * @param clazz Restrict the results returned to objects of this class

	 * @param from The audit event to start from (inclusive, or pass null to start from the beginning of the recordset)

	 * @param to The audit event to continue until (exclusive, or pass null to return audit events up to the time of the query)

	 * @param criteria Extra criteria to filter by

	 * @param pageSize The maximum number of objects returned (can be null for all matching objects)

	 *                   can be null, equivalent of starting at the beginning of the recordset)

	 * @param sort Sort the events either forwards or backwards in time

	 * @param propertyPaths properties to be initialized

	 * Returns the number of objects of type IIdentificationKey

	 * @return

	 */

	/**

	 * Finds IdentificationKeys which cover the Taxon given as parameter

	 *            IIdentificationKey

	 * @return

	 */

}

	}

	@Override

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

		    Query query = getSession().createQuery("select count(institutionalMembership) from InstitutionalMembership institutionalMembership where institutionalMembership.person = :person");

		    query.setParameter("person", person);

		} else {

			query.add(AuditEntity.relatedId("person").eq(person.getId()));

			query.addProjection(AuditEntity.id());

		}

	}

	@Override

		checkNotInPriorView("AgentDaoImpl.countMembers(Team team)");

		Query query = getSession().createQuery("select count(teamMember) from Team team join team.teamMembers teamMember where team = :team");

		query.setParameter("team", team);

	}

	@Override

		query.setParameter("team", team);

		//query.addOrder( Order.asc("sortindex") );

		setPagingParameter(query, pageSize, pageNumber);

	}

	@Override

		checkNotInPriorView("AgentDaoImpl.countAddresses(AgentBase agent)");

		Query query = getSession().createQuery("select count(address) from AgentBase agent join agent.contact.addresses address where agent = :agent");

		query.setParameter("agent", agent);

	}

	@Override

		Query query = getSession().createQuery("select address from AgentBase agent join agent.contact.addresses address where agent = :agent");

		query.setParameter("agent", agent);

		setPagingParameter(query, pageSize, pageNumber);

	}

	@Override

	public List<UuidAndTitleCache<Team>> getTeamUuidAndNomenclaturalTitle() {

		Session session = getSession();

		Query query = session.createQuery("select uuid, id, nomenclaturalTitle from " + type.getSimpleName() + " where dtype = 'Team'");

        List<Object[]> result = query.list();

		for(Object[] object : result){

		}

		return list;

    }

    @Override

        checkNotInPriorView("IdentifiableDaoBase.countRights(T identifiableEntity)");

        Query query = getSession().createQuery("select count(rights) from " + type.getSimpleName() + " identifiableEntity join identifiableEntity.rights rights where identifiableEntity = :identifiableEntity");

        query.setParameter("identifiableEntity",identifiableEntity);

    }

    @Override

        checkNotInPriorView("IdentifiableDaoBase.countSources(T identifiableEntity)");

        Query query = getSession().createQuery("SELECT COUNT(source) FROM "+identifiableEntity.getClass().getName() + " ie JOIN ie.sources source WHERE ie = :identifiableEntity");

        query.setParameter("identifiableEntity", identifiableEntity);

    }

    @Override

        Query query = getSession().createQuery("select rights from " + type.getSimpleName() + " identifiableEntity join identifiableEntity.rights rights where identifiableEntity = :identifiableEntity");

        query.setParameter("identifiableEntity",identifiableEntity);

        setPagingParameter(query, pageSize, pageNumber);

        List<Rights> results = query.list();

        defaultBeanInitializer.initializeAll(results, propertyPaths);

        return results;

        Query query = getSession().createQuery("select credits from " + type.getSimpleName() + " identifiableEntity join identifiableEntity.credits credits where identifiableEntity = :identifiableEntity");

        query.setParameter("identifiableEntity",identifiableEntity);

        setPagingParameter(query, pageSize, pageNumber);

    }

    @Override

        query.setString("idInSource", idInSource);

        query.setString("idNamespace", idNamespace);

        //TODO integrate reference in where

    }

    @Override

    }

    @Override

        checkNotInPriorView("IdentifiableDaoBase.count(Class<? extends T> clazz, String queryString)");

        QueryParser queryParser = new QueryParser(defaultField , new StandardAnalyzer());

                fullTextQuery = fullTextSession.createFullTextQuery(query, clazz);

            }

            return result;

        } catch (ParseException e) {

    public void optimizeIndex() {

        FullTextSession fullTextSession = Search.getFullTextSession(getSession());

        SearchFactory searchFactory = fullTextSession.getSearchFactory();

            searchFactory.optimize(clazz); // optimize the indices ()

        }

        fullTextSession.flushToIndexes();

	}

	@Override

		AuditEvent auditEvent = getAuditEventFromContext();

		AuditQuery query = getAuditReader().createQuery().forRevisionsOfEntity(type, false, true);

		query.addProjection(AuditEntity.revisionNumber().count());

	}

	@Override

	}

	@Override

		AuditQuery query = null;

		if(clazz == null) {

		query.addProjection(AuditEntity.revisionNumber().count());

	}

	protected void addCriteria(AuditQuery query, List<AuditCriterion> criteria) {

    }

    @Override

        checkNotInPriorView("DescriptionElementDaoImpl.countTextData(String queryString)");

        QueryParser queryParser = new QueryParser(defaultField, new StandardAnalyzer());

            } else {

                fullTextQuery = fullTextSession.createFullTextQuery(query, clazz);

            }

        } catch (ParseException e) {

            throw new QueryParseException(e, queryString);

        }

	protected IBeanInitializer defaultBeanInitializer;

	@Override

		Query query = getSession().createQuery("select count(key) from eu.etaxonomy.cdm.model.description.IIdentificationKey key");

		}

		return total;

	}

    public List<IIdentificationKey> list(Integer limit,Integer start, List<String> propertyPaths) {

		Query query = getSession().createQuery("select key from eu.etaxonomy.cdm.model.description.IIdentificationKey key order by created desc");

		defaultBeanInitializer.initializeAll(results, propertyPaths);

		return results;

	}

	@Override

	public <T extends IIdentificationKey> List<T> findByTaxonomicScope(

	        UUID taxonUuid, Class<T> type, Integer pageSize,

		Query query = getSession().createQuery("select key from " + type.getCanonicalName() +" key join key.taxonomicScope ts where ts.uuid = (:taxon_uuid)");

		query.setParameter("taxon_uuid", taxonUuid);

		defaultBeanInitializer.initializeAll(results, propertyPaths);

		return results;

	}

	@Override

		Query query = getSession().createQuery("select count(key) from " + type.getCanonicalName() +" key join key.taxonomicScope ts where ts.uuid = (:taxon_uuid)");

		query.setParameter("taxon_uuid", taxonUuid);

			count += perTypeCount;

		}

		return count;

	}

	@Override

		checkNotInPriorView("MediaDaoHibernateImpl.countRights(Media t)");

		Query query = getSession().createQuery("select count(rights) from Media media join media.rights rights where media = :media");

		query.setParameter("media",media);

	}

    @Override

        checkNotInPriorView("countTypeDesignations(TaxonName name, SpecimenTypeDesignationStatus status)");

        Query query = null;

        if(status == null) {

            query.setParameter("status", status);

        }

        query.setParameter("name",name);

    }

    @Override

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

package eu.etaxonomy.cdm.persistence.dao.hibernate.view;

@Repository

public class AuditEventDao extends DaoBase implements IAuditEventDao {

	protected AuditReader getAuditReader() {

		return AuditReaderFactory.get(getSession());

	}

		Query query = getSession().createQuery("select count(auditEvent) from AuditEvent auditEvent");

	}

		Query query = getSession().createQuery("select auditEvent from AuditEvent auditEvent where auditEvent.uuid = :uuid");

		query.setParameter("uuid", uuid);

		return null != (AuditEvent)query.uniqueResult();

	}

		Query query = getSession().createQuery("select auditEvent from AuditEvent auditEvent where auditEvent.id = :id");

		query.setParameter("id", id);

		return (AuditEvent)query.uniqueResult();

	}

		Query query = getSession().createQuery("select auditEvent from AuditEvent auditEvent where auditEvent.uuid = :uuid");

		query.setParameter("uuid", uuid);

		return (AuditEvent)query.uniqueResult();

	}

		Query query = getSession().createQuery("select auditEvent from AuditEvent auditEvent where auditEvent.revisionNumber = :revisionNumber + 1");

		query.setParameter("revisionNumber", auditEvent.getRevisionNumber());

		return (AuditEvent) query.uniqueResult();

	}

		Query query = getSession().createQuery("select auditEvent from AuditEvent auditEvent where auditEvent.revisionNumber = :revisionNumber - 1");

		query.setParameter("revisionNumber", auditEvent.getRevisionNumber());

		return (AuditEvent) query.uniqueResult();

	}

		if(sort == null) {

			sort = AuditEventSort.BACKWARDS;

		}

		Query query = null;

		if(sort.equals(AuditEventSort.FORWARDS)) {

			query = getSession().createQuery("select auditEvent from AuditEvent auditEvent order by auditEvent.timestamp asc");

		} else {

			query = getSession().createQuery("select auditEvent from AuditEvent auditEvent order by auditEvent.timestamp desc");

		}

		if(pageSize != null) {

		    query.setMaxResults(pageSize);

		    if(pageNumber != null) {

		    	query.setFirstResult(0);

		    }

		}

	}

		Number id = getAuditReader().getRevisionNumberForDate(dateTime.toDate());

		Hibernate.initialize(auditEvent);

		return auditEvent;

	}

	 * @return a count of Rights instances

	 */

    @Override

	/**

	 * Return a List of the rights for this media entity

	 *            the type designation status (or null to return all types)

	 * @return a count of TypeDesignationBase instances

	 */

			SpecimenTypeDesignationStatus status);

	/**

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

package eu.etaxonomy.cdm.persistence.view;

public interface IAuditEventDao {

	/**

	 * Find the AuditEvent with an identifier equal to the parameter

	 * @param id

	 * @return an AuditEvent, or null if there is no AuditEvent with that identifier

	 */

    public AuditEvent findById(Integer id);

    /**

     * Find the AuditEvent with a uuid (surrogate key) equal to the uuid supplied

     * @param uuid

     * @return an AuditEvent, or null if there is no AuditEvent with a uuid which matches

     */

    public AuditEvent findByUuid(UUID uuid);

    /**

     * Count the AuditEvents in this database

     * @return the total number of AuditEvents in this database

     */

    /**

     * Returns a sublist of AuditEvent instances stored in the database.

	 * A maximum of 'limit' objects are returned, starting at object with index 'start'.

     * @param limit the maximum number of entities returned (can be null to return all entities)

     * @param start

     * or backwards (AuditEventSort.BACKWARDS)

     * @return a List of AuditEvent instances

    public List<AuditEvent> list(Integer limit, Integer start,AuditEventSort sort);

    /**

     * Returns the AuditEvent immediately proceeding the audit event passed as an argument

     * @param auditEvent

     * the most recent event

     */

    public AuditEvent getNextAuditEvent(AuditEvent auditEvent);

    /**

     * Returns the AuditEvent immediately preceding the audit event passed as an argument

     * @param auditEvent

     * the first event in the database

     */

    public AuditEvent getPreviousAuditEvent(AuditEvent auditEvent);

    /**

     * Checks whether an AuditEvent with a matching uuid exists in the database

     * @param uuid

     * @return true if an AuditEvent with a matching uuid exists in the database, false otherwise

     */

    @Test

    public void testCountTextData() {

    	assertEquals("countTextData should return 4",4,matches);

    }

    @Test

    public void testSearchCount() {

		assertEquals("countTaxa should return 46",46,numberOfResults);

    }

        Team team = (Team)agentDao.findByUuid(uuid);

        assert team != null : "team must exist";

        assertEquals("countMembers should return 5",5,numberOfMembers);

    }

        Person person = (Person)agentDao.findByUuid(personUuid);

        assert person != null : "person must exist";

        assertEquals("countInstitutionalMemberships should return 3",3,numberOfInstitutionalMemberships);

    }

        TaxonName acherontiaLachesis = taxonNameDao.findByUuid(acherontiaLachesisUuid);

        assert acherontiaLachesis != null : "name must exist";

        assertEquals("countTypeDesignations should return 1",1,count);

    }

        TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);

        assert taxon != null : "taxon cannot be null";

        assertEquals("countAuditEvents should return 2",numberOfAuditEvents,2);

    }

    public void testGetAuditEventsByTypeWithRestrictions() {

        commitAndStartNewTransaction(new String[]{"AUDITEVENT", "TAXONBASE_AUD"});

        propertyPaths.add("name");

        propertyPaths.add("createdBy");

        propertyPaths.add("updatedBy");

        List<AuditCriterion> criteria = new ArrayList<>();

        criteria.add(AuditEntity.property("lsid_lsid").isNotNull());

        List<AuditEventRecord<TaxonBase>> auditEvents = taxonDao.getAuditEvents(TaxonBase.class, previousAuditEvent, mostRecentAuditEvent, criteria,null, null, AuditEventSort.FORWARDS, propertyPaths);

        assertNotNull("getAuditEvents should return a list",auditEvents);

        propertyPaths.add("name");

        propertyPaths.add("createdBy");

        propertyPaths.add("updatedBy");

        List<AuditEventRecord<TaxonBase>> auditEvents = taxonDao.getAuditEvents(TaxonBase.class, previousAuditEvent, mostRecentAuditEvent, null,null, null, AuditEventSort.FORWARDS, propertyPaths);

        assertNotNull("getAuditEvents should return a list", auditEvents);

        assertFalse("the list should not be empty", auditEvents.isEmpty());

            pagerParameters.normalizeAndValidate(response);

            start = pagerParameters.getPageIndex() * pagerParameters.getPageSize();

            return p;

        }

    }

	@Override

	public Pager<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) {

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

			results = dao.getInstitutionalMemberships(person, pageSize, pageNumber);

		}

	}

	@Override

	public Pager<Person> getMembers(Team team, Integer pageSize, Integer pageNumber) {

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

			results = dao.getMembers(team, pageSize, pageNumber);

		}

	}

	@Override

	public Pager<Address> getAddresses(AgentBase agent, Integer pageSize, Integer pageNumber) {

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

			results = dao.getAddresses(agent, pageSize, pageNumber);

		}

	}

	@Override

/**

 * Copyright (C) 2007 EDIT

 * http://www.e-taxonomy.eu

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

@Service

@Transactional(readOnly = true)

public class AuditEventService implements IAuditEventService {

	IAuditEventDao dao;

	@Autowired

	public void setDao(IAuditEventDao dao) {

		this.dao = dao;

	}

		return dao.exists(uuid);

	}

		return dao.findById(id);

	}

		return dao.findByUuid(uuid);

	}

		return dao.getNextAuditEvent(auditEvent);

	}

		return dao.getPreviousAuditEvent(auditEvent);

	}

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

		}

	}

		return dao.findByDate(dateTime);

	}

}

            Set<Feature> features, Class<T> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

        List<T> results = listDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);

    }

    @Override

     */

    @Override

    public Pager<DescriptionElementBase> searchElements(Class<? extends DescriptionElementBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            results = descriptionElementDao.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);

        }

    }

    /**

	@Override

	@Transactional(readOnly = true)

	public Pager<Rights> getRights(T t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

		List<Rights> results = new ArrayList<>();

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

	@Override

	@Transactional(readOnly = true)

	public Pager<IdentifiableSource> getSources(T t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

		 List<IdentifiableSource> results = new ArrayList<>();

		 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

	@Transactional(readOnly = true)

	@Override

	public Pager<T> search(Class<? extends T> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

		List<T> results = new ArrayList<>();

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

    @Override

    public Pager<IIdentificationKey> page(Integer pageSize, Integer pageNumber,	List<String> propertyPaths) {

        if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            Integer limit = PagerUtils.limitFor(pageSize);

            Integer start = PagerUtils.startFor(pageSize, pageNumber);

            results = dao.list(limit, start, propertyPaths);

        }

    }

	@Override

    public Pager<Rights> getRights(Media t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

		List<Rights> results = new ArrayList<>();

		if(numberOfResults > 0) { // no point checking again  //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

    @Override

    public Pager<TypeDesignationBase> getTypeDesignations(TaxonName name, SpecimenTypeDesignationStatus status,

                Integer pageSize, Integer pageNumber, List<String> propertyPaths){

            results = dao.getTypeDesignations(name, null, status, pageSize, pageNumber, propertyPaths);

        }

    }

    /**

        }

        //dao.list() does the paging of the field units. Passing the field units directly to the Pager would not work

        List<SpecimenOrObservationBase> fieldUnits = dao.list(fieldUnitUuids, pageSize, pageNumber, orderHints, propertyPaths);

    }

    @Override

	@Override

    @Transactional(readOnly = true)

	public Pager<AuditEventRecord<T>> pageAuditEvents(T t, Integer pageSize,	Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

			results = dao.getAuditEvents(t, pageSize, pageNumber, sort,propertyPaths);

		}

	}

	@Override

	@Override

    @Transactional(readOnly = true)

	public Pager<AuditEventRecord<T>> pageAuditEvents(Class<? extends T> clazz,AuditEvent from,AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageNumber, AuditEventSort sort,List<String> propertyPaths) {

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

			results = dao.getAuditEvents(clazz,from,to,criteria, pageSize, pageNumber, sort,propertyPaths);

		}

	}

	 /**