eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2013 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10 package eu.etaxonomy.taxeditor.editor.view.dataimport.transientServices;
  11
  12 import java.util.Collection;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Set;
  16 import java.util.UUID;
  17
  18 import org.hibernate.LockOptions;
  19 import org.hibernate.Session;
  20 import org.hibernate.criterion.Criterion;
  21 import org.hibernate.envers.query.criteria.AuditCriterion;
  22
  23 import eu.etaxonomy.cdm.api.service.DeleteResult;
  24 import eu.etaxonomy.cdm.api.service.IClassificationService;
  25 import eu.etaxonomy.cdm.api.service.UpdateResult;
  26 import eu.etaxonomy.cdm.api.service.config.CreateHierarchyForClassificationConfigurator;
  27 import eu.etaxonomy.cdm.api.service.config.DeleteConfiguratorBase;
  28 import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
  29 import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
  30 import eu.etaxonomy.cdm.api.service.dto.FindByIdentifierDTO;
  31 import eu.etaxonomy.cdm.api.service.dto.GroupedTaxonDTO;
  32 import eu.etaxonomy.cdm.api.service.pager.Pager;
  33 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  34 import eu.etaxonomy.cdm.model.common.Annotation;
  35 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  36 import eu.etaxonomy.cdm.model.common.ISourceable;
  37 import eu.etaxonomy.cdm.model.common.IdentifiableSource;
  38 import eu.etaxonomy.cdm.model.common.LSID;
  39 import eu.etaxonomy.cdm.model.common.Marker;
  40 import eu.etaxonomy.cdm.model.common.MarkerType;
  41 import eu.etaxonomy.cdm.model.media.MediaRepresentation;
  42 import eu.etaxonomy.cdm.model.media.Rights;
  43 import eu.etaxonomy.cdm.model.name.Rank;
  44 import eu.etaxonomy.cdm.model.taxon.Classification;
  45 import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
  46 import eu.etaxonomy.cdm.model.taxon.Taxon;
  47 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  48 import eu.etaxonomy.cdm.model.view.AuditEvent;
  49 import eu.etaxonomy.cdm.model.view.AuditEventRecord;
  50 import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
  51 import eu.etaxonomy.cdm.persistence.dto.ClassificationLookupDTO;
  52 import eu.etaxonomy.cdm.persistence.dto.MergeResult;
  53 import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
  54 import eu.etaxonomy.cdm.persistence.query.Grouping;
  55 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  56 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  57 import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
  58 import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
  59 import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
  60
  61 /**
  62  * @author pplitzner
  63  * @date 27.09.2013
  64  *
  65  */
  66 public class TransientClassificationService implements IClassificationService {
  67
  68     private final IClassificationService defaultService;
  69
  70     /**
  71      * @param defaultClassificationService
  72      */
  73     public TransientClassificationService(IClassificationService defaultClassificationService) {
  74         this.defaultService = defaultClassificationService;
  75     }
  76
  77     /**
  78      * @param t
  79      * @param pageSize
  80      * @param pageNumber
  81      * @param sort
  82      * @param propertyPaths
  83      * @return
  84      * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List)
  85      */
  86     @Override
  87     public Pager<AuditEventRecord<Classification>> pageAuditEvents(Classification t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
  88         return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
  89     }
  90
  91     /**
  92      * @param annotatedObj
  93      * @param status
  94      * @param pageSize
  95      * @param pageNumber
  96      * @param orderHints
  97      * @param propertyPaths
  98      * @return
  99      * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 100      */
 101     @Override
 102     public Pager<Annotation> getAnnotations(Classification annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 103         return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
 104     }
 105
 106     /**
 107      * @param uuid
 108      * @return
 109      * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTaxonNodeByUuid(java.util.UUID)
 110      */
 111     @Override
 112     public TaxonNode getTaxonNodeByUuid(UUID uuid) {
 113         return defaultService.getTaxonNodeByUuid(uuid);
 114     }
 115
 116     /**
 117      * @param uuid
 118      * @return
 119      * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTreeNodeByUuid(java.util.UUID)
 120      */
 121     @Override
 122     public ITaxonTreeNode getTreeNodeByUuid(UUID uuid) {
 123         return defaultService.getTreeNodeByUuid(uuid);
 124     }
 125
 126     /**
 127      *
 128      * @see eu.etaxonomy.cdm.api.service.IService#clear()
 129      */
 130     @Override
 131     public void clear() {
 132         defaultService.clear();
 133     }
 134
 135     /**
 136      * @param limit
 137      * @param start
 138      * @param orderHints
 139      * @param propertyPaths
 140      * @return
 141      * @see eu.etaxonomy.cdm.api.service.IClassificationService#listClassifications(java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 142      */
 143     @Override
 144     public List<Classification> listClassifications(Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 145         return defaultService.listClassifications(limit, start, orderHints, propertyPaths);
 146     }
 147
 148     /**
 149      * @param t
 150      * @param lockMode
 151      * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode)
 152      */
 153     @Override
 154     public void lock(Classification t, LockOptions lockOptions) {
 155         defaultService.lock(t, lockOptions);
 156     }
 157
 158     /**
 159      * @param t
 160      * @param lockMode
 161      * @param propertyPaths
 162      * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List)
 163      */
 164     @Override
 165     public void refresh(Classification t, LockOptions lockOptions, List<String> propertyPaths) {
 166         defaultService.refresh(t, lockOptions, propertyPaths);
 167     }
 168
 169     /**
 170      * @param taxon
 171      * @param classificationUuid
 172      * @param propertyPaths
 173      * @return
 174      * @deprecated
 175      * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTaxonNodeByTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.UUID, java.util.List)
 176      */
 177     @Deprecated
 178     @Override
 179     public TaxonNode loadTaxonNodeByTaxon(Taxon taxon, UUID classificationUuid, List<String> propertyPaths) {
 180         return defaultService.loadTaxonNodeByTaxon(taxon, classificationUuid, propertyPaths);
 181     }
 182
 183     /**
 184      *
 185      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache()
 186      */
 187     @Override
 188     public void updateTitleCache() {
 189         defaultService.updateTitleCache();
 190     }
 191
 192     /**
 193      * @param t
 194      * @return
 195      * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity)
 196      */
 197     @Override
 198     public AuditEventRecord<Classification> getNextAuditEvent(Classification t) {
 199         return defaultService.getNextAuditEvent(t);
 200     }
 201
 202     /**
 203      * @param annotatableEntity
 204      * @param technical
 205      * @param pageSize
 206      * @param pageNumber
 207      * @param orderHints
 208      * @param propertyPaths
 209      * @return
 210      * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 211      */
 212     @Override
 213     public Pager<Marker> getMarkers(Classification annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 214         return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
 215     }
 216
 217     /**
 218      * @param clazz
 219      * @param stepSize
 220      * @param cacheStrategy
 221      * @param monitor
 222      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor)
 223      */
 224     @Override
 225     public void updateTitleCache(Class<? extends Classification> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<Classification> cacheStrategy, IProgressMonitor monitor) {
 226         defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
 227     }
 228
 229     /**
 230      * @param taxonNode
 231      * @param propertyPaths
 232      * @return
 233      * @deprecated
 234      * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List)
 235      */
 236     @Deprecated
 237     @Override
 238     public TaxonNode loadTaxonNode(TaxonNode taxonNode, List<String> propertyPaths) {
 239         return defaultService.loadTaxonNode(taxonNode, propertyPaths);
 240     }
 241
 242     /**
 243      * @param t
 244      * @return
 245      * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity)
 246      */
 247     @Override
 248     public AuditEventRecord<Classification> getPreviousAuditEvent(Classification t) {
 249         return defaultService.getPreviousAuditEvent(t);
 250     }
 251
 252     /**
 253      * @param clazz
 254      * @return
 255      * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class)
 256      */
 257     @Override
 258     public int count(Class<? extends Classification> clazz) {
 259         return defaultService.count(clazz);
 260     }
 261
 262     /**
 263      * @param clazz
 264      * @param from
 265      * @param to
 266      * @param criteria
 267      * @param pageSize
 268      * @param pageValue
 269      * @param sort
 270      * @param propertyPaths
 271      * @return
 272      * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List)
 273      */
 274     @Override
 275     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) {
 276         return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
 277     }
 278
 279     /**
 280      * @param lsid
 281      * @return
 282      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID)
 283      */
 284     @Override
 285     public Classification find(LSID lsid) {
 286         return defaultService.find(lsid);
 287     }
 288
 289     /**
 290      * @param persistentObject
 291      * @return
 292      * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase)
 293      */
 294     @Override
 295     public DeleteResult delete(Classification persistentObject) {
 296         return defaultService.delete(persistentObject);
 297     }
 298
 299     /**
 300      * @param clazz
 301      * @param technical
 302      * @param pageSize
 303      * @param pageNumber
 304      * @param propertyPaths
 305      * @return
 306      * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List)
 307      */
 308     @Override
 309     public List<Object[]> groupMarkers(Class<? extends Classification> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 310         return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
 311     }
 312
 313     /**
 314      * @param uuid
 315      * @return
 316      * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID)
 317      */
 318     @Override
 319     public boolean exists(UUID uuid) {
 320         return defaultService.exists(uuid);
 321     }
 322
 323     /**
 324      * @param x
 325      * @param y
 326      * @return
 327      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity)
 328      */
 329     @Override
 330     public Classification replace(Classification x, Classification y) {
 331         return defaultService.replace(x, y);
 332     }
 333
 334     /**
 335      * @param uuidSet
 336      * @return
 337      * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set)
 338      */
 339     @Override
 340     public List<Classification> find(Set<UUID> uuidSet) {
 341         return defaultService.find(uuidSet);
 342     }
 343
 344     /**
 345      * @param t
 346      * @param pageSize
 347      * @param pageNumber
 348      * @param propertyPaths
 349      * @return
 350      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List)
 351      */
 352     @Override
 353     public Pager<IdentifiableSource> getSources(Classification t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 354         return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
 355     }
 356
 357     /**
 358      * @param classification
 359      * @param rank
 360      * @param pageSize
 361      * @param pageIndex
 362      * @param propertyPaths
 363      * @return
 364      * @see eu.etaxonomy.cdm.api.service.IClassificationService#listRankSpecificRootNodes(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer, java.util.List)
 365      */
 366     @Override
 367     public List<TaxonNode> listRankSpecificRootNodes(Classification classification, Rank rank, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {
 368         return defaultService.listRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths);
 369     }
 370
 371     /**
 372      * @param uuid
 373      * @return
 374      * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID)
 375      */
 376     @Override
 377     public Classification find(UUID uuid) {
 378         return defaultService.find(uuid);
 379     }
 380
 381     /**
 382      * @param id
 383      * @return
 384      * @see eu.etaxonomy.cdm.api.service.IService#find(int)
 385      */
 386     @Override
 387     public Classification find(int id) {
 388         return defaultService.find(id);
 389     }
 390
 391     /**
 392      * @param t
 393      * @param pageSize
 394      * @param pageNumber
 395      * @param propertyPaths
 396      * @return
 397      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List)
 398      */
 399     @Override
 400     public Pager<Rights> getRights(Classification t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 401         return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
 402     }
 403
 404     /**
 405      * @param clazz
 406      * @param technical
 407      * @return
 408      * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean)
 409      */
 410     @Override
 411     public int countMarkers(Class<? extends Classification> clazz, Boolean technical) {
 412         return defaultService.countMarkers(clazz, technical);
 413     }
 414
 415     /**
 416      * @param idSet
 417      * @return
 418      * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set)
 419      */
 420     @Override
 421     public List<Classification> findById(Set<Integer> idSet) {
 422         return defaultService.findById(idSet);
 423     }
 424
 425     /**
 426      * @param clazz
 427      * @param idInSource
 428      * @param idNamespace
 429      * @return
 430      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String)
 431      */
 432     @Override
 433     public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
 434         return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
 435     }
 436
 437     /**
 438      * @param classification
 439      * @param rank
 440      * @param pageSize
 441      * @param pageIndex
 442      * @param propertyPaths
 443      * @return
 444      * @see eu.etaxonomy.cdm.api.service.IClassificationService#pageRankSpecificRootNodes(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer, java.util.List)
 445      */
 446     @Override
 447     public Pager<TaxonNode> pageRankSpecificRootNodes(Classification classification, Rank rank, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {
 448         return defaultService.pageRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths);
 449     }
 450
 451     /**
 452      * @return
 453      * @see eu.etaxonomy.cdm.api.service.IService#getSession()
 454      */
 455     @Override
 456     public Session getSession() {
 457         return defaultService.getSession();
 458     }
 459
 460     /**
 461      * @param clazz
 462      * @param limit
 463      * @param start
 464      * @param groups
 465      * @param propertyPaths
 466      * @return
 467      * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 468      */
 469     @Override
 470     public List<Object[]> group(Class<? extends Classification> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
 471         return defaultService.group(clazz, limit, start, groups, propertyPaths);
 472     }
 473
 474     /**
 475      * @param clazz
 476      * @param queryString
 477      * @param matchmode
 478      * @param criteria
 479      * @param pageSize
 480      * @param pageNumber
 481      * @param orderHints
 482      * @param propertyPaths
 483      * @return
 484      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 485      */
 486     @Override
 487     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) {
 488         return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 489     }
 490
 491     /**
 492      * @param taxonNode
 493      * @param baseRank
 494      * @param propertyPaths
 495      * @return
 496      * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTreeBranch(eu.etaxonomy.cdm.model.taxon.TaxonNode, eu.etaxonomy.cdm.model.name.Rank, java.util.List)
 497      */
 498     @Override
 499     public List<TaxonNode> loadTreeBranch(TaxonNode taxonNode, Rank baseRank, List<String> propertyPaths) {
 500         return defaultService.loadTreeBranch(taxonNode, baseRank, propertyPaths);
 501     }
 502
 503     /**
 504      * @param type
 505      * @param limit
 506      * @param start
 507      * @param orderHints
 508      * @param propertyPaths
 509      * @return
 510      * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 511      */
 512     @Override
 513     public <S extends Classification> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 514         return defaultService.list(type, limit, start, orderHints, propertyPaths);
 515     }
 516
 517     /**
 518      * @param taxon
 519      * @param classification
 520      * @param baseRank
 521      * @param propertyPaths
 522      * @return
 523      * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTreeBranchToTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.util.List)
 524      */
 525     @Override
 526     public List<TaxonNode> loadTreeBranchToTaxon(Taxon taxon, Classification classification, Rank baseRank, List<String> propertyPaths) {
 527         return defaultService.loadTreeBranchToTaxon(taxon, classification, baseRank, propertyPaths);
 528     }
 529
 530     /**
 531      * @param configurator
 532      * @return
 533      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator)
 534      */
 535     @Override
 536     public Pager<Classification> findByTitle(IIdentifiableEntityServiceConfigurator<Classification> configurator) {
 537         return defaultService.findByTitle(configurator);
 538     }
 539
 540     /**
 541      * @param clazz
 542      * @param queryString
 543      * @param matchmode
 544      * @param criteria
 545      * @return
 546      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List)
 547      */
 548     @Override
 549     public Integer countByTitle(Class<? extends Classification> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
 550         return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
 551     }
 552
 553     /**
 554      * @param uuid
 555      * @return
 556      * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID)
 557      */
 558     @Override
 559     public Classification load(UUID uuid) {
 560         return defaultService.load(uuid);
 561     }
 562
 563     /**
 564      * @param uuid
 565      * @param propertyPaths
 566      * @return
 567      * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List)
 568      */
 569     @Override
 570     public Classification load(UUID uuid, List<String> propertyPaths) {
 571         return defaultService.load(uuid, propertyPaths);
 572     }
 573
 574     /**
 575      * @param configurator
 576      * @return
 577      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator)
 578      */
 579     @Override
 580     public Integer countByTitle(IIdentifiableEntityServiceConfigurator<Classification> configurator) {
 581         return defaultService.countByTitle(configurator);
 582     }
 583
 584     /**
 585      * @param transientObject
 586      * @return
 587      * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase)
 588      */
 589     @Override
 590     public Classification merge(Classification transientObject) {
 591         return defaultService.merge(transientObject);
 592     }
 593
 594     /**
 595      * @param clazz
 596      * @param queryString
 597      * @param matchmode
 598      * @param criteria
 599      * @param pageSize
 600      * @param pageNumber
 601      * @param orderHints
 602      * @param propertyPaths
 603      * @return
 604      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 605      */
 606     @Override
 607     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) {
 608         return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 609     }
 610
 611     /**
 612      * @param type
 613      * @param pageSize
 614      * @param pageNumber
 615      * @param orderHints
 616      * @param propertyPaths
 617      * @return
 618      * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 619      */
 620     @Override
 621     public <S extends Classification> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 622         return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
 623     }
 624
 625     /**
 626      * @param taxonNode
 627      * @param propertyPaths
 628      * @return
 629      * @deprecated
 630      * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadChildNodesOfTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List)
 631      */
 632     @Deprecated
 633     @Override
 634     public List<TaxonNode> loadChildNodesOfTaxonNode(TaxonNode taxonNode, List<String> propertyPaths) {
 635         return defaultService.loadChildNodesOfTaxonNode(taxonNode, propertyPaths);
 636     }
 637
 638     /**
 639      * @param classification
 640      * @return
 641      * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(eu.etaxonomy.cdm.model.taxon.Classification)
 642      */
 643     @Override
 644     public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification, List<UUID> excludeTaxa) {
 645         return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, excludeTaxa);
 646     }
 647
 648     /**
 649      * @param taxon
 650      * @param taxTree
 651      * @param propertyPaths
 652      * @param size
 653      * @param height
 654      * @param widthOrDuration
 655      * @param mimeTypes
 656      * @return
 657      * @deprecated
 658      * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllMediaForChildNodes(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, int, int, int, java.lang.String[])
 659      */
 660     @Deprecated
 661     @Override
 662     public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(Taxon taxon, Classification taxTree, List<String> propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes) {
 663         return defaultService.getAllMediaForChildNodes(taxon, taxTree, propertyPaths, size, height, widthOrDuration, mimeTypes);
 664     }
 665
 666     /**
 667      * @param persistentObject
 668      * @return
 669      * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase)
 670      */
 671     @Override
 672     public UUID refresh(Classification persistentObject) {
 673         return defaultService.refresh(persistentObject);
 674     }
 675
 676     /**
 677      * @param clazz
 678      * @param queryString
 679      * @param matchmode
 680      * @param criteria
 681      * @param pageSize
 682      * @param pageNumber
 683      * @param orderHints
 684      * @param propertyPaths
 685      * @return
 686      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 687      */
 688     @Override
 689     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) {
 690         return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 691     }
 692
 693     /**
 694      * @param taxonNode
 695      * @param propertyPaths
 696      * @param size
 697      * @param height
 698      * @param widthOrDuration
 699      * @param mimeTypes
 700      * @return
 701      * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllMediaForChildNodes(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List, int, int, int, java.lang.String[])
 702      */
 703     @Override
 704     public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(TaxonNode taxonNode, List<String> propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes) {
 705         return defaultService.getAllMediaForChildNodes(taxonNode, propertyPaths, size, height, widthOrDuration, mimeTypes);
 706     }
 707
 708     /**
 709      * @param tableName
 710      * @param limit
 711      * @param start
 712      * @return
 713      * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int)
 714      */
 715     @Override
 716     public List<Classification> rows(String tableName, int limit, int start) {
 717         return defaultService.rows(tableName, limit, start);
 718     }
 719
 720     /**
 721      * @param newInstances
 722      * @return
 723      * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection)
 724      */
 725     @Override
 726     public Map<UUID, Classification> save(Collection<Classification> newInstances) {
 727         return null;
 728     }
 729
 730     /**
 731      * @param taxonNode
 732      * @return
 733      * @deprecated
 734      * @see eu.etaxonomy.cdm.api.service.IClassificationService#removeTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode)
 735      */
 736     @Deprecated
 737     @Override
 738     public UUID removeTaxonNode(TaxonNode taxonNode) {
 739         return defaultService.removeTaxonNode(taxonNode);
 740     }
 741
 742     /**
 743      * @param taxonNode
 744      * @return
 745      * @deprecated
 746      * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode)
 747      */
 748     @Deprecated
 749     @Override
 750     public UUID saveTaxonNode(TaxonNode taxonNode) {
 751         return null;
 752     }
 753
 754     /**
 755      * @param newInstance
 756      * @return
 757      * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase)
 758      */
 759     @Override
 760     public Classification save(Classification newInstance) {
 761         return null;
 762     }
 763
 764     /**
 765      * @param taxonNodeCollection
 766      * @return
 767      * @deprecated
 768      * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTaxonNodeAll(java.util.Collection)
 769      */
 770     @Deprecated
 771     @Override
 772     public Map<UUID, TaxonNode> saveTaxonNodeAll(Collection<TaxonNode> taxonNodeCollection) {
 773         return null;
 774     }
 775
 776     /**
 777      * @param transientObject
 778      * @return
 779      * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase)
 780      */
 781     @Override
 782     public UUID saveOrUpdate(Classification transientObject) {
 783         return null;
 784     }
 785
 786     /**
 787      * @param treeNode
 788      * @return
 789      * @see eu.etaxonomy.cdm.api.service.IClassificationService#removeTreeNode(eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode)
 790      */
 791     @Override
 792     public UUID removeTreeNode(ITaxonTreeNode treeNode) {
 793         return defaultService.removeTreeNode(treeNode);
 794     }
 795
 796     /**
 797      * @param clazz
 798      * @param queryString
 799      * @param pageSize
 800      * @param pageNumber
 801      * @param orderHints
 802      * @param propertyPaths
 803      * @return
 804      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 805      */
 806     @Override
 807     public Pager<Classification> search(Class<? extends Classification> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 808         return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
 809     }
 810
 811     /**
 812      * @param treeNode
 813      * @return
 814      * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTreeNode(eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode)
 815      */
 816     @Override
 817     public UUID saveTreeNode(ITaxonTreeNode treeNode) {
 818         return null;
 819     }
 820
 821     /**
 822      * @param transientObjects
 823      * @return
 824      * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection)
 825      */
 826     @Override
 827     public Map<UUID, Classification> saveOrUpdate(Collection<Classification> transientObjects) {
 828         return null;
 829     }
 830
 831     /**
 832      * @return
 833      * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllNodes()
 834      */
 835     @Override
 836     public List<TaxonNode> getAllNodes() {
 837         return defaultService.getAllNodes();
 838     }
 839
 840     /**
 841      * @param transientObject
 842      * @return
 843      * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase)
 844      */
 845     @Override
 846     public UUID update(Classification transientObject) {
 847         return defaultService.update(transientObject);
 848     }
 849
 850     /**
 851      * @param example
 852      * @param includeProperties
 853      * @param limit
 854      * @param start
 855      * @param orderHints
 856      * @param propertyPaths
 857      * @return
 858      * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 859      */
 860     @Override
 861     public List<Classification> list(Classification example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 862         return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
 863     }
 864
 865     /**
 866      * @param clazz
 867      * @param matchStrategy
 868      * @param mergeStrategy
 869      * @return
 870      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy)
 871      */
 872     @Override
 873     public int deduplicate(Class<? extends Classification> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 874         return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
 875     }
 876
 877     /**
 878      * @param clazz
 879      * @param queryString
 880      * @param pageSize
 881      * @param pageNumber
 882      * @param orderHints
 883      * @param matchMode
 884      * @return
 885      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode)
 886      */
 887     @Override
 888     public Pager<Classification> findTitleCache(Class<? extends Classification> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
 889         return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
 890     }
 891
 892     /* (non-Javadoc)
 893      * @see eu.etaxonomy.cdm.api.service.IClassificationService#listChildNodesOfTaxon(java.util.UUID, java.util.UUID, java.lang.Integer, java.lang.Integer, java.util.List)
 894      */
 895     @Override
 896     public List<TaxonNode> listChildNodesOfTaxon(UUID taxonUuid, UUID classificationUuid, Integer pageSize,
 897             Integer pageIndex, List<String> propertyPaths) {
 898         return defaultService.listChildNodesOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, propertyPaths);
 899     }
 900
 901         @Override
 902         public DeleteResult isDeletable(Classification object,
 903                         DeleteConfiguratorBase config) {
 904
 905                 return defaultService.isDeletable(object, config);
 906         }
 907
 908         @Override
 909         public Classification findWithoutFlush(UUID uuid) {
 910                 return defaultService.findWithoutFlush(uuid);
 911         }
 912
 913
 914         @Override
 915         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){
 916                 return defaultService.findByIdentifier(clazz, identifier, identifierType, matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
 917         }
 918
 919     @Override
 920     public UpdateResult createHierarchyInClassification(Classification arg1, CreateHierarchyForClassificationConfigurator arg2) {
 921        return defaultService.createHierarchyInClassification(arg1, arg2);
 922     }
 923
 924     /* (non-Javadoc)
 925      * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.UUID)
 926      */
 927     @Override
 928     public DeleteResult delete(UUID arg0) {
 929         return defaultService.delete(arg0);
 930     }
 931
 932     /* (non-Javadoc)
 933      * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.Collection)
 934      */
 935     @Override
 936     public DeleteResult delete(Collection<UUID> arg0) {
 937         return defaultService.delete(arg0);
 938     }
 939
 940     /* (non-Javadoc)
 941      * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List)
 942      */
 943     @Override
 944     public List<Classification> merge(List<Classification> arg0) {
 945         return defaultService.merge(arg0);
 946     }
 947
 948     /* (non-Javadoc)
 949      * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
 950      */
 951     @Override
 952     public List<MergeResult<Classification>> merge(List<Classification> arg0, boolean arg1) {
 953         return defaultService.merge(arg0, arg1);
 954     }
 955
 956     /* (non-Javadoc)
 957      * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
 958      */
 959     @Override
 960     public MergeResult<Classification> merge(Classification arg0, boolean arg1) {
 961         return defaultService.merge(arg0, arg1);
 962     }
 963
 964     /* (non-Javadoc)
 965      * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
 966      */
 967     @Override
 968     public Classification loadWithUpdate(UUID arg0) {
 969         return defaultService.loadWithUpdate(arg0);
 970     }
 971
 972
 973         @Override
 974         public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
 975                         UUID classificationUuid, List<UUID> excludeTaxa) {
 976
 977                 return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classificationUuid, excludeTaxa);
 978         }
 979
 980     /**
 981      * {@inheritDoc}
 982      */
 983     @Override
 984     public List<Classification> load(List<UUID> arg0, List<String> arg1) {
 985         return defaultService.load(arg0, arg1);
 986     }
 987
 988         @Override
 989         public List<UuidAndTitleCache<Classification>> getUuidAndTitleCache(Integer limit, String pattern) {
 990                 return defaultService.getUuidAndTitleCache(null, null);
 991         }
 992
 993         @Override
 994         public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
 995                         UUID classificationUuid, List<UUID> excludeTaxa, Integer limit,
 996                         String pattern) {
 997                 return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classificationUuid, excludeTaxa, limit, pattern);
 998         }
 999
