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

   1 /**
   2 * Copyright (C) 2009 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.api.service;
  11
  12 import java.util.ArrayList;
  13 import java.util.Arrays;
  14 import java.util.Collection;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Set;
  18 import java.util.UUID;
  19
  20 import javax.persistence.EntityNotFoundException;
  21
  22 import org.springframework.beans.factory.annotation.Autowired;
  23 import org.springframework.stereotype.Service;
  24 import org.springframework.transaction.annotation.Transactional;
  25
  26 import eu.etaxonomy.cdm.api.service.config.NodeDeletionConfigurator.ChildHandling;
  27 import eu.etaxonomy.cdm.api.service.config.TermNodeDeletionConfigurator;
  28 import eu.etaxonomy.cdm.api.service.pager.Pager;
  29 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  30 import eu.etaxonomy.cdm.model.common.CdmBase;
  31 import eu.etaxonomy.cdm.model.term.TermNode;
  32 import eu.etaxonomy.cdm.model.term.TermTree;
  33 import eu.etaxonomy.cdm.model.term.TermType;
  34 import eu.etaxonomy.cdm.persistence.dao.common.Restriction;
  35 import eu.etaxonomy.cdm.persistence.dao.term.ITermNodeDao;
  36 import eu.etaxonomy.cdm.persistence.dao.term.ITermTreeDao;
  37 import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
  38 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  39 import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
  40
  41 @Service
  42 @Transactional(readOnly = false)
  43 public class TermTreeServiceImpl
  44             extends IdentifiableServiceBase<TermTree, ITermTreeDao>
  45             implements ITermTreeService {
  46
  47     private ITermNodeDao termNodeDao;
  48
  49     @Autowired
  50     private ITermNodeService termNodeService;
  51
  52     @Override
  53     @Autowired
  54     protected void setDao(ITermTreeDao dao) {
  55         this.dao = dao;
  56     }
  57
  58     @Autowired
  59     protected void setTermNodeDao(ITermNodeDao termNodeDao) {
  60         this.termNodeDao = termNodeDao;
  61     }
  62
  63     @Override
  64     @Transactional(readOnly = false)
  65     public UpdateResult updateCaches(Class<? extends TermTree> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TermTree> cacheStrategy, IProgressMonitor monitor) {
  66         if (clazz == null){
  67             clazz = TermTree.class;
  68         }
  69         return super.updateCachesImpl(clazz, stepSize, cacheStrategy, monitor);
  70     }
  71
  72     @Override
  73     public Map<UUID, TermNode> saveNodesAll(Collection<TermNode> nodeCollection) {
  74         return termNodeDao.saveAll(nodeCollection);
  75     }
  76
  77     @Override
  78     public Map<UUID, TermNode> saveOrUpdateNodesAll(Collection<TermNode> nodeCollection) {
  79         return termNodeDao.saveOrUpdateAll(nodeCollection);
  80     }
  81
  82     @Override
  83     public TermTree loadWithNodes(UUID uuid, List<String> propertyPaths, List<String> nodePaths) {
  84
  85         if(nodePaths==null){
  86             nodePaths = new ArrayList<>();
  87         }
  88
  89         if(!nodePaths.contains("children")) {
  90             nodePaths.add("children");
  91         }
  92
  93         List<String> rootPaths = new ArrayList<>();
  94         rootPaths.add("root");
  95         for(String path : nodePaths) {
  96             rootPaths.add("root." + path);
  97         }
  98
  99         if(propertyPaths != null) {
 100             rootPaths.addAll(propertyPaths);
 101         }
 102
 103         TermTree featureTree = load(uuid, rootPaths);
 104         if(featureTree == null){
 105             throw new EntityNotFoundException("No FeatureTree entity found for " + uuid);
 106         }
 107         dao.deepLoadNodes(featureTree.getRoot().getChildNodes(), nodePaths);
 108         return featureTree;
 109     }
 110
 111     /**
 112      * Returns the featureTree specified by the given <code>uuid</code>.
 113      * The specified featureTree either can be one of those stored in the CDM database or can be the
 114      * DefaultFeatureTree (contains all Features in use).
 115      * The uuid of the DefaultFeatureTree is defined in {@link ITermTreeDao#DefaultFeatureTreeUuid}.
 116       *
 117      * @see eu.etaxonomy.cdm.api.service.ServiceBase#load(java.util.UUID, java.util.List)
 118      */
 119     @Override
 120     public TermTree load(UUID uuid, List<String> propertyPaths) {
 121         return super.load(uuid, propertyPaths);
 122     }
 123
 124     @Override
 125     public DeleteResult delete(UUID featureTreeUuid){
 126         DeleteResult result = new DeleteResult();
 127         TermTree tree = dao.load(featureTreeUuid);
 128
 129         TermNode rootNode = CdmBase.deproxy(tree.getRoot());
 130         TermNodeDeletionConfigurator config = new TermNodeDeletionConfigurator();
 131         config.setChildHandling(ChildHandling.DELETE);
 132         result = termNodeService.deleteNode(rootNode.getUuid(), config);
 133         //FIXME test if this is necessary
 134         tree.removeRootNode();
 135         if (result.isOk()){
 136           dao.delete(tree);
 137           result.addDeletedObject(tree);
 138         }
 139         return result;
 140     }
 141
 142     @Override
 143     public <S extends TermTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,
 144             String pattern) {
 145         return dao.getUuidAndTitleCacheByTermType(clazz, termType, limit, pattern);
 146     }
 147
 148     @Override
 149     public List<TermTree> list(TermType termType, Integer limit, Integer start, List<OrderHint> orderHints,
 150             List<String> propertyPaths) {
 151         return dao.list(null, buildTermTypeFilterRestrictions(termType), limit, start, orderHints, propertyPaths);
 152     }
 153
 154     @Override
 155     public Pager<TermTree> page(TermType termType, Integer pageSize, Integer pageIndex, List<OrderHint> orderHints, List<String> propertyPaths) {
 156
 157         return page(null, buildTermTypeFilterRestrictions(termType), pageSize, pageIndex, orderHints, propertyPaths);
 158     }
 159
 160     /**
 161      * @param termType
 162      * @return
 163      */
 164     @Override
 165     public List<Restriction<?>> buildTermTypeFilterRestrictions(TermType termType) {
 166         List<Restriction<?>> filterRestrictions = null;
 167         if(termType != null){
 168            Set<TermType> termTypes = termType.getGeneralizationOf(true);
 169            termTypes.add(termType);
 170            filterRestrictions = Arrays.asList(new Restriction<>("termType", null, termTypes.toArray()));
 171         }
 172         return filterRestrictions;
 173     }
 174
 175
 176
 177 }