cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonTreeServiceImpl.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.ArrayList;
  14 import java.util.Collection;
  15 import java.util.Collections;
  16 import java.util.Comparator;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.TreeMap;
  20 import java.util.UUID;
  21
  22 import org.apache.log4j.Logger;
  23 import org.springframework.beans.factory.annotation.Autowired;
  24 import org.springframework.stereotype.Service;
  25 import org.springframework.transaction.annotation.Propagation;
  26 import org.springframework.transaction.annotation.Transactional;
  27
  28 import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
  29 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  30 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  31 import eu.etaxonomy.cdm.model.media.Media;
  32 import eu.etaxonomy.cdm.model.media.MediaRepresentation;
  33 import eu.etaxonomy.cdm.model.name.Rank;
  34 import eu.etaxonomy.cdm.model.taxon.ITreeNode;
  35 import eu.etaxonomy.cdm.model.taxon.Taxon;
  36 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  37 import eu.etaxonomy.cdm.model.taxon.TaxonomicTree;
  38 import eu.etaxonomy.cdm.persistence.dao.BeanInitializer;
  39 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;
  40 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;
  41 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonomicTreeDao;
  42 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  43
  44 /**
  45  * @author n.hoffmann
  46  * @created Sep 21, 2009
  47  * @version 1.0
  48  */
  49 @Service
  50 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
  51 public class TaxonTreeServiceImpl extends IdentifiableServiceBase<TaxonomicTree, ITaxonomicTreeDao>
  52                 implements ITaxonTreeService {
  53         private static final Logger logger = Logger
  54                         .getLogger(TaxonTreeServiceImpl.class);
  55
  56         @Autowired
  57         private ITaxonNodeDao taxonNodeDao;
  58         @Autowired
  59         private ITaxonDao taxonDao;
  60         @Autowired
  61         private BeanInitializer defaultBeanInitializer;
  62         private Comparator<? super TaxonNode> taxonNodeComparator;
  63         @Autowired
  64         public void setTaxonNodeComparator(ITaxonNodeComparator<? super TaxonNode> taxonNodeComparator){
  65                 this.taxonNodeComparator = (Comparator<? super TaxonNode>) taxonNodeComparator;
  66         }
  67
  68
  69         /*
  70          * (non-Javadoc)
  71          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#loadTaxonNodeByTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.UUID, java.util.List)
  72          */
  73         public TaxonNode loadTaxonNodeByTaxon(Taxon taxon, UUID taxonomicTreeUuid, List<String> propertyPaths){
  74                 TaxonomicTree tree = dao.load(taxonomicTreeUuid);
  75                 TaxonNode node = tree.getNode(taxon);
  76
  77                 return loadTaxonNode(node, propertyPaths);
  78         }
  79
  80         public TaxonNode loadTaxonNode(TaxonNode taxonNode, List<String> propertyPaths){
  81                 defaultBeanInitializer.initialize(taxonNode, propertyPaths);
  82                 return taxonNode;
  83         }
  84
  85         /*
  86          * (non-Javadoc)
  87          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#loadRankSpecificRootNodes(eu.etaxonomy.cdm.model.taxon.TaxonomicTree, eu.etaxonomy.cdm.model.name.Rank, java.util.List)
  88          */
  89         public List<TaxonNode> loadRankSpecificRootNodes(TaxonomicTree taxonomicTree, Rank rank, List<String> propertyPaths){
  90                 TaxonomicTree tree = dao.load(taxonomicTree.getUuid());
  91
  92                 List<TaxonNode> rootNodes = tree.getRankSpecificRootNodes(rank);
  93                 //sort nodes by TaxonName
  94
  95                 Collections.sort(rootNodes, taxonNodeComparator);
  96
  97                 // initialize all nodes
  98                 defaultBeanInitializer.initializeAll(rootNodes, propertyPaths);
  99
 100                 return rootNodes;
 101         }
 102
 103         /**
 104      * (non-Javadoc)
 105          * @see eu.etaxonomy.cdm.api.service.ITaxonService#loadTreeBranchTo(eu.etaxonomy.cdm.model.taxon.TaxonNode, eu.etaxonomy.cdm.model.name.Rank, java.util.List)
 106          * FIXME Candidate for harmonization
 107          * move to taxonTreeService
 108          */
 109         public List<TaxonNode> loadTreeBranch(TaxonNode taxonNode, Rank baseRank, List<String> propertyPaths){
 110
 111                 TaxonNode thisNode = taxonNodeDao.load(taxonNode.getUuid(), propertyPaths);
 112                 List<TaxonNode> pathToRoot = new ArrayList<TaxonNode>();
 113                 pathToRoot.add(thisNode);
 114
 115                 ITreeNode parentNode = thisNode.getParent();
 116                 while(parentNode instanceof TaxonNode){
 117                         TaxonNode parent = (TaxonNode) parentNode;
 118                         Rank parentNodeRank = parent.getTaxon().getName().getRank();
 119                         // stop if the next parent is higher than the baseRank
 120                         if(baseRank != null && baseRank.isLower(parentNodeRank)){
 121                                 break;
 122                         }
 123                         pathToRoot.add(parent);
 124                         parentNode = parent.getParent();
 125                 }
 126
 127                 // initialize and invert order of nodes in list
 128                 defaultBeanInitializer.initializeAll(pathToRoot, propertyPaths);
 129                 Collections.reverse(pathToRoot);
 130
 131                 return pathToRoot;
 132         }
 133
 134         /*
 135          * (non-Javadoc)
 136          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#loadTreeBranchToTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonomicTree, eu.etaxonomy.cdm.model.name.Rank, java.util.List)
 137          */
 138         public List<TaxonNode> loadTreeBranchToTaxon(Taxon taxon, TaxonomicTree taxonomicTree, Rank baseRank, List<String> propertyPaths){
 139                 TaxonomicTree tree = dao.load(taxonomicTree.getUuid());
 140                 taxon = (Taxon) taxonDao.load(taxon.getUuid());
 141                 TaxonNode node = tree.getNode(taxon);
 142                 if(node == null){
 143                         logger.warn("The specified tacon is not found in the given tree.");
 144                         return null;
 145                 }
 146                 return loadTreeBranch(node, baseRank, propertyPaths);
 147         }
 148
 149
 150         /* (non-Javadoc)
 151          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#loadChildNodesOfTaxon(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List)
 152          */
 153         public List<TaxonNode> loadChildNodesOfTaxonNode(TaxonNode taxonNode,
 154                         List<String> propertyPaths) {
 155                 List<TaxonNode> childNodes = new ArrayList<TaxonNode>(taxonNode.getChildNodes());
 156                 Collections.sort(childNodes, taxonNodeComparator);
 157                 defaultBeanInitializer.initializeAll(childNodes, propertyPaths);
 158                 return childNodes;
 159         }
 160
 161         /*
 162          * (non-Javadoc)
 163          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#loadChildNodesOfTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonomicTree, java.util.List)
 164          */
 165         public List<TaxonNode> loadChildNodesOfTaxon(Taxon taxon, TaxonomicTree taxonomicTree, List<String> propertyPaths){
 166                 TaxonomicTree tree = dao.load(taxonomicTree.getUuid());
 167                 taxon = (Taxon) taxonDao.load(taxon.getUuid());
 168
 169                 return loadChildNodesOfTaxonNode(tree.getNode(taxon), propertyPaths);
 170         }
 171
 172
 173
 174         /*
 175          * (non-Javadoc)
 176          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#getTaxonNodeByUuid(java.util.UUID)
 177          */
 178         public TaxonNode getTaxonNodeByUuid(UUID uuid) {
 179                 return taxonNodeDao.findByUuid(uuid);
 180         }
 181
 182         /*
 183          * (non-Javadoc)
 184          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#getTreeNodeByUuid(java.util.UUID)
 185          */
 186         public ITreeNode getTreeNodeByUuid(UUID uuid){
 187                 ITreeNode treeNode = taxonNodeDao.findByUuid(uuid);
 188                 if(treeNode == null){
 189                         treeNode = dao.findByUuid(uuid);
 190                 }
 191
 192                 return treeNode;
 193         }
 194
 195         /*
 196          * (non-Javadoc)
 197          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#listTaxonomicTrees(java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 198          */
 199         public List<TaxonomicTree> listTaxonomicTrees(Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 200                 return dao.list(limit, start, orderHints, propertyPaths);
 201         }
 202
 203         /*
 204          * (non-Javadoc)
 205          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#getTaxonomicTreeByUuid(java.util.UUID)
 206          */
 207         public TaxonomicTree getTaxonomicTreeByUuid(UUID uuid){
 208                 return dao.findByUuid(uuid);
 209         }
 210
 211         /* (non-Javadoc)
 212          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#removeTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonomicTree)
 213          */
 214         public UUID removeTaxonNode(TaxonNode taxonNode) {
 215                 return taxonNodeDao.delete(taxonNode);
 216         }
 217         /* (non-Javadoc)
 218          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#removeTreeNode(eu.etaxonomy.cdm.model.taxon.ITreeNode)
 219          */
 220         public UUID removeTreeNode(ITreeNode treeNode) {
 221                 if(treeNode instanceof TaxonomicTree){
 222                         return dao.delete((TaxonomicTree) treeNode);
 223                 }else if(treeNode instanceof TaxonNode){
 224                         return taxonNodeDao.delete((TaxonNode)treeNode);
 225                 }
 226                 return null;
 227         }
 228         /* (non-Javadoc)
 229          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#saveTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonomicTree)
 230          */
 231         public UUID saveTaxonNode(TaxonNode taxonNode) {
 232                 return taxonNodeDao.save(taxonNode);
 233         }
 234
 235         /*
 236          * (non-Javadoc)
 237          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#saveTaxonNodeAll(java.util.Collection)
 238          */
 239         public Map<UUID, TaxonNode> saveTaxonNodeAll(
 240                         Collection<TaxonNode> taxonNodeCollection) {
 241                 return taxonNodeDao.saveAll(taxonNodeCollection);
 242         }
 243
 244         /* (non-Javadoc)
 245          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#saveTreeNode(eu.etaxonomy.cdm.model.taxon.ITreeNode)
 246          */
 247         public UUID saveTreeNode(ITreeNode treeNode) {
 248                 if(treeNode instanceof TaxonomicTree){
 249                         return dao.save((TaxonomicTree) treeNode);
 250                 }else if(treeNode instanceof TaxonNode){
 251                         return taxonNodeDao.save((TaxonNode)treeNode);
 252                 }
 253                 return null;
 254         }
 255
 256         public List<TaxonNode> getAllNodes(){
 257                 return taxonNodeDao.list(null,null);
 258         }
 259
 260         /*
 261          * (non-Javadoc)
 262          * @see eu.etaxonomy.cdm.api.service.ITaxonService#getUuidAndTitleCacheOfAcceptedTaxa(eu.etaxonomy.cdm.model.taxon.TaxonomicTree)
 263          */
 264         public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByTaxonomicTree(TaxonomicTree taxonomicTree) {
 265                 return taxonDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByTaxonomicTree(taxonomicTree);
 266         }
 267
 268         /* (non-Javadoc)
 269          * @see eu.etaxonomy.cdm.api.service.IdentifiableServiceBase#getUuidAndTitleCache()
 270          */
 271         @Override
 272         public List<UuidAndTitleCache<TaxonomicTree>> getUuidAndTitleCache() {
 273                 return dao.getUuidAndTitleCache();
 274         }
 275
 276         /* (non-Javadoc)
 277          * @see eu.etaxonomy.cdm.api.service.ITaxonTreeService#getAllMediaForChildNodes(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List, int, int, int, java.lang.String[])
 278          */
 279         public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(
 280                         TaxonNode taxonNode, List<String> propertyPaths, int size,
 281                         int height, int widthOrDuration, String[] mimeTypes) {
 282
 283                 TreeMap<UUID, List<MediaRepresentation>> result = new TreeMap<UUID, List<MediaRepresentation>>();
 284                 List<Media> taxonMedia = new ArrayList<Media>();
 285                 List<MediaRepresentation> mediaRepresentations = new ArrayList<MediaRepresentation>();
 286
 287                 //add all media of the children to the result map
 288                 if (taxonNode != null){
 289
 290                         List<TaxonNode> nodes = new ArrayList<TaxonNode>();
 291
 292                         nodes.add(loadTaxonNode(taxonNode, propertyPaths));
 293                         nodes.addAll(loadChildNodesOfTaxonNode(taxonNode, propertyPaths));
 294
 295                         if (nodes != null){
 296                                 for(TaxonNode node : nodes){
 297                                         Taxon taxon = node.getTaxon();
 298                                         for (TaxonDescription taxonDescription: taxon.getDescriptions()){
 299                                                 for (DescriptionElementBase descriptionElement: taxonDescription.getElements()){
 300                                                         for(Media media : descriptionElement.getMedia()){
 301                                                                 taxonMedia.add(media);
 302
 303                                                                 //find the best matching representation
 304                                                                 mediaRepresentations.add(media.findBestMatchingRepresentation(size, height, widthOrDuration, mimeTypes));
 305
 306                                                         }
 307                                                 }
 308                                         }
 309                                         result.put(taxon.getUuid(), mediaRepresentations);
 310
 311                                 }
 312                         }
 313
 314                 }
 315
 316
 317                 return result;
 318
 319         }
 320
 321         public Map<UUID, List<MediaRepresentation>> getAllMediaForChildNodes(Taxon taxon, TaxonomicTree taxTree, List<String> propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes){
 322                 TaxonNode node = taxTree.getNode(taxon);
 323
 324                 return getAllMediaForChildNodes(node, propertyPaths, size, height, widthOrDuration, mimeTypes);
 325         }
 326
 327
 328
 329
 330
 331         /* (non-Javadoc)
 332          * @see eu.etaxonomy.cdm.api.service.ServiceBase#setDao(eu.etaxonomy.cdm.persistence.dao.common.ICdmEntityDao)
 333          */
 334         @Autowired
 335         protected void setDao(ITaxonomicTreeDao dao) {
 336                 this.dao = dao;
 337         }
 338
 339         /* (non-Javadoc)
 340          * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#generateTitleCache()
 341          */
 342         public void generateTitleCache() {
 343                 logger.warn("generateTitleCache not yet fully implemented!");
 344         }
 345 }