1000         @Override
1001         public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
1002                         Classification classification, List<UUID> excludeTaxa,
1003                         Integer limit, String pattern) {
1004                 return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, excludeTaxa, limit, pattern);
1005         }
1006
1007         @Override
1008         public List<TaxonNode> listSiblingsOfTaxon(UUID taxonUuid,
1009                         UUID classificationUuid, Integer pageSize, Integer pageIndex,
1010                         List<String> propertyPaths) {
1011
1012                 return defaultService.listSiblingsOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, propertyPaths);
1013         }
1014
1015         @Override
1016         public Pager<TaxonNode> pageSiblingsOfTaxon(UUID taxonUuid,
1017                         UUID classificationUuid, Integer pageSize, Integer pageIndex,
1018                         List<String> propertyPaths) {
1019                 return defaultService.pageSiblingsOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, propertyPaths);
1020         }
1021
1022         @Override
1023         public List<Classification> loadByIds(List<Integer> idSet, List<String> propertyPaths) {
1024
1025                 return defaultService.loadByIds(idSet, propertyPaths);
1026         }
1027
1028         @Override
1029         public ClassificationLookupDTO classificationLookup(Classification arg0) {
1030
1031                 return defaultService.classificationLookup(arg0);
1032         }
1033
1034         @Override
1035         public DeleteResult delete(UUID arg0, TaxonDeletionConfigurator arg1) {
1036
1037                 return defaultService.delete(arg0, arg1);
1038         }
1039
1040         @Override
1041         public List<GroupedTaxonDTO> groupTaxaByHigherTaxon(List<UUID> taxonUuids,
1042                         UUID classificationUuid, Rank minRank, Rank maxRank) {
1043                 return defaultService.groupTaxaByHigherTaxon(taxonUuids, classificationUuid, minRank, maxRank);
1044         }
1045
1046         @Override
1047         public TaxonNode getRootNode(UUID arg0) {
1048                 return defaultService.getRootNode(arg0);
1049         }
1050
1051
1052 }