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.DefinedTerm;
import eu.etaxonomy.cdm.model.common.ISourceable;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.LSID;
*/
public class TransientAgentService implements IAgentService {
- private IAgentService defaultAgentService;
+ private IAgentService defaultService;
/**
* @param defaultAgentService
*/
public TransientAgentService(IAgentService defaultAgentService) {
- this.defaultAgentService = defaultAgentService;
+ this.defaultService = defaultAgentService;
}
/**
*/
@Override
public Pager<AuditEventRecord<AgentBase>> pageAuditEvents(AgentBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
- return defaultAgentService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
+ return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
}
/**
*/
@Override
public Pager<Annotation> getAnnotations(AgentBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<Institution> searchInstitutionByCode(String code) {
- return defaultAgentService.searchInstitutionByCode(code);
+ return defaultService.searchInstitutionByCode(code);
}
/**
*/
@Override
public Pager<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) {
- return defaultAgentService.getInstitutionalMemberships(person, pageSize, pageNumber);
+ return defaultService.getInstitutionalMemberships(person, pageSize, pageNumber);
}
/**
*/
@Override
public void clear() {
- defaultAgentService.clear();
+ defaultService.clear();
}
/**
*/
@Override
public void lock(AgentBase t, LockOptions lockOptions) {
- defaultAgentService.lock(t, lockOptions);
+ defaultService.lock(t, lockOptions);
}
/**
*/
@Override
public void refresh(AgentBase t, LockOptions lockOptions, List<String> propertyPaths) {
- defaultAgentService.refresh(t, lockOptions, propertyPaths);
+ defaultService.refresh(t, lockOptions, propertyPaths);
}
/**
*/
@Override
public Pager<Person> getMembers(Team team, Integer pageSize, Integer pageNumber) {
- return defaultAgentService.getMembers(team, pageSize, pageNumber);
+ return defaultService.getMembers(team, pageSize, pageNumber);
}
/**
*/
@Override
public void updateTitleCache() {
- defaultAgentService.updateTitleCache();
+ defaultService.updateTitleCache();
}
/**
*/
@Override
public AuditEventRecord<AgentBase> getNextAuditEvent(AgentBase t) {
- return defaultAgentService.getNextAuditEvent(t);
+ return defaultService.getNextAuditEvent(t);
}
/**
*/
@Override
public Pager<Marker> getMarkers(AgentBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache(Class<? extends AgentBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<AgentBase> cacheStrategy, IProgressMonitor monitor) {
- defaultAgentService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
+ defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
}
/**
*/
@Override
public Pager<Address> getAddresses(AgentBase agent, Integer pageSize, Integer pageNumber) {
- return defaultAgentService.getAddresses(agent, pageSize, pageNumber);
+ return defaultService.getAddresses(agent, pageSize, pageNumber);
}
/**
*/
@Override
public AuditEventRecord<AgentBase> getPreviousAuditEvent(AgentBase t) {
- return defaultAgentService.getPreviousAuditEvent(t);
+ return defaultService.getPreviousAuditEvent(t);
}
/**
*/
@Override
public int count(Class<? extends AgentBase> clazz) {
- return defaultAgentService.count(clazz);
+ return defaultService.count(clazz);
}
/**
*/
@Override
public Pager<AgentBase> search(Class<? extends AgentBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<AuditEventRecord<AgentBase>> pageAuditEvents(Class<? extends AgentBase> clazz, AuditEvent from, AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List<String> propertyPaths) {
- return defaultAgentService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
+ return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
}
/**
*/
@Override
public AgentBase find(LSID lsid) {
- return defaultAgentService.find(lsid);
+ return defaultService.find(lsid);
}
/**
*/
@Override
public DeleteResult delete(AgentBase persistentObject) {
- return defaultAgentService.delete(persistentObject);
+ return defaultService.delete(persistentObject);
}
/**
*/
@Override
public List<Object[]> groupMarkers(Class<? extends AgentBase> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultAgentService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
+ return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public boolean exists(UUID uuid) {
- return defaultAgentService.exists(uuid);
+ return defaultService.exists(uuid);
}
/**
*/
@Override
public AgentBase replace(AgentBase x, AgentBase y) {
- return defaultAgentService.replace(x, y);
+ return defaultService.replace(x, y);
}
/**
*/
@Override
public List<AgentBase> find(Set<UUID> uuidSet) {
- return defaultAgentService.find(uuidSet);
+ return defaultService.find(uuidSet);
}
/**
*/
@Override
public Pager<IdentifiableSource> getSources(AgentBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultAgentService.getSources(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public AgentBase find(UUID uuid) {
- return defaultAgentService.find(uuid);
+ return defaultService.find(uuid);
}
/**
*/
@Override
public List<UuidAndTitleCache<Person>> getPersonUuidAndTitleCache() {
- return defaultAgentService.getPersonUuidAndTitleCache();
+ return defaultService.getPersonUuidAndTitleCache();
}
/**
*/
@Override
public List<UuidAndTitleCache<Team>> getTeamUuidAndTitleCache() {
- return defaultAgentService.getTeamUuidAndTitleCache();
+ return defaultService.getTeamUuidAndTitleCache();
}
/**
*/
@Override
public AgentBase find(int id) {
- return defaultAgentService.find(id);
+ return defaultService.find(id);
}
/**
*/
@Override
public Pager<Rights> getRights(AgentBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultAgentService.getRights(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public int countMarkers(Class<? extends AgentBase> clazz, Boolean technical) {
- return defaultAgentService.countMarkers(clazz, technical);
+ return defaultService.countMarkers(clazz, technical);
}
/**
*/
@Override
public List<UuidAndTitleCache<Team>> getTeamUuidAndNomenclaturalTitle() {
- return defaultAgentService.getTeamUuidAndNomenclaturalTitle();
+ return defaultService.getTeamUuidAndNomenclaturalTitle();
}
/**
*/
@Override
public List<AgentBase> findById(Set<Integer> idSet) {
- return defaultAgentService.findById(idSet);
+ return defaultService.findById(idSet);
}
/**
*/
@Override
public List<UuidAndTitleCache<Institution>> getInstitutionUuidAndTitleCache() {
- return defaultAgentService.getInstitutionUuidAndTitleCache();
+ return defaultService.getInstitutionUuidAndTitleCache();
}
/**
*/
@Override
public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
- return defaultAgentService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
+ return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
}
/**
*/
@Override
public Session getSession() {
- return defaultAgentService.getSession();
+ return defaultService.getSession();
}
/**
*/
@Override
public List<UuidAndTitleCache<AgentBase>> getUuidAndTitleCache() {
- return defaultAgentService.getUuidAndTitleCache();
+ return defaultService.getUuidAndTitleCache();
}
/**
*/
@Override
public List<Object[]> group(Class<? extends AgentBase> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
- return defaultAgentService.group(clazz, limit, start, groups, propertyPaths);
+ return defaultService.group(clazz, limit, start, groups, propertyPaths);
}
/**
*/
@Override
public Pager<AgentBase> findByTitle(Class<? extends AgentBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends AgentBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.list(type, limit, start, orderHints, propertyPaths);
+ return defaultService.list(type, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<AgentBase> findByTitle(IIdentifiableEntityServiceConfigurator<AgentBase> configurator) {
- return defaultAgentService.findByTitle(configurator);
+ return defaultService.findByTitle(configurator);
}
/**
*/
@Override
public Integer countByTitle(Class<? extends AgentBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
- return defaultAgentService.countByTitle(clazz, queryString, matchmode, criteria);
+ return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
}
/**
*/
@Override
public AgentBase load(UUID uuid) {
- return defaultAgentService.load(uuid);
+ return defaultService.load(uuid);
}
/**
*/
@Override
public AgentBase load(UUID uuid, List<String> propertyPaths) {
- return defaultAgentService.load(uuid, propertyPaths);
+ return defaultService.load(uuid, propertyPaths);
}
/**
*/
@Override
public Integer countByTitle(IIdentifiableEntityServiceConfigurator<AgentBase> configurator) {
- return defaultAgentService.countByTitle(configurator);
+ return defaultService.countByTitle(configurator);
}
/**
*/
@Override
public AgentBase merge(AgentBase transientObject) {
- return defaultAgentService.merge(transientObject);
+ return defaultService.merge(transientObject);
}
/**
*/
@Override
public List<AgentBase> listByTitle(Class<? extends AgentBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends AgentBase> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public UUID refresh(AgentBase persistentObject) {
- return defaultAgentService.refresh(persistentObject);
+ return defaultService.refresh(persistentObject);
}
/**
*/
@Override
public List<AgentBase> listByReferenceTitle(Class<? extends AgentBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<AgentBase> rows(String tableName, int limit, int start) {
- return defaultAgentService.rows(tableName, limit, start);
+ return defaultService.rows(tableName, limit, start);
}
/**
*/
@Override
public UUID update(AgentBase transientObject) {
- return defaultAgentService.update(transientObject);
+ return defaultService.update(transientObject);
}
/**
*/
@Override
public List<AgentBase> list(AgentBase example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultAgentService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
+ return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public int deduplicate(Class<? extends AgentBase> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
- return defaultAgentService.deduplicate(clazz, matchStrategy, mergeStrategy);
+ return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
}
/**
*/
@Override
public Pager<AgentBase> findTitleCache(Class<? extends AgentBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
- return defaultAgentService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
+ return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
}
@Override
@Override
public AgentBase findWithoutFlush(UUID uuid) {
- return defaultAgentService.findWithoutFlush(uuid);
+ return defaultService.findWithoutFlush(uuid);
};
-
+ @Override
+ public <S extends AgentBase> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
+ }
}
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;
*/
public class TransientClassificationService implements IClassificationService {
- private final IClassificationService defaultClassificationService;
+ private final IClassificationService defaultService;
/**
* @param defaultClassificationService
*/
public TransientClassificationService(IClassificationService defaultClassificationService) {
- this.defaultClassificationService = defaultClassificationService;
+ this.defaultService = defaultClassificationService;
}
/**
*/
@Override
public Pager<AuditEventRecord<Classification>> pageAuditEvents(Classification t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
- return defaultClassificationService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
+ return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
}
/**
*/
@Override
public Pager<Annotation> getAnnotations(Classification annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public TaxonNode getTaxonNodeByUuid(UUID uuid) {
- return defaultClassificationService.getTaxonNodeByUuid(uuid);
+ return defaultService.getTaxonNodeByUuid(uuid);
}
/**
*/
@Override
public ITaxonTreeNode getTreeNodeByUuid(UUID uuid) {
- return defaultClassificationService.getTreeNodeByUuid(uuid);
+ return defaultService.getTreeNodeByUuid(uuid);
}
/**
*/
@Override
public void clear() {
- defaultClassificationService.clear();
+ defaultService.clear();
}
/**
*/
@Override
public List<Classification> listClassifications(Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.listClassifications(limit, start, orderHints, propertyPaths);
+ return defaultService.listClassifications(limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public void lock(Classification t, LockOptions lockOptions) {
- defaultClassificationService.lock(t, lockOptions);
+ defaultService.lock(t, lockOptions);
}
/**
*/
@Override
public void refresh(Classification t, LockOptions lockOptions, List<String> propertyPaths) {
- defaultClassificationService.refresh(t, lockOptions, propertyPaths);
+ defaultService.refresh(t, lockOptions, propertyPaths);
}
/**
@Deprecated
@Override
public TaxonNode loadTaxonNodeByTaxon(Taxon taxon, UUID classificationUuid, List<String> propertyPaths) {
- return defaultClassificationService.loadTaxonNodeByTaxon(taxon, classificationUuid, propertyPaths);
+ return defaultService.loadTaxonNodeByTaxon(taxon, classificationUuid, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache() {
- defaultClassificationService.updateTitleCache();
+ defaultService.updateTitleCache();
}
/**
*/
@Override
public AuditEventRecord<Classification> getNextAuditEvent(Classification t) {
- return defaultClassificationService.getNextAuditEvent(t);
+ return defaultService.getNextAuditEvent(t);
}
/**
*/
@Override
public Pager<Marker> getMarkers(Classification annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache(Class<? extends Classification> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<Classification> cacheStrategy, IProgressMonitor monitor) {
- defaultClassificationService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
+ defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
}
/**
@Deprecated
@Override
public TaxonNode loadTaxonNode(TaxonNode taxonNode, List<String> propertyPaths) {
- return defaultClassificationService.loadTaxonNode(taxonNode, propertyPaths);
+ return defaultService.loadTaxonNode(taxonNode, propertyPaths);
}
/**
*/
@Override
public AuditEventRecord<Classification> getPreviousAuditEvent(Classification t) {
- return defaultClassificationService.getPreviousAuditEvent(t);
+ return defaultService.getPreviousAuditEvent(t);
}
/**
@Deprecated
@Override
public List<TaxonNode> loadRankSpecificRootNodes(Classification classification, Rank rank, Integer limit, Integer start, List<String> propertyPaths) {
- return defaultClassificationService.loadRankSpecificRootNodes(classification, rank, limit, start, propertyPaths);
+ return defaultService.loadRankSpecificRootNodes(classification, rank, limit, start, propertyPaths);
}
/**
*/
@Override
public int count(Class<? extends Classification> clazz) {
- return defaultClassificationService.count(clazz);
+ return defaultService.count(clazz);
}
/**
*/
@Override
public Pager<AuditEventRecord<Classification>> pageAuditEvents(Class<? extends Classification> clazz, AuditEvent from, AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List<String> propertyPaths) {
- return defaultClassificationService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
+ return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
}
/**
*/
@Override
public Classification find(LSID lsid) {
- return defaultClassificationService.find(lsid);
+ return defaultService.find(lsid);
}
/**
*/
@Override
public DeleteResult delete(Classification persistentObject) {
- return defaultClassificationService.delete(persistentObject);
+ return defaultService.delete(persistentObject);
}
/**
*/
@Override
public List<Object[]> groupMarkers(Class<? extends Classification> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultClassificationService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
+ return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public boolean exists(UUID uuid) {
- return defaultClassificationService.exists(uuid);
+ return defaultService.exists(uuid);
}
/**
*/
@Override
public Classification replace(Classification x, Classification y) {
- return defaultClassificationService.replace(x, y);
+ return defaultService.replace(x, y);
}
/**
*/
@Override
public List<Classification> find(Set<UUID> uuidSet) {
- return defaultClassificationService.find(uuidSet);
+ return defaultService.find(uuidSet);
}
/**
*/
@Override
public Pager<IdentifiableSource> getSources(Classification t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultClassificationService.getSources(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public List<TaxonNode> listRankSpecificRootNodes(Classification classification, Rank rank, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {
- return defaultClassificationService.listRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths);
+ return defaultService.listRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths);
}
/**
*/
@Override
public Classification find(UUID uuid) {
- return defaultClassificationService.find(uuid);
+ return defaultService.find(uuid);
}
/**
*/
@Override
public Classification find(int id) {
- return defaultClassificationService.find(id);
+ return defaultService.find(id);
}
/**
*/
@Override
public Pager<Rights> getRights(Classification t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultClassificationService.getRights(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public int countMarkers(Class<? extends Classification> clazz, Boolean technical) {
- return defaultClassificationService.countMarkers(clazz, technical);
+ return defaultService.countMarkers(clazz, technical);
}
/**
*/
@Override
public List<Classification> findById(Set<Integer> idSet) {
- return defaultClassificationService.findById(idSet);
+ return defaultService.findById(idSet);
}
/**
*/
@Override
public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
- return defaultClassificationService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
+ return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
}
/**
*/
@Override
public Pager<TaxonNode> pageRankSpecificRootNodes(Classification classification, Rank rank, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {
- return defaultClassificationService.pageRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths);
+ return defaultService.pageRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths);
}
/**
*/
@Override
public Session getSession() {
- return defaultClassificationService.getSession();
+ return defaultService.getSession();
}
/**
*/
@Override
public List<UuidAndTitleCache<Classification>> getUuidAndTitleCache() {
- return defaultClassificationService.getUuidAndTitleCache();
+ return defaultService.getUuidAndTitleCache();
}
/**
*/
@Override
public List<Object[]> group(Class<? extends Classification> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
- return defaultClassificationService.group(clazz, limit, start, groups, propertyPaths);
+ return defaultService.group(clazz, limit, start, groups, propertyPaths);
}
/**
*/
@Override
public Pager<Classification> findByTitle(Class<? extends Classification> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<TaxonNode> loadTreeBranch(TaxonNode taxonNode, Rank baseRank, List<String> propertyPaths) {
- return defaultClassificationService.loadTreeBranch(taxonNode, baseRank, propertyPaths);
+ return defaultService.loadTreeBranch(taxonNode, baseRank, propertyPaths);
}
/**
*/
@Override
public <S extends Classification> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.list(type, limit, start, orderHints, propertyPaths);
+ return defaultService.list(type, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public List<TaxonNode> loadTreeBranchToTaxon(Taxon taxon, Classification classification, Rank baseRank, List<String> propertyPaths) {
- return defaultClassificationService.loadTreeBranchToTaxon(taxon, classification, baseRank, propertyPaths);
+ return defaultService.loadTreeBranchToTaxon(taxon, classification, baseRank, propertyPaths);
}
/**
*/
@Override
public Pager<Classification> findByTitle(IIdentifiableEntityServiceConfigurator<Classification> configurator) {
- return defaultClassificationService.findByTitle(configurator);
+ return defaultService.findByTitle(configurator);
}
/**
*/
@Override
public Integer countByTitle(Class<? extends Classification> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
- return defaultClassificationService.countByTitle(clazz, queryString, matchmode, criteria);
+ return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
}
/**
*/
@Override
public Classification load(UUID uuid) {
- return defaultClassificationService.load(uuid);
+ return defaultService.load(uuid);
}
/**
*/
@Override
public Classification load(UUID uuid, List<String> propertyPaths) {
- return defaultClassificationService.load(uuid, propertyPaths);
+ return defaultService.load(uuid, propertyPaths);
}
/**
*/
@Override
public Integer countByTitle(IIdentifiableEntityServiceConfigurator<Classification> configurator) {
- return defaultClassificationService.countByTitle(configurator);
+ return defaultService.countByTitle(configurator);
}
/**
*/
@Override
public Classification merge(Classification transientObject) {
- return defaultClassificationService.merge(transientObject);
+ return defaultService.merge(transientObject);
}
/**
*/
@Override
public List<Classification> listByTitle(Class<? extends Classification> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends Classification> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public List<TaxonNode> loadChildNodesOfTaxonNode(TaxonNode taxonNode, List<String> propertyPaths) {
- return defaultClassificationService.loadChildNodesOfTaxonNode(taxonNode, propertyPaths);
+ return defaultService.loadChildNodesOfTaxonNode(taxonNode, propertyPaths);
}
/**
*/
@Override
public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification) {
- return defaultClassificationService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification);
+ return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification);
}
/**
@Deprecated
@Override
public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(Taxon taxon, Classification taxTree, List<String> propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes) {
- return defaultClassificationService.getAllMediaForChildNodes(taxon, taxTree, propertyPaths, size, height, widthOrDuration, mimeTypes);
+ return defaultService.getAllMediaForChildNodes(taxon, taxTree, propertyPaths, size, height, widthOrDuration, mimeTypes);
}
/**
*/
@Override
public UUID refresh(Classification persistentObject) {
- return defaultClassificationService.refresh(persistentObject);
+ return defaultService.refresh(persistentObject);
}
/**
*/
@Override
public List<Classification> listByReferenceTitle(Class<? extends Classification> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(TaxonNode taxonNode, List<String> propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes) {
- return defaultClassificationService.getAllMediaForChildNodes(taxonNode, propertyPaths, size, height, widthOrDuration, mimeTypes);
+ return defaultService.getAllMediaForChildNodes(taxonNode, propertyPaths, size, height, widthOrDuration, mimeTypes);
}
/**
*/
@Override
public List<Classification> rows(String tableName, int limit, int start) {
- return defaultClassificationService.rows(tableName, limit, start);
+ return defaultService.rows(tableName, limit, start);
}
/**
@Deprecated
@Override
public UUID removeTaxonNode(TaxonNode taxonNode) {
- return defaultClassificationService.removeTaxonNode(taxonNode);
+ return defaultService.removeTaxonNode(taxonNode);
}
/**
*/
@Override
public UUID removeTreeNode(ITaxonTreeNode treeNode) {
- return defaultClassificationService.removeTreeNode(treeNode);
+ return defaultService.removeTreeNode(treeNode);
}
/**
*/
@Override
public Pager<Classification> search(Class<? extends Classification> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<TaxonNode> getAllNodes() {
- return defaultClassificationService.getAllNodes();
+ return defaultService.getAllNodes();
}
/**
*/
@Override
public UUID update(Classification transientObject) {
- return defaultClassificationService.update(transientObject);
+ return defaultService.update(transientObject);
}
/**
*/
@Override
public List<Classification> list(Classification example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultClassificationService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
+ return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public int deduplicate(Class<? extends Classification> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
- return defaultClassificationService.deduplicate(clazz, matchStrategy, mergeStrategy);
+ return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
}
/**
*/
@Override
public Pager<Classification> findTitleCache(Class<? extends Classification> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
- return defaultClassificationService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
+ return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
}
/* (non-Javadoc)
@Override
public List<TaxonNode> listChildNodesOfTaxon(UUID taxonUuid, UUID classificationUuid, Integer pageSize,
Integer pageIndex, List<String> propertyPaths) {
- return defaultClassificationService.listChildNodesOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, propertyPaths);
+ return defaultService.listChildNodesOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, propertyPaths);
}
@Override
@Override
public Classification findWithoutFlush(UUID uuid) {
- return defaultClassificationService.findWithoutFlush(uuid);
+ return defaultService.findWithoutFlush(uuid);
}
-
+ @Override
+ public <S extends Classification> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
+ }
}
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;
return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
}
-
+ @Override
+ public <S extends Collection> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
+ }
}
*/
public class TransientDescriptionService implements IDescriptionService {
- private final IDescriptionService defaultDescriptionService;
+ private final IDescriptionService defaultService;
/**
* @param defaultDescriptionService
*/
public TransientDescriptionService(IDescriptionService defaultDescriptionService) {
- this.defaultDescriptionService = defaultDescriptionService;
+ this.defaultService = defaultDescriptionService;
}
/**
*/
@Override
public Pager<AuditEventRecord<DescriptionBase>> pageAuditEvents(DescriptionBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
- return defaultDescriptionService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
+ return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
}
/**
*/
@Override
public Pager<Annotation> getAnnotations(DescriptionBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void clear() {
- defaultDescriptionService.clear();
+ defaultService.clear();
}
/**
*/
@Override
public void lock(DescriptionBase t, LockOptions lockOptions) {
- defaultDescriptionService.lock(t, lockOptions);
+ defaultService.lock(t, lockOptions);
}
/**
*/
@Override
public void refresh(DescriptionBase t, LockOptions lockOptions, List<String> propertyPaths) {
- defaultDescriptionService.refresh(t, lockOptions, propertyPaths);
+ defaultService.refresh(t, lockOptions, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache() {
- defaultDescriptionService.updateTitleCache();
+ defaultService.updateTitleCache();
}
/**
*/
@Override
public AuditEventRecord<DescriptionBase> getNextAuditEvent(DescriptionBase t) {
- return defaultDescriptionService.getNextAuditEvent(t);
+ return defaultService.getNextAuditEvent(t);
}
/**
@Deprecated
@Override
public TermVocabulary<Feature> getDefaultFeatureVocabulary() {
- return defaultDescriptionService.getDefaultFeatureVocabulary();
+ return defaultService.getDefaultFeatureVocabulary();
}
/**
*/
@Override
public Pager<Marker> getMarkers(DescriptionBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public TermVocabulary<Feature> getFeatureVocabulary(UUID uuid) {
- return defaultDescriptionService.getFeatureVocabulary(uuid);
+ return defaultService.getFeatureVocabulary(uuid);
}
/**
*/
@Override
public void updateTitleCache(Class<? extends DescriptionBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<DescriptionBase> cacheStrategy, IProgressMonitor monitor) {
- defaultDescriptionService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
+ defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
}
/**
*/
@Override
public AuditEventRecord<DescriptionBase> getPreviousAuditEvent(DescriptionBase t) {
- return defaultDescriptionService.getPreviousAuditEvent(t);
+ return defaultService.getPreviousAuditEvent(t);
}
/**
*/
@Override
public DescriptionElementBase getDescriptionElementByUuid(UUID uuid) {
- return defaultDescriptionService.getDescriptionElementByUuid(uuid);
+ return defaultService.getDescriptionElementByUuid(uuid);
}
/**
*/
@Override
public int count(Class<? extends DescriptionBase> clazz) {
- return defaultDescriptionService.count(clazz);
+ return defaultService.count(clazz);
}
/**
*/
@Override
public DescriptionElementBase loadDescriptionElement(UUID uuid, List<String> propertyPaths) {
- return defaultDescriptionService.loadDescriptionElement(uuid, propertyPaths);
+ return defaultService.loadDescriptionElement(uuid, propertyPaths);
}
/**
*/
@Override
public Pager<AuditEventRecord<DescriptionBase>> pageAuditEvents(Class<? extends DescriptionBase> clazz, AuditEvent from, AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List<String> propertyPaths) {
- return defaultDescriptionService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
+ return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
}
/**
*/
@Override
public DescriptionBase find(LSID lsid) {
- return defaultDescriptionService.find(lsid);
+ return defaultService.find(lsid);
}
/**
*/
@Override
public DeleteResult delete(DescriptionBase persistentObject) {
- return defaultDescriptionService.delete(persistentObject);
+ return defaultService.delete(persistentObject);
}
/**
*/
@Override
public List<Object[]> groupMarkers(Class<? extends DescriptionBase> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
+ return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public boolean exists(UUID uuid) {
- return defaultDescriptionService.exists(uuid);
+ return defaultService.exists(uuid);
}
/**
*/
@Override
public DescriptionBase replace(DescriptionBase x, DescriptionBase y) {
- return defaultDescriptionService.replace(x, y);
+ return defaultService.replace(x, y);
}
/**
*/
@Override
public List<DescriptionBase> find(Set<UUID> uuidSet) {
- return defaultDescriptionService.find(uuidSet);
+ return defaultService.find(uuidSet);
}
/**
*/
@Override
public Pager<IdentifiableSource> getSources(DescriptionBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.getSources(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public UUID deleteDescriptionElement(DescriptionElementBase descriptionElement) {
- return defaultDescriptionService.deleteDescriptionElement(descriptionElement);
+ return defaultService.deleteDescriptionElement(descriptionElement);
}
/**
*/
@Override
public DescriptionBase find(UUID uuid) {
- return defaultDescriptionService.find(uuid);
+ return defaultService.find(uuid);
}
/**
*/
@Override
public Pager<DescriptionBase> page(Class<? extends DescriptionBase> type, Boolean hasMedia, Boolean hasText, Set<Feature> feature, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.page(type, hasMedia, hasText, feature, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.page(type, hasMedia, hasText, feature, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public DescriptionBase find(int id) {
- return defaultDescriptionService.find(id);
+ return defaultService.find(id);
}
/**
*/
@Override
public Pager<Rights> getRights(DescriptionBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.getRights(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public int countMarkers(Class<? extends DescriptionBase> clazz, Boolean technical) {
- return defaultDescriptionService.countMarkers(clazz, technical);
+ return defaultService.countMarkers(clazz, technical);
}
/**
*/
@Override
public List<DescriptionBase> findById(Set<Integer> idSet) {
- return defaultDescriptionService.findById(idSet);
+ return defaultService.findById(idSet);
}
/**
*/
@Override
public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
- return defaultDescriptionService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
+ return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
}
/**
*/
@Override
public Session getSession() {
- return defaultDescriptionService.getSession();
+ return defaultService.getSession();
}
/**
*/
@Override
public List<UuidAndTitleCache<DescriptionBase>> getUuidAndTitleCache() {
- return defaultDescriptionService.getUuidAndTitleCache();
+ return defaultService.getUuidAndTitleCache();
}
/**
*/
@Override
public List<Object[]> group(Class<? extends DescriptionBase> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
- return defaultDescriptionService.group(clazz, limit, start, groups, propertyPaths);
+ return defaultService.group(clazz, limit, start, groups, propertyPaths);
}
/**
*/
@Override
public int count(Class<? extends DescriptionBase> type, Boolean hasImages, Boolean hasText, Set<Feature> feature) {
- return defaultDescriptionService.count(type, hasImages, hasText, feature);
+ return defaultService.count(type, hasImages, hasText, feature);
}
/**
*/
@Override
public Pager<DescriptionBase> findByTitle(Class<? extends DescriptionBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends DescriptionBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.list(type, limit, start, orderHints, propertyPaths);
+ return defaultService.list(type, limit, start, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public Pager<DescriptionElementBase> getDescriptionElements(DescriptionBase description, Set<Feature> features, Class<? extends DescriptionElementBase> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.getDescriptionElements(description, features, type, pageSize, pageNumber, propertyPaths);
+ return defaultService.getDescriptionElements(description, features, type, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public Pager<DescriptionBase> findByTitle(IIdentifiableEntityServiceConfigurator<DescriptionBase> configurator) {
- return defaultDescriptionService.findByTitle(configurator);
+ return defaultService.findByTitle(configurator);
}
/**
*/
@Override
public Integer countByTitle(Class<? extends DescriptionBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
- return defaultDescriptionService.countByTitle(clazz, queryString, matchmode, criteria);
+ return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
}
/**
*/
@Override
public DescriptionBase load(UUID uuid) {
- return defaultDescriptionService.load(uuid);
+ return defaultService.load(uuid);
}
/**
*/
@Override
public DescriptionBase load(UUID uuid, List<String> propertyPaths) {
- return defaultDescriptionService.load(uuid, propertyPaths);
+ return defaultService.load(uuid, propertyPaths);
}
/**
*/
@Override
public Integer countByTitle(IIdentifiableEntityServiceConfigurator<DescriptionBase> configurator) {
- return defaultDescriptionService.countByTitle(configurator);
+ return defaultService.countByTitle(configurator);
}
/**
*/
@Override
public DescriptionBase merge(DescriptionBase transientObject) {
- return defaultDescriptionService.merge(transientObject);
+ return defaultService.merge(transientObject);
}
/**
*/
@Override
public Pager<DescriptionElementBase> pageDescriptionElements(DescriptionBase description, Class<? extends DescriptionBase> descriptionType, Set<Feature> features, Class<? extends DescriptionElementBase> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.pageDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);
+ return defaultService.pageDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public List<DescriptionBase> listByTitle(Class<? extends DescriptionBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends DescriptionBase> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public UUID refresh(DescriptionBase persistentObject) {
- return defaultDescriptionService.refresh(persistentObject);
+ return defaultService.refresh(persistentObject);
}
/**
*/
@Override
public List<DescriptionBase> listByReferenceTitle(Class<? extends DescriptionBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public List<DescriptionElementBase> listDescriptionElements(DescriptionBase description, Set<Feature> features, Class<? extends DescriptionElementBase> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.listDescriptionElements(description, features, type, pageSize, pageNumber, propertyPaths);
+ return defaultService.listDescriptionElements(description, features, type, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public List<DescriptionBase> rows(String tableName, int limit, int start) {
- return defaultDescriptionService.rows(tableName, limit, start);
+ return defaultService.rows(tableName, limit, start);
}
/**
*/
@Override
public Pager<DescriptionBase> search(Class<? extends DescriptionBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public UUID update(DescriptionBase transientObject) {
- return defaultDescriptionService.update(transientObject);
+ return defaultService.update(transientObject);
}
/**
*/
@Override
public List<DescriptionElementBase> listDescriptionElements(DescriptionBase description, Class<? extends DescriptionBase> descriptionType, Set<Feature> features, Class<? extends DescriptionElementBase> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.listDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);
+ return defaultService.listDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public List<DescriptionBase> list(DescriptionBase example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
+ return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public int deduplicate(Class<? extends DescriptionBase> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
- return defaultDescriptionService.deduplicate(clazz, matchStrategy, mergeStrategy);
+ return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
}
/**
*/
@Override
public Pager<Annotation> getDescriptionElementAnnotations(DescriptionElementBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.getDescriptionElementAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getDescriptionElementAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<DescriptionBase> findTitleCache(Class<? extends DescriptionBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
- return defaultDescriptionService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
+ return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
}
/**
*/
@Override
public Pager<TaxonDescription> pageTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.pageTaxonDescriptions(taxon, scopes, geographicalScope, pageSize, pageNumber, propertyPaths);
+ return defaultService.pageTaxonDescriptions(taxon, scopes, geographicalScope, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonDescription> pageTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Set<MarkerType> markerTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.pageTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths);
+ return defaultService.pageTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public List<TaxonDescription> listTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.listTaxonDescriptions(taxon, scopes, geographicalScope, pageSize, pageNumber, propertyPaths);
+ return defaultService.listTaxonDescriptions(taxon, scopes, geographicalScope, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public List<TaxonDescription> listTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Set<MarkerType> markerTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths);
+ return defaultService.listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public List<Media> listTaxonDescriptionMedia(UUID taxonUuid, boolean limitToGalleries, Set<MarkerType> markerTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.listTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes, pageSize, pageNumber, propertyPaths);
+ return defaultService.listTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public int countTaxonDescriptionMedia(UUID taxonUuid, boolean limitToGalleries, Set<MarkerType> markerTypes) {
- return defaultDescriptionService.countTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes);
+ return defaultService.countTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes);
}
/**
*/
@Override
public Pager<TaxonNameDescription> getTaxonNameDescriptions(TaxonNameBase name, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.getTaxonNameDescriptions(name, pageSize, pageNumber, propertyPaths);
+ return defaultService.getTaxonNameDescriptions(name, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonDescription> searchDescriptionByDistribution(Set<NamedArea> namedAreas, PresenceAbsenceTerm presence, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.searchDescriptionByDistribution(namedAreas, presence, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.searchDescriptionByDistribution(namedAreas, presence, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<DescriptionElementBase> searchElements(Class<? extends DescriptionElementBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultDescriptionService.searchElements(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.searchElements(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<Media> getMedia(DescriptionElementBase descriptionElement, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.getMedia(descriptionElement, pageSize, pageNumber, propertyPaths);
+ return defaultService.getMedia(descriptionElement, pageSize, pageNumber, propertyPaths);
}
/**
@Deprecated
@Override
public <T extends DescriptionElementBase> List<T> getDescriptionElementsForTaxon(Taxon taxon, Set<Feature> features, Class<T> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.getDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
+ return defaultService.getDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public <T extends DescriptionElementBase> List<T> listDescriptionElementsForTaxon(Taxon taxon, Set<Feature> features, Class<T> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.listDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
+ return defaultService.listDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public <T extends DescriptionElementBase> Pager<T> pageDescriptionElementsForTaxon(Taxon taxon, Set<Feature> features, Class<T> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.pageDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
+ return defaultService.pageDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public String generateNaturalLanguageDescription(FeatureTree featureTree, TaxonDescription description, List<Language> preferredLanguages, String separator) {
- return defaultDescriptionService.generateNaturalLanguageDescription(featureTree, description, preferredLanguages, separator);
+ return defaultService.generateNaturalLanguageDescription(featureTree, description, preferredLanguages, separator);
}
/**
@Deprecated
@Override
public boolean hasStructuredData(DescriptionBase<?> description) {
- return defaultDescriptionService.hasStructuredData(description);
+ return defaultService.hasStructuredData(description);
}
/**
*/
@Override
public void moveDescriptionElementsToDescription(Collection<DescriptionElementBase> descriptionElements, DescriptionBase targetDescription, boolean isPaste) {
- defaultDescriptionService.moveDescriptionElementsToDescription(descriptionElements, targetDescription, isPaste);
+ defaultService.moveDescriptionElementsToDescription(descriptionElements, targetDescription, isPaste);
}
/* (non-Javadoc)
*/
@Override
public Pager<NamedArea> pageNamedAreasInUse(Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultDescriptionService.pageNamedAreasInUse(pageSize, pageNumber, propertyPaths);
+ return defaultService.pageNamedAreasInUse(pageSize, pageNumber, propertyPaths);
}
/* (non-Javadoc)
*/
@Override
public DistributionTree getOrderedDistributions(Set<TaxonDescription> taxonDescriptions, boolean subAreaPreference, boolean statusOrderPreference, Set<MarkerType> hideMarkedAreas, Set<NamedAreaLevel> omitLevels, List<String> propertyPaths) {
- return defaultDescriptionService.getOrderedDistributions(taxonDescriptions, subAreaPreference, statusOrderPreference, hideMarkedAreas, omitLevels, propertyPaths);
+ return defaultService.getOrderedDistributions(taxonDescriptions, subAreaPreference, statusOrderPreference, hideMarkedAreas, omitLevels, propertyPaths);
}
@Override
@Override
public DescriptionBase findWithoutFlush(UUID uuid) {
- return defaultDescriptionService.findWithoutFlush(uuid);
+ return defaultService.findWithoutFlush(uuid);
+ }
+
+ @Override
+ public <S extends DescriptionBase> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
}
-
}
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.DefinedTerm;
import eu.etaxonomy.cdm.model.common.ISourceable;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.LSID;
*/
public class TransientNameService implements INameService {
- private INameService defaultNameService;
+ private INameService defaultService;
/**
*
*/
public TransientNameService(INameService defaultNameService) {
- this.defaultNameService = defaultNameService;
+ this.defaultService = defaultNameService;
}
/**
*/
@Override
public Pager<AuditEventRecord<TaxonNameBase>> pageAuditEvents(TaxonNameBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
- return defaultNameService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
+ return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
}
/**
*/
@Override
public Pager<Annotation> getAnnotations(TaxonNameBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void clear() {
- defaultNameService.clear();
+ defaultService.clear();
}
/**
*/
@Override
public void lock(TaxonNameBase t, LockOptions lockOptions) {
- defaultNameService.lock(t, lockOptions);
+ defaultService.lock(t, lockOptions);
}
/**
*/
@Override
public void refresh(TaxonNameBase t, LockOptions lockOptions, List<String> propertyPaths) {
- defaultNameService.refresh(t, lockOptions, propertyPaths);
+ defaultService.refresh(t, lockOptions, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache() {
- defaultNameService.updateTitleCache();
+ defaultService.updateTitleCache();
}
/**
*/
@Override
public AuditEventRecord<TaxonNameBase> getNextAuditEvent(TaxonNameBase t) {
- return defaultNameService.getNextAuditEvent(t);
+ return defaultService.getNextAuditEvent(t);
}
/**
*/
@Override
public Pager<Marker> getMarkers(TaxonNameBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache(Class<? extends TaxonNameBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TaxonNameBase> cacheStrategy, IProgressMonitor monitor) {
- defaultNameService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
+ defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
}
/**
*/
@Override
public AuditEventRecord<TaxonNameBase> getPreviousAuditEvent(TaxonNameBase t) {
- return defaultNameService.getPreviousAuditEvent(t);
+ return defaultService.getPreviousAuditEvent(t);
}
/**
*/
@Override
public int count(Class<? extends TaxonNameBase> clazz) {
- return defaultNameService.count(clazz);
+ return defaultService.count(clazz);
}
/**
*/
@Override
public DeleteResult delete(TaxonNameBase name, NameDeletionConfigurator config) {
- return defaultNameService.delete(name, config);
+ return defaultService.delete(name, config);
}
/**
*/
@Override
public Pager<AuditEventRecord<TaxonNameBase>> pageAuditEvents(Class<? extends TaxonNameBase> clazz, AuditEvent from, AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List<String> propertyPaths) {
- return defaultNameService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
+ return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
}
/**
*/
@Override
public TaxonNameBase find(LSID lsid) {
- return defaultNameService.find(lsid);
+ return defaultService.find(lsid);
}
/**
*/
@Override
public DeleteResult delete(TaxonNameBase persistentObject) {
- return defaultNameService.delete(persistentObject);
+ return defaultService.delete(persistentObject);
}
/**
*/
@Override
public List<Object[]> groupMarkers(Class<? extends TaxonNameBase> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultNameService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
+ return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public boolean exists(UUID uuid) {
- return defaultNameService.exists(uuid);
+ return defaultService.exists(uuid);
}
/**
*/
@Override
public void deleteTypeDesignation(TaxonNameBase name, TypeDesignationBase typeDesignation) {
- defaultNameService.deleteTypeDesignation(name, typeDesignation);
+ defaultService.deleteTypeDesignation(name, typeDesignation);
}
/**
*/
@Override
public TaxonNameBase replace(TaxonNameBase x, TaxonNameBase y) {
- return defaultNameService.replace(x, y);
+ return defaultService.replace(x, y);
}
/**
*/
@Override
public List<TaxonNameBase> find(Set<UUID> uuidSet) {
- return defaultNameService.find(uuidSet);
+ return defaultService.find(uuidSet);
}
/**
*/
@Override
public Pager<IdentifiableSource> getSources(TaxonNameBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultNameService.getSources(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public TaxonNameBase find(UUID uuid) {
- return defaultNameService.find(uuid);
+ return defaultService.find(uuid);
}
/**
*/
@Override
public TaxonNameBase find(int id) {
- return defaultNameService.find(id);
+ return defaultService.find(id);
}
/**
*/
@Override
public Pager<Rights> getRights(TaxonNameBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultNameService.getRights(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public int countMarkers(Class<? extends TaxonNameBase> clazz, Boolean technical) {
- return defaultNameService.countMarkers(clazz, technical);
+ return defaultService.countMarkers(clazz, technical);
}
/**
*/
@Override
public List<NomenclaturalStatus> getAllNomenclaturalStatus(int limit, int start) {
- return defaultNameService.getAllNomenclaturalStatus(limit, start);
+ return defaultService.getAllNomenclaturalStatus(limit, start);
}
/**
*/
@Override
public List<TypeDesignationBase> getAllTypeDesignations(int limit, int start) {
- return defaultNameService.getAllTypeDesignations(limit, start);
+ return defaultService.getAllTypeDesignations(limit, start);
}
/**
*/
@Override
public List<TaxonNameBase> findById(Set<Integer> idSet) {
- return defaultNameService.findById(idSet);
+ return defaultService.findById(idSet);
}
/**
*/
@Override
public List<TaxonNameBase> getNamesByName(String name) {
- return defaultNameService.getNamesByName(name);
+ return defaultService.getNamesByName(name);
}
/**
*/
@Override
public List<NonViralName> getNamesByNameCache(String nameCache) {
- return defaultNameService.getNamesByNameCache(nameCache);
+ return defaultService.getNamesByNameCache(nameCache);
}
/**
*/
@Override
public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
- return defaultNameService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
+ return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
}
/**
*/
@Override
public Session getSession() {
- return defaultNameService.getSession();
+ return defaultService.getSession();
}
/**
*/
@Override
public List<UuidAndTitleCache<TaxonNameBase>> getUuidAndTitleCache() {
- return defaultNameService.getUuidAndTitleCache();
+ return defaultService.getUuidAndTitleCache();
}
/**
*/
@Override
public List<Object[]> group(Class<? extends TaxonNameBase> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
- return defaultNameService.group(clazz, limit, start, groups, propertyPaths);
+ return defaultService.group(clazz, limit, start, groups, propertyPaths);
}
/**
*/
@Override
public List<NonViralName> findNamesByTitleCache(String titleCache, MatchMode matchMode, List<String> propertyPaths) {
- return defaultNameService.findNamesByTitleCache(titleCache, matchMode, propertyPaths);
+ return defaultService.findNamesByTitleCache(titleCache, matchMode, propertyPaths);
}
/**
*/
@Override
public List<NonViralName> findNamesByNameCache(String nameCache, MatchMode matchMode, List<String> propertyPaths) {
- return defaultNameService.findNamesByNameCache(nameCache, matchMode, propertyPaths);
+ return defaultService.findNamesByNameCache(nameCache, matchMode, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonNameBase> findByTitle(Class<? extends TaxonNameBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public NonViralName findNameByUuid(UUID uuid, List<String> propertyPaths) {
- return defaultNameService.findNameByUuid(uuid, propertyPaths);
+ return defaultService.findNameByUuid(uuid, propertyPaths);
}
/**
*/
@Override
public List getNamesByName(String name, CdmBase sessionObject) {
- return defaultNameService.getNamesByName(name, sessionObject);
+ return defaultService.getNamesByName(name, sessionObject);
}
/**
*/
@Override
public List<SearchResult<TaxonNameBase>> findByNameFuzzySearch(String name, float accuracy, List<Language> languages, boolean highlightFragments, List<String> propertyPaths, int maxNoOfResults) throws CorruptIndexException, IOException, ParseException {
- return defaultNameService.findByNameFuzzySearch(name, accuracy, languages, highlightFragments, propertyPaths, maxNoOfResults);
+ return defaultService.findByNameFuzzySearch(name, accuracy, languages, highlightFragments, propertyPaths, maxNoOfResults);
}
/**
*/
@Override
public <S extends TaxonNameBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.list(type, limit, start, orderHints, propertyPaths);
+ return defaultService.list(type, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonNameBase> findByTitle(IIdentifiableEntityServiceConfigurator<TaxonNameBase> configurator) {
- return defaultNameService.findByTitle(configurator);
+ return defaultService.findByTitle(configurator);
}
/**
*/
@Override
public Integer countByTitle(Class<? extends TaxonNameBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
- return defaultNameService.countByTitle(clazz, queryString, matchmode, criteria);
+ return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
}
/**
*/
@Override
public TaxonNameBase load(UUID uuid) {
- return defaultNameService.load(uuid);
+ return defaultService.load(uuid);
}
/**
*/
@Override
public List<DocumentSearchResult> findByNameFuzzySearch(String name, float accuracy, List<Language> languages, boolean highlightFragments, int maxNoOfResults) throws CorruptIndexException, IOException, ParseException {
- return defaultNameService.findByNameFuzzySearch(name, accuracy, languages, highlightFragments, maxNoOfResults);
+ return defaultService.findByNameFuzzySearch(name, accuracy, languages, highlightFragments, maxNoOfResults);
}
/**
*/
@Override
public TaxonNameBase load(UUID uuid, List<String> propertyPaths) {
- return defaultNameService.load(uuid, propertyPaths);
+ return defaultService.load(uuid, propertyPaths);
}
/**
*/
@Override
public Integer countByTitle(IIdentifiableEntityServiceConfigurator<TaxonNameBase> configurator) {
- return defaultNameService.countByTitle(configurator);
+ return defaultService.countByTitle(configurator);
}
/**
*/
@Override
public TaxonNameBase merge(TaxonNameBase transientObject) {
- return defaultNameService.merge(transientObject);
+ return defaultService.merge(transientObject);
}
/**
*/
@Override
public List<TaxonNameBase> listByTitle(Class<? extends TaxonNameBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends TaxonNameBase> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<DocumentSearchResult> findByFuzzyNameCacheSearch(String name, float accuracy, List<Language> languages, boolean highlightFragments, int maxNoOfResults) throws CorruptIndexException, IOException, ParseException {
- return defaultNameService.findByFuzzyNameCacheSearch(name, accuracy, languages, highlightFragments, maxNoOfResults);
+ return defaultService.findByFuzzyNameCacheSearch(name, accuracy, languages, highlightFragments, maxNoOfResults);
}
/**
*/
@Override
public List<DocumentSearchResult> findByNameExactSearch(String name, boolean wildcard, List<Language> languages, boolean highlightFragments, int maxNoOfResults) throws CorruptIndexException, IOException, ParseException {
- return defaultNameService.findByNameExactSearch(name, wildcard, languages, highlightFragments, maxNoOfResults);
+ return defaultService.findByNameExactSearch(name, wildcard, languages, highlightFragments, maxNoOfResults);
}
/**
*/
@Override
public UUID refresh(TaxonNameBase persistentObject) {
- return defaultNameService.refresh(persistentObject);
+ return defaultService.refresh(persistentObject);
}
/**
*/
@Override
public List<TaxonNameBase> listByReferenceTitle(Class<? extends TaxonNameBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<TaxonNameBase> rows(String tableName, int limit, int start) {
- return defaultNameService.rows(tableName, limit, start);
+ return defaultService.rows(tableName, limit, start);
}
/**
*/
@Override
public List findNamesByTitle(String title) {
- return defaultNameService.findNamesByTitle(title);
+ return defaultService.findNamesByTitle(title);
}
/**
*/
@Override
public List findNamesByTitle(String title, CdmBase sessionObject) {
- return defaultNameService.findNamesByTitle(title, sessionObject);
+ return defaultService.findNamesByTitle(title, sessionObject);
}
/**
*/
@Override
public List<HomotypicalGroup> getAllHomotypicalGroups(int limit, int start) {
- return defaultNameService.getAllHomotypicalGroups(limit, start);
+ return defaultService.getAllHomotypicalGroups(limit, start);
}
/**
@Deprecated
@Override
public List<RelationshipBase> getAllRelationships(int limit, int start) {
- return defaultNameService.getAllRelationships(limit, start);
+ return defaultService.getAllRelationships(limit, start);
}
/**
*/
@Override
public UUID update(TaxonNameBase transientObject) {
- return defaultNameService.update(transientObject);
+ return defaultService.update(transientObject);
}
/**
*/
@Override
public List<TaxonNameBase> list(TaxonNameBase example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
+ return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public int deduplicate(Class<? extends TaxonNameBase> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
- return defaultNameService.deduplicate(clazz, matchStrategy, mergeStrategy);
+ return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
}
/**
*/
@Override
public List<NameRelationship> listNameRelationships(TaxonNameBase name, Direction direction, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.listNameRelationships(name, direction, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listNameRelationships(name, direction, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonNameBase> findTitleCache(Class<? extends TaxonNameBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
- return defaultNameService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
+ return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
}
/**
*/
@Override
public Pager<NameRelationship> pageNameRelationships(TaxonNameBase name, Direction direction, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.pageNameRelationships(name, direction, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.pageNameRelationships(name, direction, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public List<NameRelationship> listFromNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.listFromNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listFromNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public Pager<NameRelationship> pageFromNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.pageFromNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.pageFromNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public List<NameRelationship> listToNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.listToNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listToNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public Pager<NameRelationship> pageToNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.pageToNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.pageToNameRelationships(name, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<HybridRelationship> getHybridNames(NonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.getHybridNames(name, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getHybridNames(name, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<TypeDesignationBase> getTypeDesignations(TaxonNameBase name, SpecimenTypeDesignationStatus status, Integer pageSize, Integer pageNumber) {
- return defaultNameService.getTypeDesignations(name, status, pageSize, pageNumber);
+ return defaultService.getTypeDesignations(name, status, pageSize, pageNumber);
}
/**
*/
@Override
public Pager<TypeDesignationBase> getTypeDesignations(TaxonNameBase name, SpecimenTypeDesignationStatus status, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultNameService.getTypeDesignations(name, status, pageSize, pageNumber, propertyPaths);
+ return defaultService.getTypeDesignations(name, status, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonNameBase> searchNames(String uninomial, String infraGenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.searchNames(uninomial, infraGenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.searchNames(uninomial, infraGenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonNameBase> search(Class<? extends TaxonNameBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<UuidAndTitleCache> getUuidAndTitleCacheOfNames() {
- return defaultNameService.getUuidAndTitleCacheOfNames();
+ return defaultService.getUuidAndTitleCacheOfNames();
}
/**
*/
@Override
public Pager<TaxonNameBase> findByName(Class<? extends TaxonNameBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultNameService.findByName(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByName(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public HomotypicalGroup findHomotypicalGroup(UUID uuid) {
- return defaultNameService.findHomotypicalGroup(uuid);
+ return defaultService.findHomotypicalGroup(uuid);
}
/**
*/
@Override
public List<TaggedText> getTaggedName(UUID uuid) {
- return defaultNameService.getTaggedName(uuid);
+ return defaultService.getTaggedName(uuid);
}
@Override
@Override
public TaxonNameBase findWithoutFlush(UUID uuid) {
- return defaultNameService.findWithoutFlush(uuid);
+ return defaultService.findWithoutFlush(uuid);
+ }
+
+ @Override
+ public <S extends TaxonNameBase> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
}
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.DefinedTerm;
import eu.etaxonomy.cdm.model.common.ICdmBase;
import eu.etaxonomy.cdm.model.common.ISourceable;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
List<String> propertyPaths) {
return defaultService.listDescriptionsWithDescriptionSpecimen(specimen, limit, start, orderHints, propertyPaths);
}
+
+ @Override
+ public <S extends SpecimenOrObservationBase> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
+ }
}
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;
*/
public class TransientReferenceService implements IReferenceService {
- private IReferenceService defaultReferenceService;
+ private IReferenceService defaultService;
/**
* @param defaultReferenceService
*/
public TransientReferenceService(IReferenceService defaultReferenceService) {
- this.defaultReferenceService = defaultReferenceService;
+ this.defaultService = defaultReferenceService;
}
/**
*/
@Override
public Pager<Reference> search(Class<? extends Reference> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<AuditEventRecord<Reference>> pageAuditEvents(Reference t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
- return defaultReferenceService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
+ return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
}
/**
*/
@Override
public Pager<Annotation> getAnnotations(Reference annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void clear() {
- defaultReferenceService.clear();
+ defaultService.clear();
}
/**
*/
@Override
public void lock(Reference t, LockOptions lockOptions) {
- defaultReferenceService.lock(t, lockOptions);
+ defaultService.lock(t, lockOptions);
}
/**
*/
@Override
public void refresh(Reference t, LockOptions lockOptions, List<String> propertyPaths) {
- defaultReferenceService.refresh(t, lockOptions, propertyPaths);
+ defaultService.refresh(t, lockOptions, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache() {
- defaultReferenceService.updateTitleCache();
+ defaultService.updateTitleCache();
}
/**
*/
@Override
public AuditEventRecord<Reference> getNextAuditEvent(Reference t) {
- return defaultReferenceService.getNextAuditEvent(t);
+ return defaultService.getNextAuditEvent(t);
}
/**
*/
@Override
public Pager<Marker> getMarkers(Reference annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<UuidAndTitleCache<Reference>> getUuidAndTitle() {
- return defaultReferenceService.getUuidAndTitle();
+ return defaultService.getUuidAndTitle();
}
/**
*/
@Override
public void updateTitleCache(Class<? extends Reference> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<Reference> cacheStrategy, IProgressMonitor monitor) {
- defaultReferenceService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
+ defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
}
/**
*/
@Override
public AuditEventRecord<Reference> getPreviousAuditEvent(Reference t) {
- return defaultReferenceService.getPreviousAuditEvent(t);
+ return defaultService.getPreviousAuditEvent(t);
}
/**
*/
@Override
public List<Reference> getAllReferencesForPublishing() {
- return defaultReferenceService.getAllReferencesForPublishing();
+ return defaultService.getAllReferencesForPublishing();
}
/**
*/
@Override
public int count(Class<? extends Reference> clazz) {
- return defaultReferenceService.count(clazz);
+ return defaultService.count(clazz);
}
/**
*/
@Override
public List<Reference> getAllNomenclaturalReferences() {
- return defaultReferenceService.getAllNomenclaturalReferences();
+ return defaultService.getAllNomenclaturalReferences();
}
/**
*/
@Override
public List<TaxonBase> listCoveredTaxa(Reference reference, boolean includeSubordinateReferences, List<String> propertyPaths) {
- return defaultReferenceService.listCoveredTaxa(reference, includeSubordinateReferences, propertyPaths);
+ return defaultService.listCoveredTaxa(reference, includeSubordinateReferences, propertyPaths);
}
/**
*/
@Override
public Pager<AuditEventRecord<Reference>> pageAuditEvents(Class<? extends Reference> clazz, AuditEvent from, AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List<String> propertyPaths) {
- return defaultReferenceService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
+ return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
}
/**
*/
@Override
public Reference find(LSID lsid) {
- return defaultReferenceService.find(lsid);
+ return defaultService.find(lsid);
}
/**
*/
@Override
public DeleteResult delete(Reference persistentObject) {
- return defaultReferenceService.delete(persistentObject);
+ return defaultService.delete(persistentObject);
}
/**
*/
@Override
public List<Object[]> groupMarkers(Class<? extends Reference> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultReferenceService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
+ return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public boolean exists(UUID uuid) {
- return defaultReferenceService.exists(uuid);
+ return defaultService.exists(uuid);
}
/**
*/
@Override
public Reference replace(Reference x, Reference y) {
- return defaultReferenceService.replace(x, y);
+ return defaultService.replace(x, y);
}
/**
*/
@Override
public List<Reference> find(Set<UUID> uuidSet) {
- return defaultReferenceService.find(uuidSet);
+ return defaultService.find(uuidSet);
}
/**
*/
@Override
public Pager<IdentifiableSource> getSources(Reference t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultReferenceService.getSources(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public Reference find(UUID uuid) {
- return defaultReferenceService.find(uuid);
+ return defaultService.find(uuid);
}
/**
*/
@Override
public Reference find(int id) {
- return defaultReferenceService.find(id);
+ return defaultService.find(id);
}
/**
*/
@Override
public Pager<Rights> getRights(Reference t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultReferenceService.getRights(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public int countMarkers(Class<? extends Reference> clazz, Boolean technical) {
- return defaultReferenceService.countMarkers(clazz, technical);
+ return defaultService.countMarkers(clazz, technical);
}
/**
*/
@Override
public List<Reference> findById(Set<Integer> idSet) {
- return defaultReferenceService.findById(idSet);
+ return defaultService.findById(idSet);
}
/**
*/
@Override
public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
- return defaultReferenceService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
+ return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
}
/**
*/
@Override
public Session getSession() {
- return defaultReferenceService.getSession();
+ return defaultService.getSession();
}
/**
*/
@Override
public List<UuidAndTitleCache<Reference>> getUuidAndTitleCache() {
- return defaultReferenceService.getUuidAndTitleCache();
+ return defaultService.getUuidAndTitleCache();
}
/**
*/
@Override
public List<Object[]> group(Class<? extends Reference> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
- return defaultReferenceService.group(clazz, limit, start, groups, propertyPaths);
+ return defaultService.group(clazz, limit, start, groups, propertyPaths);
}
/**
*/
@Override
public Pager<Reference> findByTitle(Class<? extends Reference> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends Reference> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.list(type, limit, start, orderHints, propertyPaths);
+ return defaultService.list(type, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<Reference> findByTitle(IIdentifiableEntityServiceConfigurator<Reference> configurator) {
- return defaultReferenceService.findByTitle(configurator);
+ return defaultService.findByTitle(configurator);
}
/**
*/
@Override
public Integer countByTitle(Class<? extends Reference> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
- return defaultReferenceService.countByTitle(clazz, queryString, matchmode, criteria);
+ return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
}
/**
*/
@Override
public Reference load(UUID uuid) {
- return defaultReferenceService.load(uuid);
+ return defaultService.load(uuid);
}
/**
*/
@Override
public Reference load(UUID uuid, List<String> propertyPaths) {
- return defaultReferenceService.load(uuid, propertyPaths);
+ return defaultService.load(uuid, propertyPaths);
}
/**
*/
@Override
public Integer countByTitle(IIdentifiableEntityServiceConfigurator<Reference> configurator) {
- return defaultReferenceService.countByTitle(configurator);
+ return defaultService.countByTitle(configurator);
}
/**
*/
@Override
public Reference merge(Reference transientObject) {
- return defaultReferenceService.merge(transientObject);
+ return defaultService.merge(transientObject);
}
/**
*/
@Override
public List<Reference> listByTitle(Class<? extends Reference> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends Reference> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public UUID refresh(Reference persistentObject) {
- return defaultReferenceService.refresh(persistentObject);
+ return defaultService.refresh(persistentObject);
}
/**
*/
@Override
public List<Reference> listByReferenceTitle(Class<? extends Reference> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<Reference> rows(String tableName, int limit, int start) {
- return defaultReferenceService.rows(tableName, limit, start);
+ return defaultService.rows(tableName, limit, start);
}
/**
*/
@Override
public UUID update(Reference transientObject) {
- return defaultReferenceService.update(transientObject);
+ return defaultService.update(transientObject);
}
/**
*/
@Override
public List<Reference> list(Reference example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultReferenceService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
+ return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public int deduplicate(Class<? extends Reference> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
- return defaultReferenceService.deduplicate(clazz, matchStrategy, mergeStrategy);
+ return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
}
/**
*/
@Override
public Pager<Reference> findTitleCache(Class<? extends Reference> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
- return defaultReferenceService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
+ return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
}
@Override
@Override
public Reference findWithoutFlush(UUID uuid) {
- return defaultReferenceService.findWithoutFlush(uuid);
+ return defaultService.findWithoutFlush(uuid);
+ }
+
+ @Override
+ public <S extends Reference> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
}
-
}
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.DefinedTerm;
import eu.etaxonomy.cdm.model.common.ISourceable;
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
*/
public class TransientTaxonService implements ITaxonService {
- private final ITaxonService defaultTaxonService;
+ private final ITaxonService defaultService;
/**
* @param defaultTaxonService
*/
public TransientTaxonService(ITaxonService defaultTaxonService) {
- this.defaultTaxonService = defaultTaxonService;
+ this.defaultService = defaultTaxonService;
}
/**
*/
@Override
public Pager<AuditEventRecord<TaxonBase>> pageAuditEvents(TaxonBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
- return defaultTaxonService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
+ return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
}
/**
*/
@Override
public Pager<Annotation> getAnnotations(TaxonBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void clear() {
- defaultTaxonService.clear();
+ defaultService.clear();
}
/**
*/
@Override
public void lock(TaxonBase t, LockOptions lockOptions) {
- defaultTaxonService.lock(t, lockOptions);
+ defaultService.lock(t, lockOptions);
}
/**
*/
@Override
public void refresh(TaxonBase t, LockOptions lockOptions, List<String> propertyPaths) {
- defaultTaxonService.refresh(t, lockOptions, propertyPaths);
+ defaultService.refresh(t, lockOptions, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache() {
- defaultTaxonService.updateTitleCache();
+ defaultService.updateTitleCache();
}
/**
*/
@Override
public AuditEventRecord<TaxonBase> getNextAuditEvent(TaxonBase t) {
- return defaultTaxonService.getNextAuditEvent(t);
+ return defaultService.getNextAuditEvent(t);
}
/**
*/
@Override
public Pager<Marker> getMarkers(TaxonBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void updateTitleCache(Class<? extends TaxonBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TaxonBase> cacheStrategy, IProgressMonitor monitor) {
- defaultTaxonService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
+ defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
}
/**
*/
@Override
public AuditEventRecord<TaxonBase> getPreviousAuditEvent(TaxonBase t) {
- return defaultTaxonService.getPreviousAuditEvent(t);
+ return defaultService.getPreviousAuditEvent(t);
}
/**
*/
@Override
public int count(Class<? extends TaxonBase> clazz) {
- return defaultTaxonService.count(clazz);
+ return defaultService.count(clazz);
}
/**
*/
@Override
public Pager<AuditEventRecord<TaxonBase>> pageAuditEvents(Class<? extends TaxonBase> clazz, AuditEvent from, AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List<String> propertyPaths) {
- return defaultTaxonService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
+ return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
}
/**
*/
@Override
public TaxonBase find(LSID lsid) {
- return defaultTaxonService.find(lsid);
+ return defaultService.find(lsid);
}
/**
*/
@Override
public DeleteResult delete(TaxonBase persistentObject) {
- return defaultTaxonService.delete(persistentObject);
+ return defaultService.delete(persistentObject);
}
/**
*/
@Override
public List<Object[]> groupMarkers(Class<? extends TaxonBase> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultTaxonService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
+ return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public boolean exists(UUID uuid) {
- return defaultTaxonService.exists(uuid);
+ return defaultService.exists(uuid);
}
*/
@Override
public TaxonBase replace(TaxonBase x, TaxonBase y) {
- return defaultTaxonService.replace(x, y);
+ return defaultService.replace(x, y);
}
/**
*/
@Override
public List<TaxonBase> find(Set<UUID> uuidSet) {
- return defaultTaxonService.find(uuidSet);
+ return defaultService.find(uuidSet);
}
/**
*/
@Override
public Pager<IdentifiableSource> getSources(TaxonBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultTaxonService.getSources(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
}
/**
@Deprecated
@Override
public List<Taxon> getRootTaxa(Reference sec, CdmFetch cdmFetch, boolean onlyWithChildren) {
- return defaultTaxonService.getRootTaxa(sec, cdmFetch, onlyWithChildren);
+ return defaultService.getRootTaxa(sec, cdmFetch, onlyWithChildren);
}
/**
*/
@Override
public TaxonBase find(UUID uuid) {
- return defaultTaxonService.find(uuid);
+ return defaultService.find(uuid);
}
/**
@Deprecated
@Override
public List<Taxon> getRootTaxa(Rank rank, Reference sec, boolean onlyWithChildren, boolean withMisapplications, List<String> propertyPaths) {
- return defaultTaxonService.getRootTaxa(rank, sec, onlyWithChildren, withMisapplications, propertyPaths);
+ return defaultService.getRootTaxa(rank, sec, onlyWithChildren, withMisapplications, propertyPaths);
}
/**
*/
@Override
public TaxonBase find(int id) {
- return defaultTaxonService.find(id);
+ return defaultService.find(id);
}
/**
*/
@Override
public Pager<Rights> getRights(TaxonBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultTaxonService.getRights(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public int countMarkers(Class<? extends TaxonBase> clazz, Boolean technical) {
- return defaultTaxonService.countMarkers(clazz, technical);
+ return defaultService.countMarkers(clazz, technical);
}
/**
*/
@Override
public List<TaxonBase> findById(Set<Integer> idSet) {
- return defaultTaxonService.findById(idSet);
+ return defaultService.findById(idSet);
}
/**
*/
@Override
public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
- return defaultTaxonService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
+ return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
}
/**
*/
@Override
public Session getSession() {
- return defaultTaxonService.getSession();
+ return defaultService.getSession();
}
/**
*/
@Override
public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCache() {
- return defaultTaxonService.getUuidAndTitleCache();
+ return defaultService.getUuidAndTitleCache();
}
/**
*/
@Override
public List<Object[]> group(Class<? extends TaxonBase> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
- return defaultTaxonService.group(clazz, limit, start, groups, propertyPaths);
+ return defaultService.group(clazz, limit, start, groups, propertyPaths);
}
/**
*/
@Override
public List<RelationshipBase> getAllRelationships(int limit, int start) {
- return defaultTaxonService.getAllRelationships(limit, start);
+ return defaultService.getAllRelationships(limit, start);
}
/**
*/
@Override
public Pager<TaxonBase> findByTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public OrderedTermVocabulary<TaxonRelationshipType> getTaxonRelationshipTypeVocabulary() {
- return defaultTaxonService.getTaxonRelationshipTypeVocabulary();
+ return defaultService.getTaxonRelationshipTypeVocabulary();
}
/**
*/
@Override
public List<TaxonBase> searchTaxaByName(String name, Reference sec) {
- return defaultTaxonService.searchTaxaByName(name, sec);
+ return defaultService.searchTaxaByName(name, sec);
}
/**
*/
@Override
public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon) {
- defaultTaxonService.swapSynonymAndAcceptedTaxon(synonym, acceptedTaxon);
+ defaultService.swapSynonymAndAcceptedTaxon(synonym, acceptedTaxon);
}
/**
*/
@Override
public <S extends TaxonBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.list(type, limit, start, orderHints, propertyPaths);
+ return defaultService.list(type, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonBase> findByTitle(IIdentifiableEntityServiceConfigurator<TaxonBase> configurator) {
- return defaultTaxonService.findByTitle(configurator);
+ return defaultService.findByTitle(configurator);
}
/**
*/
@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);
+ return defaultService.changeSynonymToAcceptedTaxon(synonym, acceptedTaxon, deleteSynonym, copyCitationInfo, citation, microCitation);
}
/**
*/
@Override
public Integer countByTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
- return defaultTaxonService.countByTitle(clazz, queryString, matchmode, criteria);
+ return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
}
/**
*/
@Override
public TaxonBase load(UUID uuid) {
- return defaultTaxonService.load(uuid);
+ return defaultService.load(uuid);
}
/**
*/
@Override
public TaxonBase load(UUID uuid, List<String> propertyPaths) {
- return defaultTaxonService.load(uuid, propertyPaths);
+ return defaultService.load(uuid, propertyPaths);
}
/**
*/
@Override
public Integer countByTitle(IIdentifiableEntityServiceConfigurator<TaxonBase> configurator) {
- return defaultTaxonService.countByTitle(configurator);
+ return defaultService.countByTitle(configurator);
}
/**
*/
@Override
public TaxonBase merge(TaxonBase transientObject) {
- return defaultTaxonService.merge(transientObject);
+ return defaultService.merge(transientObject);
}
/**
*/
@Override
public List<TaxonBase> listByTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends TaxonBase> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public UUID refresh(TaxonBase persistentObject) {
- return defaultTaxonService.refresh(persistentObject);
+ return defaultService.refresh(persistentObject);
}
/**
*/
@Override
public Taxon changeSynonymToRelatedTaxon(Synonym synonym, Taxon toTaxon, TaxonRelationshipType taxonRelationshipType, Reference reference, String microReference) {
- return defaultTaxonService.changeSynonymToRelatedTaxon(synonym, toTaxon, taxonRelationshipType, reference, microReference);
+ return defaultService.changeSynonymToRelatedTaxon(synonym, toTaxon, taxonRelationshipType, reference, microReference);
}
/**
*/
@Override
public List<TaxonBase> listByReferenceTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<TaxonBase> rows(String tableName, int limit, int start) {
- return defaultTaxonService.rows(tableName, limit, start);
+ return defaultService.rows(tableName, limit, start);
}
/**
*/
@Override
public long deleteSynonymRelationships(Synonym syn, Taxon taxon) {
- return defaultTaxonService.deleteSynonymRelationships(syn, taxon);
+ return defaultService.deleteSynonymRelationships(syn, taxon);
}
/**
*/
@Override
public void changeHomotypicalGroupOfSynonym(Synonym synonym, HomotypicalGroup newHomotypicalGroup, Taxon targetTaxon, boolean removeFromOtherTaxa, boolean setBasionymRelationIfApplicable) {
- defaultTaxonService.changeHomotypicalGroupOfSynonym(synonym, newHomotypicalGroup, targetTaxon, removeFromOtherTaxa, setBasionymRelationIfApplicable);
+ defaultService.changeHomotypicalGroupOfSynonym(synonym, newHomotypicalGroup, targetTaxon, removeFromOtherTaxa, setBasionymRelationIfApplicable);
}
/**
*/
@Override
public UUID update(TaxonBase transientObject) {
- return defaultTaxonService.update(transientObject);
+ return defaultService.update(transientObject);
}
/**
*/
@Override
public List<TaxonBase> list(TaxonBase example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
+ return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
}
/**
*/
@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);
+ return defaultService.moveSynonymToAnotherTaxon(oldSynonymRelation, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);
}
/**
*/
@Override
public int deduplicate(Class<? extends TaxonBase> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
- return defaultTaxonService.deduplicate(clazz, matchStrategy, mergeStrategy);
+ return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
}
/**
*/
@Override
public Pager<TaxonBase> findTitleCache(Class<? extends TaxonBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
- return defaultTaxonService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
+ return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
}
/**
*/
@Override
public List<TaxonRelationship> listToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.listToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonRelationship> pageToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.pageToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.pageToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<TaxonRelationship> listFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.listFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonRelationship> pageFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.pageFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.pageFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Set<Taxon> listRelatedTaxa(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, Integer maxDepth, Integer limit, Integer start, List<String> propertyPaths) {
- return defaultTaxonService.listRelatedTaxa(taxon, includeRelationships, maxDepth, limit, start, propertyPaths);
+ return defaultService.listRelatedTaxa(taxon, includeRelationships, maxDepth, limit, start, propertyPaths);
}
/**
*/
@Override
public List<Classification> listClassifications(TaxonBase taxonBase, Integer limit, Integer start, List<String> propertyPaths) {
- return defaultTaxonService.listClassifications(taxonBase, limit, start, propertyPaths);
+ return defaultService.listClassifications(taxonBase, limit, start, propertyPaths);
}
/**
*/
@Override
public Pager<SynonymRelationship> getSynonyms(Synonym synonym, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.getSynonyms(synonym, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getSynonyms(synonym, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<SynonymRelationship> getSynonyms(Taxon taxon, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.getSynonyms(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getSynonyms(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<Synonym> getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths) {
- return defaultTaxonService.getHomotypicSynonymsByHomotypicGroup(taxon, propertyPaths);
+ return defaultService.getHomotypicSynonymsByHomotypicGroup(taxon, propertyPaths);
}
/**
*/
@Override
public List<List<Synonym>> getHeterotypicSynonymyGroups(Taxon taxon, List<String> propertyPaths) {
- return defaultTaxonService.getHeterotypicSynonymyGroups(taxon, propertyPaths);
+ return defaultService.getHeterotypicSynonymyGroups(taxon, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonBase> search(Class<? extends TaxonBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<TaxonBase> findTaxaByName(Class<? extends TaxonBase> 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);
+ return defaultService.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber);
}
/**
*/
@Override
public List<TaxonBase> listTaxaByName(Class<? extends TaxonBase> 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);
+ return defaultService.listTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber);
}
/**
*/
@Override
public Pager<IdentifiableEntity> findTaxaAndNames(IFindTaxaAndNamesConfigurator configurator) {
- return defaultTaxonService.findTaxaAndNames(configurator);
+ return defaultService.findTaxaAndNames(configurator);
}
/**
@Deprecated
@Override
public Pager<SearchResult<TaxonBase>> findByEverythingFullText(String queryString, Classification classification, List<Language> languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws CorruptIndexException, IOException, ParseException, LuceneMultiSearchException {
- return defaultTaxonService.findByEverythingFullText(queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByEverythingFullText(queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<SearchResult<TaxonBase>> findByFullText(Class<? extends TaxonBase> clazz, String queryString, Classification classification, List<Language> languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws CorruptIndexException, IOException, ParseException {
- return defaultTaxonService.findByFullText(clazz, queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByFullText(clazz, queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
}
List<PresenceAbsenceTerm> statusFilter, Classification classification, Integer pageSize,
Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws IOException,
ParseException {
- return defaultTaxonService.findByDistribution(areaFilter, statusFilter, classification, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByDistribution(areaFilter, statusFilter, classification, pageSize, pageNumber, orderHints, propertyPaths);
}
Set<PresenceAbsenceTerm> distributionStatus, List<Language> languages, boolean highlightFragments,
Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths)
throws CorruptIndexException, IOException, ParseException, LuceneMultiSearchException {
- return defaultTaxonService.findTaxaAndNamesByFullText(searchModes, queryString, classification, namedAreas, distributionStatus, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findTaxaAndNamesByFullText(searchModes, queryString, classification, namedAreas, distributionStatus, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<SearchResult<TaxonBase>> findByDescriptionElementFullText(Class<? extends DescriptionElementBase> clazz, String queryString, Classification classification, List<Feature> features, List<Language> languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws CorruptIndexException, IOException, ParseException {
- return defaultTaxonService.findByDescriptionElementFullText(clazz, queryString, classification, features, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByDescriptionElementFullText(clazz, queryString, classification, features, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
@Deprecated
@Override
public List<MediaRepresentation> getAllMedia(Taxon taxon, int size, int height, int widthOrDuration, String[] mimeTypes) {
- return defaultTaxonService.getAllMedia(taxon, size, height, widthOrDuration, mimeTypes);
+ return defaultService.getAllMedia(taxon, size, height, widthOrDuration, mimeTypes);
}
/**
@Deprecated
@Override
public List<Media> listTaxonDescriptionMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, boolean limitToGalleries, List<String> propertyPath) {
- return defaultTaxonService.listTaxonDescriptionMedia(taxon, includeRelationships, limitToGalleries, propertyPath);
+ return defaultService.listTaxonDescriptionMedia(taxon, includeRelationships, limitToGalleries, propertyPath);
}
/**
*/
@Override
public List<Media> listMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, Boolean limitToGalleries, Boolean includeTaxonDescriptions, Boolean includeOccurrences, Boolean includeTaxonNameDescriptions, List<String> propertyPath) {
- return defaultTaxonService.listMedia(taxon, includeRelationships, limitToGalleries, includeTaxonDescriptions, includeOccurrences, includeTaxonNameDescriptions, propertyPath);
+ return defaultService.listMedia(taxon, includeRelationships, limitToGalleries, includeTaxonDescriptions, includeOccurrences, includeTaxonNameDescriptions, propertyPath);
}
/**
*/
@Override
public List<TaxonBase> findTaxaByID(Set<Integer> listOfIDs) {
- return defaultTaxonService.findTaxaByID(listOfIDs);
+ return defaultService.findTaxaByID(listOfIDs);
}
/**
*/
@Override
public TaxonBase findTaxonByUuid(UUID uuid, List<String> propertyPaths) {
- return defaultTaxonService.findTaxonByUuid(uuid, propertyPaths);
+ return defaultService.findTaxonByUuid(uuid, propertyPaths);
}
/**
*/
@Override
public int countAllRelationships() {
- return defaultTaxonService.countAllRelationships();
+ return defaultService.countAllRelationships();
}
/**
*/
@Override
public List<TaxonNameBase> findIdenticalTaxonNames(List<String> propertyPath) {
- return defaultTaxonService.findIdenticalTaxonNames(propertyPath);
+ return defaultService.findIdenticalTaxonNames(propertyPath);
}
/**
*/
@Override
public List<TaxonNameBase> findIdenticalTaxonNameIds(List<String> propertyPath) {
- return defaultTaxonService.findIdenticalTaxonNameIds(propertyPath);
+ return defaultService.findIdenticalTaxonNameIds(propertyPath);
}
/**
*/
@Override
public String getPhylumName(TaxonNameBase name) {
- return defaultTaxonService.getPhylumName(name);
+ return defaultService.getPhylumName(name);
}
/**
*/
@Override
public long deleteSynonymRelationships(Synonym syn) {
- return defaultTaxonService.deleteSynonymRelationships(syn);
+ return defaultService.deleteSynonymRelationships(syn);
}
/**
*/
@Override
public List<SynonymRelationship> listSynonymRelationships(TaxonBase taxonBase, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths, Direction direction) {
- return defaultTaxonService.listSynonymRelationships(taxonBase, type, pageSize, pageNumber, orderHints, propertyPaths, direction);
+ return defaultService.listSynonymRelationships(taxonBase, type, pageSize, pageNumber, orderHints, propertyPaths, direction);
}
/**
*/
@Override
public Taxon findBestMatchingTaxon(String taxonName) {
- return defaultTaxonService.findBestMatchingTaxon(taxonName);
+ return defaultService.findBestMatchingTaxon(taxonName);
}
/**
*/
@Override
public Taxon findBestMatchingTaxon(MatchingTaxonConfigurator config) {
- return defaultTaxonService.findBestMatchingTaxon(config);
+ return defaultService.findBestMatchingTaxon(config);
}
/**
*/
@Override
public Synonym findBestMatchingSynonym(String taxonName) {
- return defaultTaxonService.findBestMatchingSynonym(taxonName);
+ return defaultService.findBestMatchingSynonym(taxonName);
}
/**
*/
@Override
public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheTaxon() {
- return defaultTaxonService.getUuidAndTitleCacheTaxon();
+ return defaultService.getUuidAndTitleCacheTaxon();
}
/**
*/
@Override
public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheSynonym() {
- return defaultTaxonService.getUuidAndTitleCacheSynonym();
+ return defaultService.getUuidAndTitleCacheSynonym();
}
/**
*/
@Override
public List<UuidAndTitleCache<IdentifiableEntity>> findTaxaAndNamesForEditor(IFindTaxaAndNamesConfigurator configurator) {
- return defaultTaxonService.findTaxaAndNamesForEditor(configurator);
+ return defaultService.findTaxaAndNamesForEditor(configurator);
}
/**
*/
@Override
public List<Synonym> createInferredSynonyms(Taxon taxon, Classification tree, SynonymRelationshipType type, boolean doWithMisappliedNames) {
- return defaultTaxonService.createInferredSynonyms(taxon, tree, type, doWithMisappliedNames);
+ return defaultService.createInferredSynonyms(taxon, tree, type, doWithMisappliedNames);
}
/**
*/
@Override
public List<Synonym> createAllInferredSynonyms(Taxon taxon, Classification tree, boolean doWithMisappliedNames) {
- return defaultTaxonService.createAllInferredSynonyms(taxon, tree, doWithMisappliedNames);
+ return defaultService.createAllInferredSynonyms(taxon, tree, doWithMisappliedNames);
}
@Override
public DeleteResult deleteSynonym(Synonym arg0, SynonymDeletionConfigurator arg1) {
- return defaultTaxonService.deleteSynonym(arg0, arg1);
+ return defaultService.deleteSynonym(arg0, arg1);
}
@Override
public DeleteResult deleteSynonym(Synonym arg0, Taxon arg1, SynonymDeletionConfigurator arg2) {
- return defaultTaxonService.deleteSynonym(arg0, arg1, arg2);
+ return defaultService.deleteSynonym(arg0, arg1, arg2);
}
@Override
public DeleteResult deleteTaxon(Taxon arg0, TaxonDeletionConfigurator arg1, Classification arg2) {
- return defaultTaxonService.deleteTaxon(arg0, arg1, arg2);
+ return defaultService.deleteTaxon(arg0, arg1, arg2);
}
@Override
public List<List<Synonym>> getSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths) {
- return defaultTaxonService.getSynonymsByHomotypicGroup(taxon, propertyPaths);
+ return defaultService.getSynonymsByHomotypicGroup(taxon, propertyPaths);
}
@Override
SynonymRelationshipType synonymRelationshipType)
throws DataChangeNoRollbackException {
- return defaultTaxonService.changeRelatedTaxonToSynonym(fromTaxon, toTaxon, oldRelationshipType, synonymRelationshipType);
+ return defaultService.changeRelatedTaxonToSynonym(fromTaxon, toTaxon, oldRelationshipType, synonymRelationshipType);
}
/* (non-Javadoc)
@Override
public Pager<Taxon> pageAcceptedTaxaFor(UUID synonymUuid, UUID classificationUuid, Integer pageSize,
Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.pageAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.pageAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
}
/* (non-Javadoc)
@Override
public List<Taxon> listAcceptedTaxaFor(UUID synonymUuid, UUID classificationUuid, Integer pageSize,
Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTaxonService.listAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
}
@Override
@Override
public TaxonBase findWithoutFlush(UUID uuid) {
- return defaultTaxonService.findWithoutFlush(uuid);
+ return defaultService.findWithoutFlush(uuid);
}
/* (non-Javadoc)
*/
@Override
public List<TaxonBase> findTaxaByName(MatchingTaxonConfigurator config) {
- return defaultTaxonService.findTaxaByName(config);
+ return defaultService.findTaxaByName(config);
}
-
+
+ @Override
+ public <S extends TaxonBase> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
+ }
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.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.ISourceable;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
*/
public class TransientTermService implements ITermService {
- private final ITermService defaultTermService;
+ private final ITermService defaultService;
/**
* @param defaultTermService
*/
public TransientTermService(ITermService defaultTermService) {
- this.defaultTermService = defaultTermService;
+ this.defaultService = defaultTermService;
}
/**
*/
@Override
public Pager<AuditEventRecord<DefinedTermBase>> pageAuditEvents(DefinedTermBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
- return defaultTermService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
+ return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
}
/**
*/
@Override
public Pager<Annotation> getAnnotations(DefinedTermBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public void clear() {
- defaultTermService.clear();
+ defaultService.clear();
}
/**
*/
@Override
public void lock(DefinedTermBase t, LockOptions lockOptions) {
- defaultTermService.lock(t, lockOptions);
+ defaultService.lock(t, lockOptions);
}
/**
*/
@Override
public DefinedTermBase getByUri(URI uri) {
- return defaultTermService.getByUri(uri);
+ return defaultService.getByUri(uri);
}
/**
*/
@Override
public void refresh(DefinedTermBase t, LockOptions lockOptions, List<String> propertyPaths) {
- defaultTermService.refresh(t, lockOptions, propertyPaths);
+ defaultService.refresh(t, lockOptions, propertyPaths);
}
/**
*/
@Override
public List<LanguageString> getAllLanguageStrings(int limit, int start) {
- return defaultTermService.getAllLanguageStrings(limit, start);
+ return defaultService.getAllLanguageStrings(limit, start);
}
/**
*/
@Override
public List<Representation> getAllRepresentations(int limit, int start) {
- return defaultTermService.getAllRepresentations(limit, start);
+ return defaultService.getAllRepresentations(limit, start);
}
/**
*/
@Override
public void updateTitleCache() {
- defaultTermService.updateTitleCache();
+ defaultService.updateTitleCache();
}
/**
*/
@Override
public AuditEventRecord<DefinedTermBase> getNextAuditEvent(DefinedTermBase t) {
- return defaultTermService.getNextAuditEvent(t);
+ return defaultService.getNextAuditEvent(t);
}
/**
*/
@Override
public Language getLanguageByIso(String iso639) {
- return defaultTermService.getLanguageByIso(iso639);
+ return defaultService.getLanguageByIso(iso639);
}
/**
*/
@Override
public List<Language> getLanguagesByLocale(Enumeration<Locale> locales) {
- return defaultTermService.getLanguagesByLocale(locales);
+ return defaultService.getLanguagesByLocale(locales);
}
/**
*/
@Override
public NamedArea getAreaByTdwgAbbreviation(String tdwgAbbreviation) {
- return defaultTermService.getAreaByTdwgAbbreviation(tdwgAbbreviation);
+ return defaultService.getAreaByTdwgAbbreviation(tdwgAbbreviation);
}
/**
*/
@Override
public Pager<Marker> getMarkers(DefinedTermBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize, Integer pageNumber) {
- return defaultTermService.getMedia(definedTerm, pageSize, pageNumber);
+ return defaultService.getMedia(definedTerm, pageSize, pageNumber);
}
/**
*/
@Override
public void updateTitleCache(Class<? extends DefinedTermBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<DefinedTermBase> cacheStrategy, IProgressMonitor monitor) {
- defaultTermService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
+ defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
}
/**
*/
@Override
public AuditEventRecord<DefinedTermBase> getPreviousAuditEvent(DefinedTermBase t) {
- return defaultTermService.getPreviousAuditEvent(t);
+ return defaultService.getPreviousAuditEvent(t);
}
/**
*/
@Override
public int count(Class<? extends DefinedTermBase> clazz) {
- return defaultTermService.count(clazz);
+ return defaultService.count(clazz);
}
/**
*/
@Override
public Pager<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.list(level, type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.list(level, type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public Pager<AuditEventRecord<DefinedTermBase>> pageAuditEvents(Class<? extends DefinedTermBase> clazz, AuditEvent from, AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List<String> propertyPaths) {
- return defaultTermService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
+ return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
}
/**
*/
@Override
public DefinedTermBase find(LSID lsid) {
- return defaultTermService.find(lsid);
+ return defaultService.find(lsid);
}
/**
*/
@Override
public DeleteResult delete(DefinedTermBase persistentObject) {
- return defaultTermService.delete(persistentObject);
+ return defaultService.delete(persistentObject);
}
/**
*/
@Override
public List<Object[]> groupMarkers(Class<? extends DefinedTermBase> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultTermService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
+ return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public boolean exists(UUID uuid) {
- return defaultTermService.exists(uuid);
+ return defaultService.exists(uuid);
}
/**
*/
@Override
public DefinedTermBase replace(DefinedTermBase x, DefinedTermBase y) {
- return defaultTermService.replace(x, y);
+ return defaultService.replace(x, y);
}
/**
*/
@Override
public <T extends DefinedTermBase> Pager<T> getGeneralizationOf(T definedTerm, Integer pageSize, Integer pageNumber) {
- return defaultTermService.getGeneralizationOf(definedTerm, pageSize, pageNumber);
+ return defaultService.getGeneralizationOf(definedTerm, pageSize, pageNumber);
}
/**
*/
@Override
public List<DefinedTermBase> find(Set<UUID> uuidSet) {
- return defaultTermService.find(uuidSet);
+ return defaultService.find(uuidSet);
}
/**
*/
@Override
public Pager<IdentifiableSource> getSources(DefinedTermBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultTermService.getSources(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public DefinedTermBase find(UUID uuid) {
- return defaultTermService.find(uuid);
+ return defaultService.find(uuid);
}
/**
*/
@Override
public <T extends DefinedTermBase> Pager<T> getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultTermService.getPartOf(definedTerms, pageSize, pageNumber, propertyPaths);
+ return defaultService.getPartOf(definedTerms, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public DefinedTermBase find(int id) {
- return defaultTermService.find(id);
+ return defaultService.find(id);
}
/**
*/
@Override
public Pager<Rights> getRights(DefinedTermBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultTermService.getRights(t, pageSize, pageNumber, propertyPaths);
+ return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public int countMarkers(Class<? extends DefinedTermBase> clazz, Boolean technical) {
- return defaultTermService.countMarkers(clazz, technical);
+ return defaultService.countMarkers(clazz, technical);
}
/**
*/
@Override
public List<DefinedTermBase> findById(Set<Integer> idSet) {
- return defaultTermService.findById(idSet);
+ return defaultService.findById(idSet);
}
/**
*/
@Override
public <T extends DefinedTermBase> Pager<T> getIncludes(Collection<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
- return defaultTermService.getIncludes(definedTerms, pageSize, pageNumber, propertyPaths);
+ return defaultService.getIncludes(definedTerms, pageSize, pageNumber, propertyPaths);
}
/**
*/
@Override
public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
- return defaultTermService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
+ return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
}
/**
*/
@Override
public Session getSession() {
- return defaultTermService.getSession();
+ return defaultService.getSession();
}
/**
*/
@Override
public List<UuidAndTitleCache<DefinedTermBase>> getUuidAndTitleCache() {
- return defaultTermService.getUuidAndTitleCache();
+ return defaultService.getUuidAndTitleCache();
}
/**
*/
@Override
public List<Object[]> group(Class<? extends DefinedTermBase> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
- return defaultTermService.group(clazz, limit, start, groups, propertyPaths);
+ return defaultService.group(clazz, limit, start, groups, propertyPaths);
}
/**
*/
@Override
public <T extends DefinedTermBase> Pager<T> findByRepresentationText(String label, Class<T> clazz, Integer pageSize, Integer pageNumber) {
- return defaultTermService.findByRepresentationText(label, clazz, pageSize, pageNumber);
+ return defaultService.findByRepresentationText(label, clazz, pageSize, pageNumber);
}
/**
*/
@Override
public Pager<DefinedTermBase> findByTitle(Class<? extends DefinedTermBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <T extends DefinedTermBase> Pager<T> findByRepresentationAbbreviation(String abbrev, Class<T> clazz, Integer pageSize, Integer pageNumber) {
- return defaultTermService.findByRepresentationAbbreviation(abbrev, clazz, pageSize, pageNumber);
+ return defaultService.findByRepresentationAbbreviation(abbrev, clazz, pageSize, pageNumber);
}
/**
*/
@Override
public <S extends DefinedTermBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.list(type, limit, start, orderHints, propertyPaths);
+ return defaultService.list(type, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public DeleteResult delete(DefinedTermBase term, TermDeletionConfigurator config) {
- return defaultTermService.delete(term, config);
+ return defaultService.delete(term, config);
}
/**
*/
@Override
public Pager<DefinedTermBase> findByTitle(IIdentifiableEntityServiceConfigurator<DefinedTermBase> configurator) {
- return defaultTermService.findByTitle(configurator);
+ return defaultService.findByTitle(configurator);
}
/**
*/
@Override
public Integer countByTitle(Class<? extends DefinedTermBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
- return defaultTermService.countByTitle(clazz, queryString, matchmode, criteria);
+ return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
}
/**
*/
@Override
public DefinedTermBase load(UUID uuid) {
- return defaultTermService.load(uuid);
+ return defaultService.load(uuid);
}
/**
*/
@Override
public DefinedTermBase load(UUID uuid, List<String> propertyPaths) {
- return defaultTermService.load(uuid, propertyPaths);
+ return defaultService.load(uuid, propertyPaths);
}
/**
*/
@Override
public Integer countByTitle(IIdentifiableEntityServiceConfigurator<DefinedTermBase> configurator) {
- return defaultTermService.countByTitle(configurator);
+ return defaultService.countByTitle(configurator);
}
/**
*/
@Override
public DefinedTermBase merge(DefinedTermBase transientObject) {
- return defaultTermService.merge(transientObject);
+ return defaultService.merge(transientObject);
}
/**
*/
@Override
public List<DefinedTermBase> listByTitle(Class<? extends DefinedTermBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public <S extends DefinedTermBase> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public UUID refresh(DefinedTermBase persistentObject) {
- return defaultTermService.refresh(persistentObject);
+ return defaultService.refresh(persistentObject);
}
/**
*/
@Override
public List<DefinedTermBase> listByReferenceTitle(Class<? extends DefinedTermBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public List<DefinedTermBase> rows(String tableName, int limit, int start) {
- return defaultTermService.rows(tableName, limit, start);
+ return defaultService.rows(tableName, limit, start);
}
/**
*/
@Override
public Pager<DefinedTermBase> search(Class<? extends DefinedTermBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
/**
*/
@Override
public UUID update(DefinedTermBase transientObject) {
- return defaultTermService.update(transientObject);
+ return defaultService.update(transientObject);
}
/**
*/
@Override
public List<DefinedTermBase> list(DefinedTermBase example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
+ return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
}
/**
*/
@Override
public int deduplicate(Class<? extends DefinedTermBase> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
- return defaultTermService.deduplicate(clazz, matchStrategy, mergeStrategy);
+ return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
}
/**
*/
@Override
public Pager<DefinedTermBase> findTitleCache(Class<? extends DefinedTermBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
- return defaultTermService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
+ return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
}
@Override
public <TERM extends DefinedTermBase> TERM findByIdInVocabulary(String id, UUID vocabularyUuid,
Class<TERM> clazz) {
- return defaultTermService.findByIdInVocabulary(id, vocabularyUuid, clazz);
+ return defaultService.findByIdInVocabulary(id, vocabularyUuid, clazz);
}
@Override
public DeleteResult isDeletable(DefinedTermBase object,
DeleteConfiguratorBase config) {
- return defaultTermService.isDeletable(object, config);
+ return defaultService.isDeletable(object, config);
}
/* (non-Javadoc)
@Override
public List<DefinedTermBase<?>> listByTermType(TermType termType, Integer limit, Integer start,
List<OrderHint> orderHints, List<String> propertyPaths) {
- return defaultTermService.listByTermType(termType, limit, start, orderHints, propertyPaths);
+ return defaultService.listByTermType(termType, limit, start, orderHints, propertyPaths);
}
@Override
public DefinedTermBase findWithoutFlush(UUID uuid) {
- return defaultTermService.findWithoutFlush(uuid);
+ return defaultService.findWithoutFlush(uuid);
+ }
+
+
+ @Override
+ public <S extends DefinedTermBase> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
+ return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
}
}