cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/IClassificationService.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 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
  11 package eu.etaxonomy.cdm.api.service;
  12
  13 import java.util.Collection;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.UUID;
  17
  18 import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
  19 import eu.etaxonomy.cdm.model.media.MediaRepresentation;
  20 import eu.etaxonomy.cdm.model.name.Rank;
  21 import eu.etaxonomy.cdm.model.taxon.ITreeNode;
  22 import eu.etaxonomy.cdm.model.taxon.Taxon;
  23 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  24 import eu.etaxonomy.cdm.model.taxon.Classification;
  25 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  26
  27
  28 /**
  29  * @author n.hoffmann
  30  * @created Sep 21, 2009
  31  * @version 1.0
  32  */
  33 public interface IClassificationService extends IIdentifiableEntityService<Classification> {
  34
  35         /**
  36          *
  37          * @param uuid
  38          * @return
  39          */
  40         public TaxonNode getTaxonNodeByUuid(UUID uuid);
  41
  42         /**
  43          *
  44          * @param uuid
  45          * @return
  46          */
  47         public ITreeNode getTreeNodeByUuid(UUID uuid);
  48
  49         /**
  50          *
  51          * @param limit
  52          * @param start
  53          * @param orderHints
  54          * @param propertyPaths
  55          * @return
  56          */
  57         public List<Classification> listClassifications(Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths);
  58
  59         /**
  60          *
  61          * @param uuid
  62          * @return
  63          */
  64         public Classification getClassificationByUuid(UUID uuid);
  65
  66         /**
  67          *
  68          * @param taxon
  69          * @param classificationUuid
  70          * @param propertyPaths
  71          * @return
  72          * @deprecated use loadTaxonNode(TaxonNode taxonNode, ...) instead
  73          * if you have a classification and a taxon that is in it, you should also have the according taxonNode
  74          */
  75         public TaxonNode loadTaxonNodeByTaxon(Taxon taxon, UUID classificationUuid, List<String> propertyPaths);
  76
  77         /**
  78          *
  79          * @param taxonNode
  80          * @param propertyPaths
  81          * @return
  82          * @deprecated use TaxonNodeService instead
  83          */
  84         public TaxonNode loadTaxonNode(TaxonNode taxonNode, List<String> propertyPaths);
  85
  86         /**
  87          * Loads all TaxonNodes of the specified tree for a given Rank.
  88          * If a branch does not contain a TaxonNode with a TaxonName at the given
  89          * Rank the node associated with the next lower Rank is taken as root node.
  90          * If the <code>rank</code> is null the absolute root nodes will be returned.
  91          *
  92          * @param classification
  93          * @param rank may be null
  94          * @param propertyPaths
  95          * @return
  96          */
  97         public List<TaxonNode> loadRankSpecificRootNodes(Classification classification, Rank rank, List<String> propertyPaths);
  98
  99         /**
 100          * @param taxonNode
 101          * @param baseRank
 102          *            specifies the root level of the classification, may be null.
 103          *            Nodes of this rank or in case this rank does not exist in the
 104          *            current branch the next lower rank is taken as root node for
 105          *            this rank henceforth called the <b>base node</b>.
 106          * @param propertyPaths
 107          *            the initialization strategy for the returned TaxonNode
 108          *            instances.
 109          * @return the path of nodes from the <b>base node</b> to the node of the
 110          *         specified taxon.
 111          */
 112         public List<TaxonNode> loadTreeBranch(TaxonNode taxonNode, Rank baseRank, List<String> propertyPaths);
 113
 114         /**
 115          * Although this method seems to be a redundant alternative to {@link #loadChildNodesOfTaxonNode(TaxonNode, List)} it is an important
 116          * alternative from which web services benefit. Without this method the web service controller method, which operates outside of the
 117          * transaction, would have to initialize the full taxon tree with all nodes of the taxon.
 118          * This would be rather slow compared to using this method.
 119          * @param taxon
 120          * @param classification
 121          *            the classification to be used
 122          * @param baseRank
 123          *            specifies the root level of the classification, may be null.
 124          *            Nodes of this rank or in case this rank does not exist in the
 125          *            current branch the next lower rank is taken as as root node for
 126          *            this rank henceforth called the <b>base node</b>.
 127          * @param propertyPaths
 128          *            the initialization strategy for the returned TaxonNode
 129          *            instances.
 130          * @return the path of nodes from the <b>base node</b> to the node of the specified
 131          *         taxon.
 132          */
 133         public List<TaxonNode> loadTreeBranchToTaxon(Taxon taxon, Classification classification, Rank baseRank, List<String> propertyPaths);
 134
 135
 136
 137         /**
 138          * Although this method seems to be a redundant alternative to {@link #loadChildNodesOfTaxonNode(TaxonNode, List)} it is an important
 139          * alternative from which web services benefit. Without this method the web service controller method, which operates outside of the
 140          * transaction, would have to initialize the full taxon tree with all nodes of the taxon.
 141          * This would be rather slow compared to using this method.
 142          * @param taxon
 143          * @param classification
 144          * @param propertyPaths
 145          * @return
 146          */
 147         public List<TaxonNode> loadChildNodesOfTaxon(Taxon taxon, Classification classification, List<String> propertyPaths);
 148
 149         /**
 150          * @param taxonNode
 151          * @param propertyPaths
 152          * @deprecated move to TaxonNodeService
 153          * @return
 154          */
 155         public List<TaxonNode> loadChildNodesOfTaxonNode(TaxonNode taxonNode, List<String> propertyPaths);
 156
 157         /**
 158          *
 159          * @param classification
 160          * @return
 161          */
 162         public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification);
 163
 164         /**
 165          * @param taxon
 166          * @param taxTree
 167          * @param propertyPaths
 168          * @param size
 169          * @param height
 170          * @param widthOrDuration
 171          * @param mimeTypes
 172          * @return
 173          *  @deprecated use getAllMediaForChildNodes(TaxonNode taxonNode, ...) instead
 174          * if you have a classification and a taxon that is in it, you should also have the according taxonNode
 175          */
 176         public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(Taxon taxon, Classification taxTree, List<String> propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes);
 177
 178         /**
 179          *
 180          * @param taxonNode
 181          * @param propertyPaths
 182          * @param size
 183          * @param height
 184          * @param widthOrDuration
 185          * @param mimeTypes
 186          * @return
 187          */
 188         public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(TaxonNode taxonNode, List<String> propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes);
 189
 190         /**
 191          *
 192          * @param taxonNode
 193          * @return
 194          * @deprecated use TaxonNodeService instead
 195          */
 196         public UUID removeTaxonNode(TaxonNode taxonNode);
 197
 198         /**
 199          *
 200          * @param taxonNode
 201          * @return
 202          * @deprecated use TaxonNodeService instead
 203          */
 204         public UUID saveTaxonNode(TaxonNode taxonNode);
 205
 206         /**
 207          *
 208          * @param taxonNodeCollection
 209          * @return
 210          * @deprecated use TaxonNodeService instead
 211          */
 212         public Map<UUID, TaxonNode> saveTaxonNodeAll(Collection<TaxonNode> taxonNodeCollection);
 213
 214         /**
 215          *
 216          * @param treeNode
 217          * @return
 218          */
 219         public UUID removeTreeNode(ITreeNode treeNode);
 220
 221         /**
 222          *
 223          * @param treeNode
 224          * @return
 225          */
 226         public UUID saveTreeNode(ITreeNode treeNode);
 227
 228
 229         public List<TaxonNode> getAllNodes();
 230
 231
 232 }