From a14ee477df2d10c5d1fa93aa175198e324c31831 Mon Sep 17 00:00:00 2001 From: Patric Plitzner Date: Fri, 27 Sep 2013 09:56:05 +0000 Subject: [PATCH] - implementing transient service layer to use wit ABCD import to not save the data --- .gitattributes | 12 +- .../DataImportSpecimenEditorInput.java | 1 + .../TransientAgentService.java | 741 +++++++++ .../TransientCdmRepository.java | 18 +- .../TransientClassificationService.java | 921 +++++++++++ .../TransientCollectionService.java | 659 ++++++++ .../TransientDescriptionService.java | 1093 +++++++++++++ .../TransientNameService.java | 1194 ++++++++++++++ .../TransientOccurenceService.java | 13 +- .../TransientReferenceService.java | 693 ++++++++ .../TransientTaxonService.java | 1387 +++++++++++++++++ .../TransientTermService.java | 856 ++++++++++ 12 files changed, 7573 insertions(+), 15 deletions(-) create mode 100644 eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientAgentService.java rename eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/{ => transientServices}/TransientCdmRepository.java (93%) create mode 100644 eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientClassificationService.java create mode 100644 eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCollectionService.java create mode 100644 eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientDescriptionService.java create mode 100644 eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientNameService.java rename eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/{ => transientServices}/TransientOccurenceService.java (99%) create mode 100644 eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientReferenceService.java create mode 100644 eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTaxonService.java create mode 100644 eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTermService.java diff --git a/.gitattributes b/.gitattributes index 1ac4c77a3..af5f0ce6b 100644 --- a/.gitattributes +++ b/.gitattributes @@ -118,8 +118,16 @@ eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/bulkedito eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/DataImportEditor.java -text eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/DataImportEditorLineDisplayStrategy.java -text eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/DataImportSpecimenEditorInput.java -text -eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/TransientCdmRepository.java -text -eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/TransientOccurenceService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientAgentService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCdmRepository.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientClassificationService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCollectionService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientDescriptionService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientNameService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientOccurenceService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientReferenceService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTaxonService.java -text +eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTermService.java -text eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/wizard/SpecimenSearchWizard.java -text eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/wizard/SpecimenSearchWizardPage.java -text eu.etaxonomy.taxeditor.bulkeditor/src/test/java/eu/etaxonomy/taxeditor/bulkeditor/Application.java -text diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/DataImportSpecimenEditorInput.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/DataImportSpecimenEditorInput.java index 0f7bbcc53..55a7c6021 100644 --- a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/DataImportSpecimenEditorInput.java +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/DataImportSpecimenEditorInput.java @@ -25,6 +25,7 @@ import eu.etaxonomy.cdm.ext.biocase.BioCaseQueryServiceWrapper; import eu.etaxonomy.cdm.io.common.CdmDefaultImport; import eu.etaxonomy.cdm.io.specimen.abcd206.in.Abcd206ImportConfigurator; import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase; +import eu.etaxonomy.taxeditor.dataimport.transientServices.TransientCdmRepository; import eu.etaxonomy.taxeditor.store.CdmStore; /** diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientAgentService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientAgentService.java new file mode 100644 index 000000000..425724511 --- /dev/null +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientAgentService.java @@ -0,0 +1,741 @@ +// $Id$ +/** +* Copyright (C) 2013 EDIT +* European Distributed Institute of Taxonomy +* 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. +*/ +package eu.etaxonomy.taxeditor.dataimport.transientServices; + +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.hibernate.LockMode; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.IAgentService; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.agent.Address; +import eu.etaxonomy.cdm.model.agent.AgentBase; +import eu.etaxonomy.cdm.model.agent.Institution; +import eu.etaxonomy.cdm.model.agent.InstitutionalMembership; +import eu.etaxonomy.cdm.model.agent.Person; +import eu.etaxonomy.cdm.model.agent.Team; +import eu.etaxonomy.cdm.model.common.Annotation; +import eu.etaxonomy.cdm.model.common.ISourceable; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.common.UuidAndTitleCache; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.view.AuditEvent; +import eu.etaxonomy.cdm.model.view.AuditEventRecord; +import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientAgentService implements IAgentService { + + private IAgentService defaultAgentService; + + /** + * @param defaultAgentService + */ + public TransientAgentService(IAgentService defaultAgentService) { + this.defaultAgentService = defaultAgentService; + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(AgentBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultAgentService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getAnnotations(AgentBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultAgentService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param code + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#searchInstitutionByCode(java.lang.String) + */ + @Override + public List searchInstitutionByCode(String code) { + return defaultAgentService.searchInstitutionByCode(code); + } + + /** + * @param person + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#getInstitutionalMemberships(eu.etaxonomy.cdm.model.agent.Person, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) { + return defaultAgentService.getInstitutionalMemberships(person, pageSize, pageNumber); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultAgentService.clear(); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(AgentBase t, LockMode lockMode) { + defaultAgentService.lock(t, lockMode); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(AgentBase t, LockMode lockMode, List propertyPaths) { + defaultAgentService.refresh(t, lockMode, propertyPaths); + } + + /** + * @param team + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#getMembers(eu.etaxonomy.cdm.model.agent.Team, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager getMembers(Team team, Integer pageSize, Integer pageNumber) { + return defaultAgentService.getMembers(team, pageSize, pageNumber); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultAgentService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(AgentBase t) { + return defaultAgentService.getNextAuditEvent(t); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getMarkers(AgentBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultAgentService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultAgentService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param agent + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#getAddresses(eu.etaxonomy.cdm.model.agent.AgentBase, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager
getAddresses(AgentBase agent, Integer pageSize, Integer pageNumber) { + return defaultAgentService.getAddresses(agent, pageSize, pageNumber); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(AgentBase t) { + return defaultAgentService.getPreviousAuditEvent(t); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultAgentService.count(clazz); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultAgentService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultAgentService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public AgentBase find(LSID lsid) { + return defaultAgentService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID delete(AgentBase persistentObject) { + return defaultAgentService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultAgentService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultAgentService.exists(uuid); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public AgentBase replace(AgentBase x, AgentBase y) { + return defaultAgentService.replace(x, y); + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultAgentService.find(uuidSet); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(AgentBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultAgentService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public AgentBase find(UUID uuid) { + return defaultAgentService.find(uuid); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#getPersonUuidAndTitleCache() + */ + @Override + public List> getPersonUuidAndTitleCache() { + return defaultAgentService.getPersonUuidAndTitleCache(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#getTeamUuidAndTitleCache() + */ + @Override + public List> getTeamUuidAndTitleCache() { + return defaultAgentService.getTeamUuidAndTitleCache(); + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public AgentBase find(int id) { + return defaultAgentService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(AgentBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultAgentService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultAgentService.countMarkers(clazz, technical); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#getTeamUuidAndNomenclaturalTitle() + */ + @Override + public List> getTeamUuidAndNomenclaturalTitle() { + return defaultAgentService.getTeamUuidAndNomenclaturalTitle(); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultAgentService.findById(idSet); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IAgentService#getInstitutionUuidAndTitleCache() + */ + @Override + public List> getInstitutionUuidAndTitleCache() { + return defaultAgentService.getInstitutionUuidAndTitleCache(); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultAgentService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultAgentService.getSession(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache() + */ + @Override + public List> getUuidAndTitleCache() { + return defaultAgentService.getUuidAndTitleCache(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultAgentService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultAgentService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultAgentService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultAgentService.findByTitle(configurator); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultAgentService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public AgentBase load(UUID uuid) { + return defaultAgentService.load(uuid); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public AgentBase load(UUID uuid, List propertyPaths) { + return defaultAgentService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultAgentService.countByTitle(configurator); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public AgentBase merge(AgentBase transientObject) { + return defaultAgentService.merge(transientObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultAgentService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultAgentService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(AgentBase persistentObject) { + return defaultAgentService.refresh(persistentObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultAgentService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultAgentService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(Collection newInstances) { + return null; + } + + /** + * @param newInstance + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID save(AgentBase newInstance) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(AgentBase transientObject) { + return null; + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(Collection transientObjects) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(AgentBase transientObject) { + return defaultAgentService.update(transientObject); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(AgentBase example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultAgentService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultAgentService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultAgentService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + }; + + + +} diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/TransientCdmRepository.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCdmRepository.java similarity index 93% rename from eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/TransientCdmRepository.java rename to eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCdmRepository.java index 4be8d7286..3cc18f7fe 100644 --- a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/TransientCdmRepository.java +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCdmRepository.java @@ -7,7 +7,7 @@ * 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.taxeditor.dataimport; +package eu.etaxonomy.taxeditor.dataimport.transientServices; import java.util.List; @@ -101,7 +101,7 @@ public class TransientCdmRepository implements ICdmApplicationConfiguration { */ @Override public IAgentService getAgentService() { - return defaultApplicationConfiguration.getAgentService(); + return new TransientAgentService(defaultApplicationConfiguration.getAgentService()); } /** @@ -129,7 +129,7 @@ public class TransientCdmRepository implements ICdmApplicationConfiguration { */ @Override public IClassificationService getClassificationService() { - return defaultApplicationConfiguration.getClassificationService(); + return new TransientClassificationService(defaultApplicationConfiguration.getClassificationService()); } /** @@ -138,7 +138,7 @@ public class TransientCdmRepository implements ICdmApplicationConfiguration { */ @Override public ICollectionService getCollectionService() { - return defaultApplicationConfiguration.getCollectionService(); + return new TransientCollectionService(defaultApplicationConfiguration.getCollectionService()); } /** @@ -165,7 +165,7 @@ public class TransientCdmRepository implements ICdmApplicationConfiguration { */ @Override public IDescriptionService getDescriptionService() { - return defaultApplicationConfiguration.getDescriptionService(); + return new TransientDescriptionService(defaultApplicationConfiguration.getDescriptionService()); } /** @@ -246,7 +246,7 @@ public class TransientCdmRepository implements ICdmApplicationConfiguration { */ @Override public INameService getNameService() { - return defaultApplicationConfiguration.getNameService(); + return new TransientNameService(defaultApplicationConfiguration.getNameService()); } /** @@ -294,7 +294,7 @@ public class TransientCdmRepository implements ICdmApplicationConfiguration { */ @Override public IReferenceService getReferenceService() { - return defaultApplicationConfiguration.getReferenceService(); + return new TransientReferenceService(defaultApplicationConfiguration.getReferenceService()); } /** @@ -312,7 +312,7 @@ public class TransientCdmRepository implements ICdmApplicationConfiguration { */ @Override public ITaxonService getTaxonService() { - return defaultApplicationConfiguration.getTaxonService(); + return new TransientTaxonService(defaultApplicationConfiguration.getTaxonService()); } /** @@ -321,7 +321,7 @@ public class TransientCdmRepository implements ICdmApplicationConfiguration { */ @Override public ITermService getTermService() { - return defaultApplicationConfiguration.getTermService(); + return new TransientTermService(defaultApplicationConfiguration.getTermService()); } /** diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientClassificationService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientClassificationService.java new file mode 100644 index 000000000..c316e5e1b --- /dev/null +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientClassificationService.java @@ -0,0 +1,921 @@ +// $Id$ +/** +* Copyright (C) 2013 EDIT +* European Distributed Institute of Taxonomy +* 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. +*/ +package eu.etaxonomy.taxeditor.dataimport.transientServices; + +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.hibernate.LockMode; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.IClassificationService; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.common.Annotation; +import eu.etaxonomy.cdm.model.common.ISourceable; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.common.UuidAndTitleCache; +import eu.etaxonomy.cdm.model.media.MediaRepresentation; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.name.Rank; +import eu.etaxonomy.cdm.model.taxon.Classification; +import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode; +import eu.etaxonomy.cdm.model.taxon.Taxon; +import eu.etaxonomy.cdm.model.taxon.TaxonNode; +import eu.etaxonomy.cdm.model.view.AuditEvent; +import eu.etaxonomy.cdm.model.view.AuditEventRecord; +import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientClassificationService implements IClassificationService { + + private IClassificationService defaultClassificationService; + + /** + * @param defaultClassificationService + */ + public TransientClassificationService(IClassificationService defaultClassificationService) { + this.defaultClassificationService = defaultClassificationService; + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Classification t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultClassificationService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getAnnotations(Classification annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultClassificationService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTaxonNodeByUuid(java.util.UUID) + */ + @Override + public TaxonNode getTaxonNodeByUuid(UUID uuid) { + return defaultClassificationService.getTaxonNodeByUuid(uuid); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTreeNodeByUuid(java.util.UUID) + */ + @Override + public ITaxonTreeNode getTreeNodeByUuid(UUID uuid) { + return defaultClassificationService.getTreeNodeByUuid(uuid); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultClassificationService.clear(); + } + + /** + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#listClassifications(java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listClassifications(Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultClassificationService.listClassifications(limit, start, orderHints, propertyPaths); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(Classification t, LockMode lockMode) { + defaultClassificationService.lock(t, lockMode); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(Classification t, LockMode lockMode, List propertyPaths) { + defaultClassificationService.refresh(t, lockMode, propertyPaths); + } + + /** + * @param taxon + * @param classificationUuid + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTaxonNodeByTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.UUID, java.util.List) + */ + @Deprecated + @Override + public TaxonNode loadTaxonNodeByTaxon(Taxon taxon, UUID classificationUuid, List propertyPaths) { + return defaultClassificationService.loadTaxonNodeByTaxon(taxon, classificationUuid, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultClassificationService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(Classification t) { + return defaultClassificationService.getNextAuditEvent(t); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getMarkers(Classification annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultClassificationService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultClassificationService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param taxonNode + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List) + */ + @Deprecated + @Override + public TaxonNode loadTaxonNode(TaxonNode taxonNode, List propertyPaths) { + return defaultClassificationService.loadTaxonNode(taxonNode, propertyPaths); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(Classification t) { + return defaultClassificationService.getPreviousAuditEvent(t); + } + + /** + * @param classification + * @param rank + * @param limit + * @param start + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadRankSpecificRootNodes(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Deprecated + @Override + public List loadRankSpecificRootNodes(Classification classification, Rank rank, Integer limit, Integer start, List propertyPaths) { + return defaultClassificationService.loadRankSpecificRootNodes(classification, rank, limit, start, propertyPaths); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultClassificationService.count(clazz); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultClassificationService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public Classification find(LSID lsid) { + return defaultClassificationService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID delete(Classification persistentObject) { + return defaultClassificationService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultClassificationService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultClassificationService.exists(uuid); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public Classification replace(Classification x, Classification y) { + return defaultClassificationService.replace(x, y); + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultClassificationService.find(uuidSet); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(Classification t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultClassificationService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param classification + * @param rank + * @param pageSize + * @param pageIndex + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#listRankSpecificRootNodes(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listRankSpecificRootNodes(Classification classification, Rank rank, Integer pageSize, Integer pageIndex, List propertyPaths) { + return defaultClassificationService.listRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public Classification find(UUID uuid) { + return defaultClassificationService.find(uuid); + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public Classification find(int id) { + return defaultClassificationService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(Classification t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultClassificationService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultClassificationService.countMarkers(clazz, technical); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultClassificationService.findById(idSet); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultClassificationService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @param classification + * @param rank + * @param pageSize + * @param pageIndex + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#pageRankSpecificRootNodes(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager pageRankSpecificRootNodes(Classification classification, Rank rank, Integer pageSize, Integer pageIndex, List propertyPaths) { + return defaultClassificationService.pageRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultClassificationService.getSession(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache() + */ + @Override + public List> getUuidAndTitleCache() { + return defaultClassificationService.getUuidAndTitleCache(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultClassificationService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultClassificationService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxonNode + * @param baseRank + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTreeBranch(eu.etaxonomy.cdm.model.taxon.TaxonNode, eu.etaxonomy.cdm.model.name.Rank, java.util.List) + */ + @Override + public List loadTreeBranch(TaxonNode taxonNode, Rank baseRank, List propertyPaths) { + return defaultClassificationService.loadTreeBranch(taxonNode, baseRank, propertyPaths); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultClassificationService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param classification + * @param baseRank + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTreeBranchToTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.util.List) + */ + @Override + public List loadTreeBranchToTaxon(Taxon taxon, Classification classification, Rank baseRank, List propertyPaths) { + return defaultClassificationService.loadTreeBranchToTaxon(taxon, classification, baseRank, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultClassificationService.findByTitle(configurator); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultClassificationService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public Classification load(UUID uuid) { + return defaultClassificationService.load(uuid); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public Classification load(UUID uuid, List propertyPaths) { + return defaultClassificationService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultClassificationService.countByTitle(configurator); + } + + /** + * @param taxon + * @param classification + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadChildNodesOfTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List) + */ + @Override + public List loadChildNodesOfTaxon(Taxon taxon, Classification classification, List propertyPaths) { + return defaultClassificationService.loadChildNodesOfTaxon(taxon, classification, propertyPaths); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public Classification merge(Classification transientObject) { + return defaultClassificationService.merge(transientObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultClassificationService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultClassificationService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxonNode + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadChildNodesOfTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List) + */ + @Deprecated + @Override + public List loadChildNodesOfTaxonNode(TaxonNode taxonNode, List propertyPaths) { + return defaultClassificationService.loadChildNodesOfTaxonNode(taxonNode, propertyPaths); + } + + /** + * @param classification + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(eu.etaxonomy.cdm.model.taxon.Classification) + */ + @Override + public List> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification) { + return defaultClassificationService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification); + } + + /** + * @param taxon + * @param taxTree + * @param propertyPaths + * @param size + * @param height + * @param widthOrDuration + * @param mimeTypes + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllMediaForChildNodes(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, int, int, int, java.lang.String[]) + */ + @Deprecated + @Override + public Map> getAllMediaForChildNodes(Taxon taxon, Classification taxTree, List propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes) { + return defaultClassificationService.getAllMediaForChildNodes(taxon, taxTree, propertyPaths, size, height, widthOrDuration, mimeTypes); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(Classification persistentObject) { + return defaultClassificationService.refresh(persistentObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultClassificationService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxonNode + * @param propertyPaths + * @param size + * @param height + * @param widthOrDuration + * @param mimeTypes + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllMediaForChildNodes(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List, int, int, int, java.lang.String[]) + */ + @Override + public Map> getAllMediaForChildNodes(TaxonNode taxonNode, List propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes) { + return defaultClassificationService.getAllMediaForChildNodes(taxonNode, propertyPaths, size, height, widthOrDuration, mimeTypes); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultClassificationService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(Collection newInstances) { + return null; + } + + /** + * @param taxonNode + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#removeTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode) + */ + @Deprecated + @Override + public UUID removeTaxonNode(TaxonNode taxonNode) { + return defaultClassificationService.removeTaxonNode(taxonNode); + } + + /** + * @param taxonNode + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode) + */ + @Deprecated + @Override + public UUID saveTaxonNode(TaxonNode taxonNode) { + return null; + } + + /** + * @param newInstance + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID save(Classification newInstance) { + return null; + } + + /** + * @param taxonNodeCollection + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTaxonNodeAll(java.util.Collection) + */ + @Deprecated + @Override + public Map saveTaxonNodeAll(Collection taxonNodeCollection) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(Classification transientObject) { + return null; + } + + /** + * @param treeNode + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#removeTreeNode(eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode) + */ + @Override + public UUID removeTreeNode(ITaxonTreeNode treeNode) { + return defaultClassificationService.removeTreeNode(treeNode); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultClassificationService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param treeNode + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTreeNode(eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode) + */ + @Override + public UUID saveTreeNode(ITaxonTreeNode treeNode) { + return null; + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(Collection transientObjects) { + return null; + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllNodes() + */ + @Override + public List getAllNodes() { + return defaultClassificationService.getAllNodes(); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(Classification transientObject) { + return defaultClassificationService.update(transientObject); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Classification example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultClassificationService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultClassificationService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultClassificationService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + } + + + +} diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCollectionService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCollectionService.java new file mode 100644 index 000000000..33aa4228e --- /dev/null +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientCollectionService.java @@ -0,0 +1,659 @@ +// $Id$ +/** +* Copyright (C) 2013 EDIT +* European Distributed Institute of Taxonomy +* 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. +*/ +package eu.etaxonomy.taxeditor.dataimport.transientServices; + +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.hibernate.LockMode; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.ICollectionService; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.common.Annotation; +import eu.etaxonomy.cdm.model.common.ISourceable; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.common.UuidAndTitleCache; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.occurrence.Collection; +import eu.etaxonomy.cdm.model.view.AuditEvent; +import eu.etaxonomy.cdm.model.view.AuditEventRecord; +import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientCollectionService implements ICollectionService { + + private ICollectionService defaultCollectionService; + + /** + * @param defaultCollectionService + */ + public TransientCollectionService(ICollectionService defaultCollectionService) { + this.defaultCollectionService = defaultCollectionService; + } + + /** + * @param clazz + * @param query + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ICollectionService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String query, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultCollectionService.search(clazz, query, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Collection t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultCollectionService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getAnnotations(Collection annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultCollectionService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultCollectionService.clear(); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(Collection t, LockMode lockMode) { + defaultCollectionService.lock(t, lockMode); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(Collection t, LockMode lockMode, List propertyPaths) { + defaultCollectionService.refresh(t, lockMode, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultCollectionService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(Collection t) { + return defaultCollectionService.getNextAuditEvent(t); + } + + /** + * @param code + * @return + * @see eu.etaxonomy.cdm.api.service.ICollectionService#searchByCode(java.lang.String) + */ + @Override + public List searchByCode(String code) { + return defaultCollectionService.searchByCode(code); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getMarkers(Collection annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultCollectionService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultCollectionService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(Collection t) { + return defaultCollectionService.getPreviousAuditEvent(t); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultCollectionService.count(clazz); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultCollectionService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public Collection find(LSID lsid) { + return defaultCollectionService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID delete(Collection persistentObject) { + return defaultCollectionService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultCollectionService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultCollectionService.exists(uuid); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public Collection replace(Collection x, Collection y) { + return defaultCollectionService.replace(x, y); + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultCollectionService.find(uuidSet); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(Collection t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultCollectionService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public Collection find(UUID uuid) { + return defaultCollectionService.find(uuid); + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public Collection find(int id) { + return defaultCollectionService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(Collection t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultCollectionService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultCollectionService.countMarkers(clazz, technical); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultCollectionService.findById(idSet); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultCollectionService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultCollectionService.getSession(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache() + */ + @Override + public List> getUuidAndTitleCache() { + return defaultCollectionService.getUuidAndTitleCache(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultCollectionService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultCollectionService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultCollectionService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultCollectionService.findByTitle(configurator); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultCollectionService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public Collection load(UUID uuid) { + return defaultCollectionService.load(uuid); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public Collection load(UUID uuid, List propertyPaths) { + return defaultCollectionService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultCollectionService.countByTitle(configurator); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public Collection merge(Collection transientObject) { + return defaultCollectionService.merge(transientObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultCollectionService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultCollectionService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(Collection persistentObject) { + return defaultCollectionService.refresh(persistentObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultCollectionService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultCollectionService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(java.util.Collection newInstances) { + return null; + } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID save(Collection newInstance) { + return null; + } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(Collection transientObject) { + return null; + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(java.util.Collection transientObjects) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(Collection transientObject) { + return defaultCollectionService.update(transientObject); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Collection example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultCollectionService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultCollectionService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultCollectionService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + } + + + +} diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientDescriptionService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientDescriptionService.java new file mode 100644 index 000000000..d48ffe535 --- /dev/null +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientDescriptionService.java @@ -0,0 +1,1093 @@ +// $Id$ +/** +* Copyright (C) 2013 EDIT +* European Distributed Institute of Taxonomy +* 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. +*/ +package eu.etaxonomy.taxeditor.dataimport.transientServices; + +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.hibernate.LockMode; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.DistributionTree; +import eu.etaxonomy.cdm.api.service.IDescriptionService; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.common.Annotation; +import eu.etaxonomy.cdm.model.common.DefinedTerm; +import eu.etaxonomy.cdm.model.common.ISourceable; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Language; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.common.TermVocabulary; +import eu.etaxonomy.cdm.model.common.UuidAndTitleCache; +import eu.etaxonomy.cdm.model.description.DescriptionBase; +import eu.etaxonomy.cdm.model.description.DescriptionElementBase; +import eu.etaxonomy.cdm.model.description.Feature; +import eu.etaxonomy.cdm.model.description.FeatureTree; +import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase; +import eu.etaxonomy.cdm.model.description.TaxonDescription; +import eu.etaxonomy.cdm.model.description.TaxonNameDescription; +import eu.etaxonomy.cdm.model.location.NamedArea; +import eu.etaxonomy.cdm.model.location.NamedAreaLevel; +import eu.etaxonomy.cdm.model.media.Media; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.name.TaxonNameBase; +import eu.etaxonomy.cdm.model.taxon.Taxon; +import eu.etaxonomy.cdm.model.view.AuditEvent; +import eu.etaxonomy.cdm.model.view.AuditEventRecord; +import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientDescriptionService implements IDescriptionService { + + private IDescriptionService defaultDescriptionService; + + /** + * @param defaultDescriptionService + */ + public TransientDescriptionService(IDescriptionService defaultDescriptionService) { + this.defaultDescriptionService = defaultDescriptionService; + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(DescriptionBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultDescriptionService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getAnnotations(DescriptionBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultDescriptionService.clear(); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(DescriptionBase t, LockMode lockMode) { + defaultDescriptionService.lock(t, lockMode); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(DescriptionBase t, LockMode lockMode, List propertyPaths) { + defaultDescriptionService.refresh(t, lockMode, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultDescriptionService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(DescriptionBase t) { + return defaultDescriptionService.getNextAuditEvent(t); + } + + /** + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getDefaultFeatureVocabulary() + */ + @Deprecated + @Override + public TermVocabulary getDefaultFeatureVocabulary() { + return defaultDescriptionService.getDefaultFeatureVocabulary(); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getMarkers(DescriptionBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param uuid + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getFeatureVocabulary(java.util.UUID) + */ + @Deprecated + @Override + public TermVocabulary getFeatureVocabulary(UUID uuid) { + return defaultDescriptionService.getFeatureVocabulary(uuid); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultDescriptionService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(DescriptionBase t) { + return defaultDescriptionService.getPreviousAuditEvent(t); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getDescriptionElementByUuid(java.util.UUID) + */ + @Override + public DescriptionElementBase getDescriptionElementByUuid(UUID uuid) { + return defaultDescriptionService.getDescriptionElementByUuid(uuid); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultDescriptionService.count(clazz); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#loadDescriptionElement(java.util.UUID, java.util.List) + */ + @Override + public DescriptionElementBase loadDescriptionElement(UUID uuid, List propertyPaths) { + return defaultDescriptionService.loadDescriptionElement(uuid, propertyPaths); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultDescriptionService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public DescriptionBase find(LSID lsid) { + return defaultDescriptionService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID delete(DescriptionBase persistentObject) { + return defaultDescriptionService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultDescriptionService.exists(uuid); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public DescriptionBase replace(DescriptionBase x, DescriptionBase y) { + return defaultDescriptionService.replace(x, y); + } + + /** + * @param descriptionElement + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#saveDescriptionElement(eu.etaxonomy.cdm.model.description.DescriptionElementBase) + */ + @Override + public UUID saveDescriptionElement(DescriptionElementBase descriptionElement) { + return null; + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultDescriptionService.find(uuidSet); + } + + /** + * @param descriptionElements + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#saveDescriptionElement(java.util.Collection) + */ + @Override + public Map saveDescriptionElement(Collection descriptionElements) { + return null; + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(DescriptionBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param descriptionElement + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#deleteDescriptionElement(eu.etaxonomy.cdm.model.description.DescriptionElementBase) + */ + @Override + public UUID deleteDescriptionElement(DescriptionElementBase descriptionElement) { + return defaultDescriptionService.deleteDescriptionElement(descriptionElement); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public DescriptionBase find(UUID uuid) { + return defaultDescriptionService.find(uuid); + } + + /** + * @param type + * @param hasMedia + * @param hasText + * @param feature + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#page(java.lang.Class, java.lang.Boolean, java.lang.Boolean, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Boolean hasMedia, Boolean hasText, Set feature, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.page(type, hasMedia, hasText, feature, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public DescriptionBase find(int id) { + return defaultDescriptionService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(DescriptionBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultDescriptionService.countMarkers(clazz, technical); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultDescriptionService.findById(idSet); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultDescriptionService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultDescriptionService.getSession(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache() + */ + @Override + public List> getUuidAndTitleCache() { + return defaultDescriptionService.getUuidAndTitleCache(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultDescriptionService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param type + * @param hasImages + * @param hasText + * @param feature + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#count(java.lang.Class, java.lang.Boolean, java.lang.Boolean, java.util.Set) + */ + @Override + public int count(Class type, Boolean hasImages, Boolean hasText, Set feature) { + return defaultDescriptionService.count(type, hasImages, hasText, feature); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultDescriptionService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param description + * @param features + * @param type + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getDescriptionElements(eu.etaxonomy.cdm.model.description.DescriptionBase, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Deprecated + @Override + public Pager getDescriptionElements(DescriptionBase description, Set features, Class type, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.getDescriptionElements(description, features, type, pageSize, pageNumber, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultDescriptionService.findByTitle(configurator); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultDescriptionService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public DescriptionBase load(UUID uuid) { + return defaultDescriptionService.load(uuid); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public DescriptionBase load(UUID uuid, List propertyPaths) { + return defaultDescriptionService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultDescriptionService.countByTitle(configurator); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public DescriptionBase merge(DescriptionBase transientObject) { + return defaultDescriptionService.merge(transientObject); + } + + /** + * @param description + * @param descriptionType + * @param features + * @param type + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#pageDescriptionElements(eu.etaxonomy.cdm.model.description.DescriptionBase, java.lang.Class, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager pageDescriptionElements(DescriptionBase description, Class descriptionType, Set features, Class type, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.pageDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(DescriptionBase persistentObject) { + return defaultDescriptionService.refresh(persistentObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param description + * @param features + * @param type + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#listDescriptionElements(eu.etaxonomy.cdm.model.description.DescriptionBase, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Deprecated + @Override + public List listDescriptionElements(DescriptionBase description, Set features, Class type, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.listDescriptionElements(description, features, type, pageSize, pageNumber, propertyPaths); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultDescriptionService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(Collection newInstances) { + return null; + } + + /** + * @param newInstance + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID save(DescriptionBase newInstance) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(DescriptionBase transientObject) { + return null; + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(Collection transientObjects) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(DescriptionBase transientObject) { + return defaultDescriptionService.update(transientObject); + } + + /** + * @param description + * @param descriptionType + * @param features + * @param type + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#listDescriptionElements(eu.etaxonomy.cdm.model.description.DescriptionBase, java.lang.Class, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listDescriptionElements(DescriptionBase description, Class descriptionType, Set features, Class type, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.listDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(DescriptionBase example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultDescriptionService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultDescriptionService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getDescriptionElementAnnotations(eu.etaxonomy.cdm.model.description.DescriptionElementBase, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getDescriptionElementAnnotations(DescriptionElementBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.getDescriptionElementAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultDescriptionService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + } + + /** + * @param taxon + * @param scopes + * @param geographicalScope + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#pageTaxonDescriptions(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager pageTaxonDescriptions(Taxon taxon, Set scopes, Set geographicalScope, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.pageTaxonDescriptions(taxon, scopes, geographicalScope, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxon + * @param scopes + * @param geographicalScope + * @param markerTypes + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#pageTaxonDescriptions(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.util.Set, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager pageTaxonDescriptions(Taxon taxon, Set scopes, Set geographicalScope, Set markerTypes, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.pageTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxon + * @param scopes + * @param geographicalScope + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#listTaxonDescriptions(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listTaxonDescriptions(Taxon taxon, Set scopes, Set geographicalScope, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.listTaxonDescriptions(taxon, scopes, geographicalScope, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxon + * @param scopes + * @param geographicalScope + * @param markerTypes + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#listTaxonDescriptions(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.util.Set, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listTaxonDescriptions(Taxon taxon, Set scopes, Set geographicalScope, Set markerTypes, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxonUuid + * @param limitToGalleries + * @param markerTypes + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#listTaxonDescriptionMedia(java.util.UUID, boolean, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listTaxonDescriptionMedia(UUID taxonUuid, boolean limitToGalleries, Set markerTypes, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.listTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxonUuid + * @param limitToGalleries + * @param markerTypes + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#countTaxonDescriptionMedia(java.util.UUID, boolean, java.util.Set) + */ + @Override + public int countTaxonDescriptionMedia(UUID taxonUuid, boolean limitToGalleries, Set markerTypes) { + return defaultDescriptionService.countTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes); + } + + /** + * @param name + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getTaxonNameDescriptions(eu.etaxonomy.cdm.model.name.TaxonNameBase, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getTaxonNameDescriptions(TaxonNameBase name, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.getTaxonNameDescriptions(name, pageSize, pageNumber, propertyPaths); + } + + /** + * @param namedAreas + * @param presence + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#searchDescriptionByDistribution(java.util.Set, eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager searchDescriptionByDistribution(Set namedAreas, PresenceAbsenceTermBase presence, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.searchDescriptionByDistribution(namedAreas, presence, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#searchElements(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager searchElements(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultDescriptionService.searchElements(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param descriptionElement + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getMedia(eu.etaxonomy.cdm.model.description.DescriptionElementBase, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getMedia(DescriptionElementBase descriptionElement, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.getMedia(descriptionElement, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxon + * @param features + * @param type + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getDescriptionElementsForTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Deprecated + @Override + public List getDescriptionElementsForTaxon(Taxon taxon, Set features, Class type, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.getDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxon + * @param features + * @param type + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#listDescriptionElementsForTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listDescriptionElementsForTaxon(Taxon taxon, Set features, Class type, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.listDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxon + * @param features + * @param type + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#pageDescriptionElementsForTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager pageDescriptionElementsForTaxon(Taxon taxon, Set features, Class type, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultDescriptionService.pageDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths); + } + + /** + * @param taxonDescriptions + * @param levels + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getOrderedDistributions(java.util.Set, java.util.Set, java.util.List) + */ + @Override + public DistributionTree getOrderedDistributions(Set taxonDescriptions, Set levels, List propertyPaths) { + return defaultDescriptionService.getOrderedDistributions(taxonDescriptions, levels, propertyPaths); + } + + /** + * @param featureTree + * @param description + * @param preferredLanguages + * @param separator + * @return + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#generateNaturalLanguageDescription(eu.etaxonomy.cdm.model.description.FeatureTree, eu.etaxonomy.cdm.model.description.TaxonDescription, java.util.List, java.lang.String) + */ + @Override + public String generateNaturalLanguageDescription(FeatureTree featureTree, TaxonDescription description, List preferredLanguages, String separator) { + return defaultDescriptionService.generateNaturalLanguageDescription(featureTree, description, preferredLanguages, separator); + } + + /** + * @param description + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#hasStructuredData(eu.etaxonomy.cdm.model.description.DescriptionBase) + */ + @Deprecated + @Override + public boolean hasStructuredData(DescriptionBase description) { + return defaultDescriptionService.hasStructuredData(description); + } + + /** + * @param descriptionElements + * @param targetDescription + * @param isPaste + * @see eu.etaxonomy.cdm.api.service.IDescriptionService#moveDescriptionElementsToDescription(java.util.Collection, eu.etaxonomy.cdm.model.description.DescriptionBase, boolean) + */ + @Override + public void moveDescriptionElementsToDescription(Collection descriptionElements, DescriptionBase targetDescription, boolean isPaste) { + defaultDescriptionService.moveDescriptionElementsToDescription(descriptionElements, targetDescription, isPaste); + } + + +} diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientNameService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientNameService.java new file mode 100644 index 000000000..420c293c0 --- /dev/null +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientNameService.java @@ -0,0 +1,1194 @@ +// $Id$ +/** +* Copyright (C) 2013 EDIT +* European Distributed Institute of Taxonomy +* 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. +*/ +package eu.etaxonomy.taxeditor.dataimport.transientServices; + +import java.io.IOException; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.apache.lucene.index.CorruptIndexException; +import org.apache.lucene.queryParser.ParseException; +import org.hibernate.LockMode; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.INameService; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.config.NameDeletionConfigurator; +import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.api.service.search.DocumentSearchResult; +import eu.etaxonomy.cdm.api.service.search.SearchResult; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.common.Annotation; +import eu.etaxonomy.cdm.model.common.CdmBase; +import eu.etaxonomy.cdm.model.common.ISourceable; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Language; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary; +import eu.etaxonomy.cdm.model.common.ReferencedEntityBase; +import eu.etaxonomy.cdm.model.common.RelationshipBase; +import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction; +import eu.etaxonomy.cdm.model.common.TermVocabulary; +import eu.etaxonomy.cdm.model.common.UuidAndTitleCache; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.name.HomotypicalGroup; +import eu.etaxonomy.cdm.model.name.HybridRelationship; +import eu.etaxonomy.cdm.model.name.HybridRelationshipType; +import eu.etaxonomy.cdm.model.name.NameRelationship; +import eu.etaxonomy.cdm.model.name.NameRelationshipType; +import eu.etaxonomy.cdm.model.name.NomenclaturalStatus; +import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType; +import eu.etaxonomy.cdm.model.name.NonViralName; +import eu.etaxonomy.cdm.model.name.Rank; +import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus; +import eu.etaxonomy.cdm.model.name.TaxonNameBase; +import eu.etaxonomy.cdm.model.name.TypeDesignationBase; +import eu.etaxonomy.cdm.model.view.AuditEvent; +import eu.etaxonomy.cdm.model.view.AuditEventRecord; +import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.TaggedText; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientNameService implements INameService { + + private INameService defaultNameService; + + /** + * + */ + public TransientNameService(INameService defaultNameService) { + this.defaultNameService = defaultNameService; + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(TaxonNameBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultNameService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getAnnotations(TaxonNameBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultNameService.clear(); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(TaxonNameBase t, LockMode lockMode) { + defaultNameService.lock(t, lockMode); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(TaxonNameBase t, LockMode lockMode, List propertyPaths) { + defaultNameService.refresh(t, lockMode, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultNameService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(TaxonNameBase t) { + return defaultNameService.getNextAuditEvent(t); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getMarkers(TaxonNameBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultNameService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(TaxonNameBase t) { + return defaultNameService.getPreviousAuditEvent(t); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultNameService.count(clazz); + } + + /** + * @param name + * @param config + * @return + * @throws ReferencedObjectUndeletableException + * @see eu.etaxonomy.cdm.api.service.INameService#delete(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.api.service.config.NameDeletionConfigurator) + */ + @Override + public UUID delete(TaxonNameBase name, NameDeletionConfigurator config) throws ReferencedObjectUndeletableException { + return defaultNameService.delete(name, config); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultNameService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public TaxonNameBase find(LSID lsid) { + return defaultNameService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID delete(TaxonNameBase persistentObject) { + return defaultNameService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultNameService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultNameService.exists(uuid); + } + + /** + * @param name + * @param typeDesignation + * @see eu.etaxonomy.cdm.api.service.INameService#deleteTypeDesignation(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.name.TypeDesignationBase) + */ + @Override + public void deleteTypeDesignation(TaxonNameBase name, TypeDesignationBase typeDesignation) { + defaultNameService.deleteTypeDesignation(name, typeDesignation); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public TaxonNameBase replace(TaxonNameBase x, TaxonNameBase y) { + return defaultNameService.replace(x, y); + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultNameService.find(uuidSet); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(TaxonNameBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultNameService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param typeDesignationCollection + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#saveTypeDesignationAll(java.util.Collection) + */ + @Override + public Map saveTypeDesignationAll(Collection typeDesignationCollection) { + return null; + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public TaxonNameBase find(UUID uuid) { + return defaultNameService.find(uuid); + } + + /** + * @param referencedEntityCollection + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#saveReferencedEntitiesAll(java.util.Collection) + */ + @Override + public Map saveReferencedEntitiesAll(Collection referencedEntityCollection) { + return null; + } + + /** + * @param homotypicalGroups + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#saveAllHomotypicalGroups(java.util.Collection) + */ + @Override + public Map saveAllHomotypicalGroups(Collection homotypicalGroups) { + return null; + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public TaxonNameBase find(int id) { + return defaultNameService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(TaxonNameBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultNameService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultNameService.countMarkers(clazz, technical); + } + + /** + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getAllNomenclaturalStatus(int, int) + */ + @Override + public List getAllNomenclaturalStatus(int limit, int start) { + return defaultNameService.getAllNomenclaturalStatus(limit, start); + } + + /** + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getAllTypeDesignations(int, int) + */ + @Override + public List getAllTypeDesignations(int limit, int start) { + return defaultNameService.getAllTypeDesignations(limit, start); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultNameService.findById(idSet); + } + + /** + * @param name + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getNamesByName(java.lang.String) + */ + @Override + public List getNamesByName(String name) { + return defaultNameService.getNamesByName(name); + } + + /** + * @param nameCache + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getNamesByNameCache(java.lang.String) + */ + @Override + public List getNamesByNameCache(String nameCache) { + return defaultNameService.getNamesByNameCache(nameCache); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultNameService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultNameService.getSession(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache() + */ + @Override + public List> getUuidAndTitleCache() { + return defaultNameService.getUuidAndTitleCache(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultNameService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param titleCache + * @param matchMode + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#findNamesByTitleCache(java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public List findNamesByTitleCache(String titleCache, MatchMode matchMode, List propertyPaths) { + return defaultNameService.findNamesByTitleCache(titleCache, matchMode, propertyPaths); + } + + /** + * @param nameCache + * @param matchMode + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#findNamesByNameCache(java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public List findNamesByNameCache(String nameCache, MatchMode matchMode, List propertyPaths) { + return defaultNameService.findNamesByNameCache(nameCache, matchMode, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#findNameByUuid(java.util.UUID, java.util.List) + */ + @Override + public NonViralName findNameByUuid(UUID uuid, List propertyPaths) { + return defaultNameService.findNameByUuid(uuid, propertyPaths); + } + + /** + * @param name + * @param sessionObject + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getNamesByName(java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase) + */ + @Override + public List getNamesByName(String name, CdmBase sessionObject) { + return defaultNameService.getNamesByName(name, sessionObject); + } + + /** + * @param name + * @param accuracy + * @param languages + * @param highlightFragments + * @param propertyPaths + * @param maxNoOfResults + * @return + * @throws CorruptIndexException + * @throws IOException + * @throws ParseException + * @see eu.etaxonomy.cdm.api.service.INameService#findByNameFuzzySearch(java.lang.String, float, java.util.List, boolean, java.util.List, int) + */ + @Override + public List> findByNameFuzzySearch(String name, float accuracy, List languages, boolean highlightFragments, List propertyPaths, int maxNoOfResults) throws CorruptIndexException, IOException, ParseException { + return defaultNameService.findByNameFuzzySearch(name, accuracy, languages, highlightFragments, propertyPaths, maxNoOfResults); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultNameService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultNameService.findByTitle(configurator); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultNameService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public TaxonNameBase load(UUID uuid) { + return defaultNameService.load(uuid); + } + + /** + * @param name + * @param accuracy + * @param languages + * @param highlightFragments + * @param maxNoOfResults + * @return + * @throws CorruptIndexException + * @throws IOException + * @throws ParseException + * @see eu.etaxonomy.cdm.api.service.INameService#findByNameFuzzySearch(java.lang.String, float, java.util.List, boolean, int) + */ + @Override + public List findByNameFuzzySearch(String name, float accuracy, List languages, boolean highlightFragments, int maxNoOfResults) throws CorruptIndexException, IOException, ParseException { + return defaultNameService.findByNameFuzzySearch(name, accuracy, languages, highlightFragments, maxNoOfResults); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public TaxonNameBase load(UUID uuid, List propertyPaths) { + return defaultNameService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultNameService.countByTitle(configurator); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public TaxonNameBase merge(TaxonNameBase transientObject) { + return defaultNameService.merge(transientObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param name + * @param accuracy + * @param languages + * @param highlightFragments + * @param maxNoOfResults + * @return + * @throws CorruptIndexException + * @throws IOException + * @throws ParseException + * @see eu.etaxonomy.cdm.api.service.INameService#findByFuzzyNameCacheSearch(java.lang.String, float, java.util.List, boolean, int) + */ + @Override + public List findByFuzzyNameCacheSearch(String name, float accuracy, List languages, boolean highlightFragments, int maxNoOfResults) throws CorruptIndexException, IOException, ParseException { + return defaultNameService.findByFuzzyNameCacheSearch(name, accuracy, languages, highlightFragments, maxNoOfResults); + } + + /** + * @param name + * @param wildcard + * @param languages + * @param highlightFragments + * @param maxNoOfResults + * @return + * @throws CorruptIndexException + * @throws IOException + * @throws ParseException + * @see eu.etaxonomy.cdm.api.service.INameService#findByNameExactSearch(java.lang.String, boolean, java.util.List, boolean, int) + */ + @Override + public List findByNameExactSearch(String name, boolean wildcard, List languages, boolean highlightFragments, int maxNoOfResults) throws CorruptIndexException, IOException, ParseException { + return defaultNameService.findByNameExactSearch(name, wildcard, languages, highlightFragments, maxNoOfResults); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(TaxonNameBase persistentObject) { + return defaultNameService.refresh(persistentObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultNameService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(Collection newInstances) { + return null; + } + + /** + * @param newInstance + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID save(TaxonNameBase newInstance) { + return null; + } + + /** + * @param title + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#findNamesByTitle(java.lang.String) + */ + @Override + public List findNamesByTitle(String title) { + return defaultNameService.findNamesByTitle(title); + } + + /** + * @param title + * @param sessionObject + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#findNamesByTitle(java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase) + */ + @Override + public List findNamesByTitle(String title, CdmBase sessionObject) { + return defaultNameService.findNamesByTitle(title, sessionObject); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(TaxonNameBase transientObject) { + return null; + } + + /** + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getAllHomotypicalGroups(int, int) + */ + @Override + public List getAllHomotypicalGroups(int limit, int start) { + return defaultNameService.getAllHomotypicalGroups(limit, start); + } + + /** + * @param limit + * @param start + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#getAllRelationships(int, int) + */ + @Deprecated + @Override + public List getAllRelationships(int limit, int start) { + return defaultNameService.getAllRelationships(limit, start); + } + + /** + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#getRankVocabulary() + */ + @Deprecated + @Override + public OrderedTermVocabulary getRankVocabulary() { + return defaultNameService.getRankVocabulary(); + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(Collection transientObjects) { + return null; + } + + /** + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#getStatusTypeVocabulary() + */ + @Deprecated + @Override + public TermVocabulary getStatusTypeVocabulary() { + return defaultNameService.getStatusTypeVocabulary(); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(TaxonNameBase transientObject) { + return defaultNameService.update(transientObject); + } + + /** + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#getSpecimenTypeDesignationStatusVocabulary() + */ + @Deprecated + @Override + public TermVocabulary getSpecimenTypeDesignationStatusVocabulary() { + return defaultNameService.getSpecimenTypeDesignationStatusVocabulary(); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(TaxonNameBase example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultNameService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#getSpecimenTypeDesignationVocabulary() + */ + @Deprecated + @Override + public OrderedTermVocabulary getSpecimenTypeDesignationVocabulary() { + return defaultNameService.getSpecimenTypeDesignationVocabulary(); + } + + /** + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#getNameRelationshipTypeVocabulary() + */ + @Deprecated + @Override + public TermVocabulary getNameRelationshipTypeVocabulary() { + return defaultNameService.getNameRelationshipTypeVocabulary(); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultNameService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param name + * @param direction + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#listNameRelationships(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.common.RelationshipBase.Direction, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listNameRelationships(TaxonNameBase name, Direction direction, NameRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.listNameRelationships(name, direction, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultNameService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + } + + /** + * @param name + * @param direction + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#pageNameRelationships(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.common.RelationshipBase.Direction, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager pageNameRelationships(TaxonNameBase name, Direction direction, NameRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.pageNameRelationships(name, direction, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param name + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#listFromNameRelationships(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Deprecated + @Override + public List listFromNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.listFromNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param name + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#pageFromNameRelationships(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Deprecated + @Override + public Pager pageFromNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.pageFromNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param name + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#listToNameRelationships(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Deprecated + @Override + public List listToNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.listToNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param name + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.INameService#pageToNameRelationships(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Deprecated + @Override + public Pager pageToNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.pageToNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param name + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getHybridNames(eu.etaxonomy.cdm.model.name.NonViralName, eu.etaxonomy.cdm.model.name.HybridRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getHybridNames(NonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.getHybridNames(name, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param name + * @param status + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getTypeDesignations(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager getTypeDesignations(TaxonNameBase name, SpecimenTypeDesignationStatus status, Integer pageSize, Integer pageNumber) { + return defaultNameService.getTypeDesignations(name, status, pageSize, pageNumber); + } + + /** + * @param name + * @param status + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getTypeDesignations(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getTypeDesignations(TaxonNameBase name, SpecimenTypeDesignationStatus status, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultNameService.getTypeDesignations(name, status, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uninomial + * @param infraGenericEpithet + * @param specificEpithet + * @param infraspecificEpithet + * @param rank + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#searchNames(java.lang.String, java.lang.String, java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager searchNames(String uninomial, String infraGenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.searchNames(uninomial, infraGenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getUuidAndTitleCacheOfNames() + */ + @Override + public List getUuidAndTitleCacheOfNames() { + return defaultNameService.getUuidAndTitleCacheOfNames(); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#findByName(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByName(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultNameService.findByName(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#findHomotypicalGroup(java.util.UUID) + */ + @Override + public HomotypicalGroup findHomotypicalGroup(UUID uuid) { + return defaultNameService.findHomotypicalGroup(uuid); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.INameService#getTaggedName(java.util.UUID) + */ + @Override + public List getTaggedName(UUID uuid) { + return defaultNameService.getTaggedName(uuid); + } + + +} diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/TransientOccurenceService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientOccurenceService.java similarity index 99% rename from eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/TransientOccurenceService.java rename to eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientOccurenceService.java index 214f629ee..c42ae7f57 100644 --- a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/TransientOccurenceService.java +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientOccurenceService.java @@ -7,7 +7,7 @@ * 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.taxeditor.dataimport; +package eu.etaxonomy.taxeditor.dataimport.transientServices; import java.io.IOException; import java.util.ArrayList; @@ -718,7 +718,10 @@ public class TransientOccurenceService implements IOccurrenceService { */ @Override public Map save(Collection newInstances) { - return defaultService.save(newInstances); + for(SpecimenOrObservationBase unit:newInstances){ + save(unit); + } + return null; } /** @@ -757,7 +760,6 @@ public class TransientOccurenceService implements IOccurrenceService { @Override public UUID saveOrUpdate(SpecimenOrObservationBase transientObject) { units.add(transientObject); - System.out.println(transientObject.getTitleCache()); return null; } @@ -768,7 +770,10 @@ public class TransientOccurenceService implements IOccurrenceService { */ @Override public Map saveOrUpdate(Collection transientObjects) { - return defaultService.saveOrUpdate(transientObjects); + for(SpecimenOrObservationBase unit:transientObjects){ + saveOrUpdate(unit); + } + return null; } /** diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientReferenceService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientReferenceService.java new file mode 100644 index 000000000..cfcaca5e1 --- /dev/null +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientReferenceService.java @@ -0,0 +1,693 @@ +// $Id$ +/** +* Copyright (C) 2013 EDIT +* European Distributed Institute of Taxonomy +* 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. +*/ +package eu.etaxonomy.taxeditor.dataimport.transientServices; + +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.hibernate.LockMode; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.IReferenceService; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.common.Annotation; +import eu.etaxonomy.cdm.model.common.ISourceable; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.common.UuidAndTitleCache; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.reference.Reference; +import eu.etaxonomy.cdm.model.taxon.TaxonBase; +import eu.etaxonomy.cdm.model.view.AuditEvent; +import eu.etaxonomy.cdm.model.view.AuditEventRecord; +import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientReferenceService implements IReferenceService { + + private IReferenceService defaultReferenceService; + + /** + * @param defaultReferenceService + */ + public TransientReferenceService(IReferenceService defaultReferenceService) { + this.defaultReferenceService = defaultReferenceService; + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IReferenceService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultReferenceService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Reference t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultReferenceService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getAnnotations(Reference annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultReferenceService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultReferenceService.clear(); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(Reference t, LockMode lockMode) { + defaultReferenceService.lock(t, lockMode); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(Reference t, LockMode lockMode, List propertyPaths) { + defaultReferenceService.refresh(t, lockMode, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultReferenceService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(Reference t) { + return defaultReferenceService.getNextAuditEvent(t); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getMarkers(Reference annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultReferenceService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IReferenceService#getUuidAndTitle() + */ + @Override + public List> getUuidAndTitle() { + return defaultReferenceService.getUuidAndTitle(); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultReferenceService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(Reference t) { + return defaultReferenceService.getPreviousAuditEvent(t); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IReferenceService#getAllReferencesForPublishing() + */ + @Override + public List getAllReferencesForPublishing() { + return defaultReferenceService.getAllReferencesForPublishing(); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultReferenceService.count(clazz); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IReferenceService#getAllNomenclaturalReferences() + */ + @Override + public List getAllNomenclaturalReferences() { + return defaultReferenceService.getAllNomenclaturalReferences(); + } + + /** + * @param reference + * @param includeSubordinateReferences + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IReferenceService#listCoveredTaxa(eu.etaxonomy.cdm.model.reference.Reference, boolean, java.util.List) + */ + @Override + public List listCoveredTaxa(Reference reference, boolean includeSubordinateReferences, List propertyPaths) { + return defaultReferenceService.listCoveredTaxa(reference, includeSubordinateReferences, propertyPaths); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultReferenceService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public Reference find(LSID lsid) { + return defaultReferenceService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID delete(Reference persistentObject) { + return defaultReferenceService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultReferenceService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultReferenceService.exists(uuid); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public Reference replace(Reference x, Reference y) { + return defaultReferenceService.replace(x, y); + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultReferenceService.find(uuidSet); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(Reference t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultReferenceService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public Reference find(UUID uuid) { + return defaultReferenceService.find(uuid); + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public Reference find(int id) { + return defaultReferenceService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(Reference t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultReferenceService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultReferenceService.countMarkers(clazz, technical); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultReferenceService.findById(idSet); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultReferenceService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultReferenceService.getSession(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache() + */ + @Override + public List> getUuidAndTitleCache() { + return defaultReferenceService.getUuidAndTitleCache(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultReferenceService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultReferenceService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultReferenceService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultReferenceService.findByTitle(configurator); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultReferenceService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public Reference load(UUID uuid) { + return defaultReferenceService.load(uuid); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public Reference load(UUID uuid, List propertyPaths) { + return defaultReferenceService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultReferenceService.countByTitle(configurator); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public Reference merge(Reference transientObject) { + return defaultReferenceService.merge(transientObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultReferenceService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultReferenceService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(Reference persistentObject) { + return defaultReferenceService.refresh(persistentObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultReferenceService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultReferenceService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(Collection newInstances) { + return null; + } + + /** + * @param newInstance + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID save(Reference newInstance) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(Reference transientObject) { + return null; + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(Collection transientObjects) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(Reference transientObject) { + return defaultReferenceService.update(transientObject); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Reference example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultReferenceService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultReferenceService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultReferenceService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + } + + +} diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTaxonService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTaxonService.java new file mode 100644 index 000000000..6c76d93fb --- /dev/null +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTaxonService.java @@ -0,0 +1,1387 @@ +// $Id$ +/** +* Copyright (C) 2013 EDIT +* European Distributed Institute of Taxonomy +* 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. +*/ +package eu.etaxonomy.taxeditor.dataimport.transientServices; + +import java.io.IOException; +import java.util.Collection; +import java.util.EnumSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.apache.lucene.index.CorruptIndexException; +import org.apache.lucene.queryParser.ParseException; +import org.hibernate.LockMode; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.ITaxonService; +import eu.etaxonomy.cdm.api.service.TaxaAndNamesSearchMode; +import eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator; +import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator; +import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException; +import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.api.service.search.LuceneMultiSearchException; +import eu.etaxonomy.cdm.api.service.search.SearchResult; +import eu.etaxonomy.cdm.api.service.util.TaxonRelationshipEdge; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.common.Annotation; +import eu.etaxonomy.cdm.model.common.ISourceable; +import eu.etaxonomy.cdm.model.common.IdentifiableEntity; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Language; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary; +import eu.etaxonomy.cdm.model.common.RelationshipBase; +import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction; +import eu.etaxonomy.cdm.model.common.UuidAndTitleCache; +import eu.etaxonomy.cdm.model.description.DescriptionElementBase; +import eu.etaxonomy.cdm.model.description.Feature; +import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase; +import eu.etaxonomy.cdm.model.location.NamedArea; +import eu.etaxonomy.cdm.model.media.Media; +import eu.etaxonomy.cdm.model.media.MediaRepresentation; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.name.HomotypicalGroup; +import eu.etaxonomy.cdm.model.name.Rank; +import eu.etaxonomy.cdm.model.name.TaxonNameBase; +import eu.etaxonomy.cdm.model.reference.Reference; +import eu.etaxonomy.cdm.model.taxon.Classification; +import eu.etaxonomy.cdm.model.taxon.Synonym; +import eu.etaxonomy.cdm.model.taxon.SynonymRelationship; +import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType; +import eu.etaxonomy.cdm.model.taxon.Taxon; +import eu.etaxonomy.cdm.model.taxon.TaxonBase; +import eu.etaxonomy.cdm.model.taxon.TaxonRelationship; +import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType; +import eu.etaxonomy.cdm.model.view.AuditEvent; +import eu.etaxonomy.cdm.model.view.AuditEventRecord; +import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort; +import eu.etaxonomy.cdm.persistence.fetch.CdmFetch; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientTaxonService implements ITaxonService { + + private ITaxonService defaultTaxonService; + + /** + * @param defaultTaxonService + */ + public TransientTaxonService(ITaxonService defaultTaxonService) { + this.defaultTaxonService = defaultTaxonService; + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(TaxonBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultTaxonService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getAnnotations(TaxonBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultTaxonService.clear(); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(TaxonBase t, LockMode lockMode) { + defaultTaxonService.lock(t, lockMode); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(TaxonBase t, LockMode lockMode, List propertyPaths) { + defaultTaxonService.refresh(t, lockMode, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultTaxonService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(TaxonBase t) { + return defaultTaxonService.getNextAuditEvent(t); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getMarkers(TaxonBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultTaxonService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(TaxonBase t) { + return defaultTaxonService.getPreviousAuditEvent(t); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultTaxonService.count(clazz); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultTaxonService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public TaxonBase find(LSID lsid) { + return defaultTaxonService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID delete(TaxonBase persistentObject) { + return defaultTaxonService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultTaxonService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultTaxonService.exists(uuid); + } + + /** + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllSynonyms(int, int) + */ + @Override + public List getAllSynonyms(int limit, int start) { + return defaultTaxonService.getAllSynonyms(limit, start); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public TaxonBase replace(TaxonBase x, TaxonBase y) { + return defaultTaxonService.replace(x, y); + } + + /** + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllTaxa(int, int) + */ + @Override + public List getAllTaxa(int limit, int start) { + return defaultTaxonService.getAllTaxa(limit, start); + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultTaxonService.find(uuidSet); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(TaxonBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultTaxonService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param sec + * @param cdmFetch + * @param onlyWithChildren + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference, eu.etaxonomy.cdm.persistence.fetch.CdmFetch, boolean) + */ + @Deprecated + @Override + public List getRootTaxa(Reference sec, CdmFetch cdmFetch, boolean onlyWithChildren) { + return defaultTaxonService.getRootTaxa(sec, cdmFetch, onlyWithChildren); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public TaxonBase find(UUID uuid) { + return defaultTaxonService.find(uuid); + } + + /** + * @param rank + * @param sec + * @param onlyWithChildren + * @param withMisapplications + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.name.Rank, eu.etaxonomy.cdm.model.reference.Reference, boolean, boolean, java.util.List) + */ + @Deprecated + @Override + public List getRootTaxa(Rank rank, Reference sec, boolean onlyWithChildren, boolean withMisapplications, List propertyPaths) { + return defaultTaxonService.getRootTaxa(rank, sec, onlyWithChildren, withMisapplications, propertyPaths); + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public TaxonBase find(int id) { + return defaultTaxonService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(TaxonBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultTaxonService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultTaxonService.countMarkers(clazz, technical); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultTaxonService.findById(idSet); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultTaxonService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultTaxonService.getSession(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache() + */ + @Override + public List> getUuidAndTitleCache() { + return defaultTaxonService.getUuidAndTitleCache(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultTaxonService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllRelationships(int, int) + */ + @Override + public List getAllRelationships(int limit, int start) { + return defaultTaxonService.getAllRelationships(limit, start); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getTaxonRelationshipTypeVocabulary() + */ + @Deprecated + @Override + public OrderedTermVocabulary getTaxonRelationshipTypeVocabulary() { + return defaultTaxonService.getTaxonRelationshipTypeVocabulary(); + } + + /** + * @param name + * @param sec + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#searchTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference) + */ + @Override + public List searchTaxaByName(String name, Reference sec) { + return defaultTaxonService.searchTaxaByName(name, sec); + } + + /** + * @param synonym + * @param acceptedTaxon + * @see eu.etaxonomy.cdm.api.service.ITaxonService#swapSynonymAndAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon) + */ + @Override + public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon) { + defaultTaxonService.swapSynonymAndAcceptedTaxon(synonym, acceptedTaxon); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultTaxonService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultTaxonService.findByTitle(configurator); + } + + /** + * @param synonym + * @param acceptedTaxon + * @param deleteSynonym + * @param copyCitationInfo + * @param citation + * @param microCitation + * @return + * @throws HomotypicalGroupChangeException + * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String) + */ + @Override + public Taxon changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean deleteSynonym, boolean copyCitationInfo, Reference citation, String microCitation) throws HomotypicalGroupChangeException { + return defaultTaxonService.changeSynonymToAcceptedTaxon(synonym, acceptedTaxon, deleteSynonym, copyCitationInfo, citation, microCitation); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultTaxonService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public TaxonBase load(UUID uuid) { + return defaultTaxonService.load(uuid); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public TaxonBase load(UUID uuid, List propertyPaths) { + return defaultTaxonService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultTaxonService.countByTitle(configurator); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public TaxonBase merge(TaxonBase transientObject) { + return defaultTaxonService.merge(transientObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(TaxonBase persistentObject) { + return defaultTaxonService.refresh(persistentObject); + } + + /** + * @param synonym + * @param toTaxon + * @param taxonRelationshipType + * @param reference + * @param microReference + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToRelatedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String) + */ + @Override + public Taxon changeSynonymToRelatedTaxon(Synonym synonym, Taxon toTaxon, TaxonRelationshipType taxonRelationshipType, Reference reference, String microReference) { + return defaultTaxonService.changeSynonymToRelatedTaxon(synonym, toTaxon, taxonRelationshipType, reference, microReference); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultTaxonService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(Collection newInstances) { + return null; + } + + /** + * @param syn + * @param taxon + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonymRelationships(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon) + */ + @Override + public long deleteSynonymRelationships(Synonym syn, Taxon taxon) { + return defaultTaxonService.deleteSynonymRelationships(syn, taxon); + } + + /** + * @param newInstance + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID save(TaxonBase newInstance) { + return null; + } + + /** + * @param taxon + * @param config + * @throws ReferencedObjectUndeletableException + * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator) + */ + @Override + public void deleteTaxon(Taxon taxon, TaxonDeletionConfigurator config) throws ReferencedObjectUndeletableException { + defaultTaxonService.deleteTaxon(taxon, config); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(TaxonBase transientObject) { + return null; + } + + /** + * @param synonym + * @param newHomotypicalGroup + * @param targetTaxon + * @param removeFromOtherTaxa + * @param setBasionymRelationIfApplicable + * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeHomotypicalGroupOfSynonym(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.name.HomotypicalGroup, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean) + */ + @Override + public void changeHomotypicalGroupOfSynonym(Synonym synonym, HomotypicalGroup newHomotypicalGroup, Taxon targetTaxon, boolean removeFromOtherTaxa, boolean setBasionymRelationIfApplicable) { + defaultTaxonService.changeHomotypicalGroupOfSynonym(synonym, newHomotypicalGroup, targetTaxon, removeFromOtherTaxa, setBasionymRelationIfApplicable); + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(Collection transientObjects) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(TaxonBase transientObject) { + return defaultTaxonService.update(transientObject); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(TaxonBase example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultTaxonService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @param oldSynonymRelation + * @param newTaxon + * @param moveHomotypicGroup + * @param newSynonymRelationshipType + * @param newReference + * @param newReferenceDetail + * @param keepReference + * @return + * @throws HomotypicalGroupChangeException + * @see eu.etaxonomy.cdm.api.service.ITaxonService#moveSynonymToAnotherTaxon(eu.etaxonomy.cdm.model.taxon.SynonymRelationship, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String, boolean) + */ + @Override + public SynonymRelationship moveSynonymToAnotherTaxon(SynonymRelationship oldSynonymRelation, Taxon newTaxon, boolean moveHomotypicGroup, SynonymRelationshipType newSynonymRelationshipType, Reference newReference, String newReferenceDetail, boolean keepReference) throws HomotypicalGroupChangeException { + return defaultTaxonService.moveSynonymToAnotherTaxon(oldSynonymRelation, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultTaxonService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultTaxonService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + } + + /** + * @param taxon + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#listToTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.listToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#pageToTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager pageToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.pageToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#listFromTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.listFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#pageFromTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager pageFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.pageFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param includeRelationships + * @param maxDepth + * @param limit + * @param start + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#listRelatedTaxa(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.lang.Integer, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Set listRelatedTaxa(Taxon taxon, Set includeRelationships, Integer maxDepth, Integer limit, Integer start, List propertyPaths) { + return defaultTaxonService.listRelatedTaxa(taxon, includeRelationships, maxDepth, limit, start, propertyPaths); + } + + /** + * @param taxonBase + * @param limit + * @param start + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#listClassifications(eu.etaxonomy.cdm.model.taxon.TaxonBase, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listClassifications(TaxonBase taxonBase, Integer limit, Integer start, List propertyPaths) { + return defaultTaxonService.listClassifications(taxonBase, limit, start, propertyPaths); + } + + /** + * @param synonym + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getSynonyms(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getSynonyms(Synonym synonym, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.getSynonyms(synonym, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getSynonyms(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getSynonyms(Taxon taxon, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.getSynonyms(taxon, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHomotypicSynonymsByHomotypicGroup(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List) + */ + @Override + public List getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List propertyPaths) { + return defaultTaxonService.getHomotypicSynonymsByHomotypicGroup(taxon, propertyPaths); + } + + /** + * @param taxon + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHeterotypicSynonymyGroups(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List) + */ + @Override + public List> getHeterotypicSynonymyGroups(Taxon taxon, List propertyPaths) { + return defaultTaxonService.getHeterotypicSynonymyGroups(taxon, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTaxonService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param uninomial + * @param infragenericEpithet + * @param specificEpithet + * @param infraspecificEpithet + * @param rank + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByName(java.lang.Class, java.lang.String, java.lang.String, java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager findTaxaByName(Class clazz, String uninomial, String infragenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize, Integer pageNumber) { + return defaultTaxonService.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber); + } + + /** + * @param clazz + * @param uninomial + * @param infragenericEpithet + * @param specificEpithet + * @param infraspecificEpithet + * @param rank + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#listTaxaByName(java.lang.Class, java.lang.String, java.lang.String, java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer) + */ + @Override + public List listTaxaByName(Class clazz, String uninomial, String infragenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize, Integer pageNumber) { + return defaultTaxonService.listTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNames(eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator) + */ + @Override + public Pager findTaxaAndNames(IFindTaxaAndNamesConfigurator configurator) { + return defaultTaxonService.findTaxaAndNames(configurator); + } + + /** + * @param queryString + * @param classification + * @param languages + * @param highlightFragments + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @throws CorruptIndexException + * @throws IOException + * @throws ParseException + * @throws LuceneMultiSearchException + * @deprecated + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByEverythingFullText(java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Deprecated + @Override + public Pager> findByEverythingFullText(String queryString, Classification classification, List languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) throws CorruptIndexException, IOException, ParseException, LuceneMultiSearchException { + return defaultTaxonService.findByEverythingFullText(queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param classification + * @param languages + * @param highlightFragments + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @throws CorruptIndexException + * @throws IOException + * @throws ParseException + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByFullText(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager> findByFullText(Class clazz, String queryString, Classification classification, List languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) throws CorruptIndexException, IOException, ParseException { + return defaultTaxonService.findByFullText(clazz, queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param areaFilter + * @param statusFilter + * @param classification + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @throws IOException + * @throws ParseException + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByDistribution(java.util.List, java.util.List, eu.etaxonomy.cdm.model.taxon.Classification, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager> findByDistribution(List areaFilter, List> statusFilter, Classification classification, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) throws IOException, ParseException { + return defaultTaxonService.findByDistribution(areaFilter, statusFilter, classification, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param searchModes + * @param queryString + * @param classification + * @param namedAreas + * @param distributionStatus + * @param languages + * @param highlightFragments + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @throws CorruptIndexException + * @throws IOException + * @throws ParseException + * @throws LuceneMultiSearchException + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNamesByFullText(java.util.EnumSet, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.Set, java.util.Set, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager> findTaxaAndNamesByFullText(EnumSet searchModes, String queryString, Classification classification, Set namedAreas, Set> distributionStatus, List languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) throws CorruptIndexException, IOException, ParseException, LuceneMultiSearchException { + return defaultTaxonService.findTaxaAndNamesByFullText(searchModes, queryString, classification, namedAreas, distributionStatus, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param classification + * @param features + * @param languages + * @param highlightFragments + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @throws CorruptIndexException + * @throws IOException + * @throws ParseException + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByDescriptionElementFullText(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager> findByDescriptionElementFullText(Class clazz, String queryString, Classification classification, List features, List languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) throws CorruptIndexException, IOException, ParseException { + return defaultTaxonService.findByDescriptionElementFullText(clazz, queryString, classification, features, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param size + * @param height + * @param widthOrDuration + * @param mimeTypes + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllMedia(eu.etaxonomy.cdm.model.taxon.Taxon, int, int, int, java.lang.String[]) + */ + @Deprecated + @Override + public List getAllMedia(Taxon taxon, int size, int height, int widthOrDuration, String[] mimeTypes) { + return defaultTaxonService.getAllMedia(taxon, size, height, widthOrDuration, mimeTypes); + } + + /** + * @param taxon + * @param includeRelationships + * @param limitToGalleries + * @param propertyPath + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.ITaxonService#listTaxonDescriptionMedia(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, boolean, java.util.List) + */ + @Deprecated + @Override + public List listTaxonDescriptionMedia(Taxon taxon, Set includeRelationships, boolean limitToGalleries, List propertyPath) { + return defaultTaxonService.listTaxonDescriptionMedia(taxon, includeRelationships, limitToGalleries, propertyPath); + } + + /** + * @param taxon + * @param includeRelationships + * @param limitToGalleries + * @param includeTaxonDescriptions + * @param includeOccurrences + * @param includeTaxonNameDescriptions + * @param propertyPath + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#listMedia(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.lang.Boolean, java.lang.Boolean, java.lang.Boolean, java.lang.Boolean, java.util.List) + */ + @Override + public List listMedia(Taxon taxon, Set includeRelationships, Boolean limitToGalleries, Boolean includeTaxonDescriptions, Boolean includeOccurrences, Boolean includeTaxonNameDescriptions, List propertyPath) { + return defaultTaxonService.listMedia(taxon, includeRelationships, limitToGalleries, includeTaxonDescriptions, includeOccurrences, includeTaxonNameDescriptions, propertyPath); + } + + /** + * @param listOfIDs + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByID(java.util.Set) + */ + @Override + public List findTaxaByID(Set listOfIDs) { + return defaultTaxonService.findTaxaByID(listOfIDs); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxonByUuid(java.util.UUID, java.util.List) + */ + @Override + public TaxonBase findTaxonByUuid(UUID uuid, List propertyPaths) { + return defaultTaxonService.findTaxonByUuid(uuid, propertyPaths); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#countAllRelationships() + */ + @Override + public int countAllRelationships() { + return defaultTaxonService.countAllRelationships(); + } + + /** + * @param propertyPath + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNames(java.util.List) + */ + @Override + public List findIdenticalTaxonNames(List propertyPath) { + return defaultTaxonService.findIdenticalTaxonNames(propertyPath); + } + + /** + * @param propertyPath + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNameIds(java.util.List) + */ + @Override + public List findIdenticalTaxonNameIds(List propertyPath) { + return defaultTaxonService.findIdenticalTaxonNameIds(propertyPath); + } + + /** + * @param name + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getPhylumName(eu.etaxonomy.cdm.model.name.TaxonNameBase) + */ + @Override + public String getPhylumName(TaxonNameBase name) { + return defaultTaxonService.getPhylumName(name); + } + + /** + * @param syn + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonymRelationships(eu.etaxonomy.cdm.model.taxon.Synonym) + */ + @Override + public long deleteSynonymRelationships(Synonym syn) { + return defaultTaxonService.deleteSynonymRelationships(syn); + } + + /** + * @param synonym + * @param taxon + * @param removeNameIfPossible + * @param newHomotypicGroupIfNeeded + * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonym(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean) + */ + @Override + public void deleteSynonym(Synonym synonym, Taxon taxon, boolean removeNameIfPossible, boolean newHomotypicGroupIfNeeded) { + defaultTaxonService.deleteSynonym(synonym, taxon, removeNameIfPossible, newHomotypicGroupIfNeeded); + } + + /** + * @param taxonBase + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @param direction + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#listSynonymRelationships(eu.etaxonomy.cdm.model.taxon.TaxonBase, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List, eu.etaxonomy.cdm.model.common.RelationshipBase.Direction) + */ + @Override + public List listSynonymRelationships(TaxonBase taxonBase, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths, Direction direction) { + return defaultTaxonService.listSynonymRelationships(taxonBase, type, pageSize, pageNumber, orderHints, propertyPaths, direction); + } + + /** + * @param taxonName + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingTaxon(java.lang.String) + */ + @Override + public Taxon findBestMatchingTaxon(String taxonName) { + return defaultTaxonService.findBestMatchingTaxon(taxonName); + } + + /** + * @param config + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingTaxon(eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator) + */ + @Override + public Taxon findBestMatchingTaxon(MatchingTaxonConfigurator config) { + return defaultTaxonService.findBestMatchingTaxon(config); + } + + /** + * @param taxonName + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingSynonym(java.lang.String) + */ + @Override + public Synonym findBestMatchingSynonym(String taxonName) { + return defaultTaxonService.findBestMatchingSynonym(taxonName); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getUuidAndTitleCacheTaxon() + */ + @Override + public List> getUuidAndTitleCacheTaxon() { + return defaultTaxonService.getUuidAndTitleCacheTaxon(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#getUuidAndTitleCacheSynonym() + */ + @Override + public List> getUuidAndTitleCacheSynonym() { + return defaultTaxonService.getUuidAndTitleCacheSynonym(); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNamesForEditor(eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator) + */ + @Override + public List> findTaxaAndNamesForEditor(IFindTaxaAndNamesConfigurator configurator) { + return defaultTaxonService.findTaxaAndNamesForEditor(configurator); + } + + /** + * @param taxon + * @param tree + * @param type + * @param doWithMisappliedNames + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#createInferredSynonyms(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, boolean) + */ + @Override + public List createInferredSynonyms(Taxon taxon, Classification tree, SynonymRelationshipType type, boolean doWithMisappliedNames) { + return defaultTaxonService.createInferredSynonyms(taxon, tree, type, doWithMisappliedNames); + } + + /** + * @param taxon + * @param tree + * @param doWithMisappliedNames + * @return + * @see eu.etaxonomy.cdm.api.service.ITaxonService#createAllInferredSynonyms(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, boolean) + */ + @Override + public List createAllInferredSynonyms(Taxon taxon, Classification tree, boolean doWithMisappliedNames) { + return defaultTaxonService.createAllInferredSynonyms(taxon, tree, doWithMisappliedNames); + } + + + +} diff --git a/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTermService.java b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTermService.java new file mode 100644 index 000000000..1dfb05d49 --- /dev/null +++ b/eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/dataimport/transientServices/TransientTermService.java @@ -0,0 +1,856 @@ +// $Id$ +/** +* Copyright (C) 2013 EDIT +* European Distributed Institute of Taxonomy +* 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. +*/ +package eu.etaxonomy.taxeditor.dataimport.transientServices; + +import java.net.URI; +import java.util.Collection; +import java.util.Enumeration; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.hibernate.LockMode; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.DeleteResult; +import eu.etaxonomy.cdm.api.service.ITermService; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.config.TermDeletionConfigurator; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.common.Annotation; +import eu.etaxonomy.cdm.model.common.DefinedTermBase; +import eu.etaxonomy.cdm.model.common.ISourceable; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Language; +import eu.etaxonomy.cdm.model.common.LanguageString; +import eu.etaxonomy.cdm.model.common.LanguageStringBase; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.common.Representation; +import eu.etaxonomy.cdm.model.common.UuidAndTitleCache; +import eu.etaxonomy.cdm.model.location.NamedArea; +import eu.etaxonomy.cdm.model.location.NamedAreaLevel; +import eu.etaxonomy.cdm.model.location.NamedAreaType; +import eu.etaxonomy.cdm.model.media.Media; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.view.AuditEvent; +import eu.etaxonomy.cdm.model.view.AuditEventRecord; +import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientTermService implements ITermService { + + private ITermService defaultTermService; + + /** + * @param defaultTermService + */ + public TransientTermService(ITermService defaultTermService) { + this.defaultTermService = defaultTermService; + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(DefinedTermBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultTermService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getAnnotations(DefinedTermBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTermService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultTermService.clear(); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(DefinedTermBase t, LockMode lockMode) { + defaultTermService.lock(t, lockMode); + } + + /** + * @param uri + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getByUri(java.net.URI) + */ + @Override + public DefinedTermBase getByUri(URI uri) { + return defaultTermService.getByUri(uri); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(DefinedTermBase t, LockMode lockMode, List propertyPaths) { + defaultTermService.refresh(t, lockMode, propertyPaths); + } + + /** + * @param languageData + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#saveLanguageData(eu.etaxonomy.cdm.model.common.LanguageStringBase) + */ + @Override + public UUID saveLanguageData(LanguageStringBase languageData) { + return null; + } + + /** + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getAllLanguageStrings(int, int) + */ + @Override + public List getAllLanguageStrings(int limit, int start) { + return defaultTermService.getAllLanguageStrings(limit, start); + } + + /** + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getAllRepresentations(int, int) + */ + @Override + public List getAllRepresentations(int limit, int start) { + return defaultTermService.getAllRepresentations(limit, start); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultTermService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(DefinedTermBase t) { + return defaultTermService.getNextAuditEvent(t); + } + + /** + * @param iso639 + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getLanguageByIso(java.lang.String) + */ + @Override + public Language getLanguageByIso(String iso639) { + return defaultTermService.getLanguageByIso(iso639); + } + + /** + * @param locales + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getLanguagesByLocale(java.util.Enumeration) + */ + @Override + public List getLanguagesByLocale(Enumeration locales) { + return defaultTermService.getLanguagesByLocale(locales); + } + + /** + * @param tdwgAbbreviation + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getAreaByTdwgAbbreviation(java.lang.String) + */ + @Override + public NamedArea getAreaByTdwgAbbreviation(String tdwgAbbreviation) { + return defaultTermService.getAreaByTdwgAbbreviation(tdwgAbbreviation); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager getMarkers(DefinedTermBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTermService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param definedTerm + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getMedia(eu.etaxonomy.cdm.model.common.DefinedTermBase, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager getMedia(DefinedTermBase definedTerm, Integer pageSize, Integer pageNumber) { + return defaultTermService.getMedia(definedTerm, pageSize, pageNumber); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultTermService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(DefinedTermBase t) { + return defaultTermService.getPreviousAuditEvent(t); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultTermService.count(clazz); + } + + /** + * @param level + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#list(eu.etaxonomy.cdm.model.location.NamedAreaLevel, eu.etaxonomy.cdm.model.location.NamedAreaType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTermService.list(level, type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultTermService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public DefinedTermBase find(LSID lsid) { + return defaultTermService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID delete(DefinedTermBase persistentObject) { + return defaultTermService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultTermService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultTermService.exists(uuid); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public DefinedTermBase replace(DefinedTermBase x, DefinedTermBase y) { + return defaultTermService.replace(x, y); + } + + /** + * @param definedTerm + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getGeneralizationOf(eu.etaxonomy.cdm.model.common.DefinedTermBase, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager getGeneralizationOf(T definedTerm, Integer pageSize, Integer pageNumber) { + return defaultTermService.getGeneralizationOf(definedTerm, pageSize, pageNumber); + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultTermService.find(uuidSet); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(DefinedTermBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultTermService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public DefinedTermBase find(UUID uuid) { + return defaultTermService.find(uuid); + } + + /** + * @param definedTerms + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getPartOf(java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getPartOf(Set definedTerms, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultTermService.getPartOf(definedTerms, pageSize, pageNumber, propertyPaths); + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public DefinedTermBase find(int id) { + return defaultTermService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(DefinedTermBase t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultTermService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultTermService.countMarkers(clazz, technical); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultTermService.findById(idSet); + } + + /** + * @param definedTerms + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#getIncludes(java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getIncludes(Set definedTerms, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultTermService.getIncludes(definedTerms, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultTermService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultTermService.getSession(); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache() + */ + @Override + public List> getUuidAndTitleCache() { + return defaultTermService.getUuidAndTitleCache(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultTermService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param label + * @param clazz + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#findByRepresentationText(java.lang.String, java.lang.Class, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager findByRepresentationText(String label, Class clazz, Integer pageSize, Integer pageNumber) { + return defaultTermService.findByRepresentationText(label, clazz, pageSize, pageNumber); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTermService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param abbrev + * @param clazz + * @param pageSize + * @param pageNumber + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#findByRepresentationAbbreviation(java.lang.String, java.lang.Class, java.lang.Integer, java.lang.Integer) + */ + @Override + public Pager findByRepresentationAbbreviation(String abbrev, Class clazz, Integer pageSize, Integer pageNumber) { + return defaultTermService.findByRepresentationAbbreviation(abbrev, clazz, pageSize, pageNumber); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultTermService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#listByTermClass(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTermClass(Class clazz, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultTermService.listByTermClass(clazz, limit, start, orderHints, propertyPaths); + } + + /** + * @param term + * @param config + * @return + * @see eu.etaxonomy.cdm.api.service.ITermService#delete(eu.etaxonomy.cdm.model.common.DefinedTermBase, eu.etaxonomy.cdm.api.service.config.TermDeletionConfigurator) + */ + @Override + public DeleteResult delete(DefinedTermBase term, TermDeletionConfigurator config) { + return defaultTermService.delete(term, config); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultTermService.findByTitle(configurator); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultTermService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public DefinedTermBase load(UUID uuid) { + return defaultTermService.load(uuid); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public DefinedTermBase load(UUID uuid, List propertyPaths) { + return defaultTermService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultTermService.countByTitle(configurator); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public DefinedTermBase merge(DefinedTermBase transientObject) { + return defaultTermService.merge(transientObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTermService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTermService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(DefinedTermBase persistentObject) { + return defaultTermService.refresh(persistentObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTermService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultTermService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(Collection newInstances) { + return null; + } + + /** + * @param newInstance + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID save(DefinedTermBase newInstance) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(DefinedTermBase transientObject) { + return null; + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultTermService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(Collection transientObjects) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(DefinedTermBase transientObject) { + return defaultTermService.update(transientObject); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(DefinedTermBase example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultTermService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultTermService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultTermService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + } + + + + +} -- 2.34.1