import eu.etaxonomy.cdm.api.service.DeleteResult;
import eu.etaxonomy.cdm.api.service.IClassificationService;
+import eu.etaxonomy.cdm.api.service.UpdateResult;
+import eu.etaxonomy.cdm.api.service.config.CreateHierarchyForClassificationConfigurator;
import eu.etaxonomy.cdm.api.service.config.DeleteConfiguratorBase;
import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
+import eu.etaxonomy.cdm.api.service.dto.FindByIdentifierDTO;
import eu.etaxonomy.cdm.api.service.pager.Pager;
import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
import eu.etaxonomy.cdm.model.common.Annotation;
+import eu.etaxonomy.cdm.model.common.DefinedTerm;
import eu.etaxonomy.cdm.model.common.ISourceable;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.LSID;
import eu.etaxonomy.cdm.model.common.Marker;
import eu.etaxonomy.cdm.model.common.MarkerType;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.media.MediaRepresentation;
import eu.etaxonomy.cdm.model.media.Rights;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
*/
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
- public List<String> isDeletable(Classification object,
+ public DeleteResult isDeletable(Classification object,
DeleteConfiguratorBase config) {
// TODO Auto-generated method stub
return null;
@Override
public Classification findWithoutFlush(UUID uuid) {
- return defaultClassificationService.findWithoutFlush(uuid);
+ return defaultService.findWithoutFlush(uuid);
}
+ @Override
+ public <S extends Classification> Pager<FindByIdentifierDTO<S>> findByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, boolean includeEntity, Integer pageSize, Integer pageNumber, List<String> propertyPaths){
+ return defaultService.findByIdentifier(clazz, identifier, identifierType, matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
+ }
+
+ @Override
+ public UpdateResult createHierarchyInClassification(Classification arg1, CreateHierarchyForClassificationConfigurator arg2) {
+ return defaultService.createHierarchyInClassification(arg1, arg2);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.UUID)
+ */
+ @Override
+ public DeleteResult delete(UUID arg0) {
+ return defaultService.delete(arg0);
+ }
+
}
BGBM BDI Projects / taxeditor.git / blobdiff