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.MergeResult;
  38 import eu.etaxonomy.cdm.persistence.dto.TermTreeDto;
  39 import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
  40 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  41 import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
  42
  43 @Service
  44 @Transactional(readOnly = false)
  45 public class TermTreeServiceImpl
  46             extends IdentifiableServiceBase<TermTree, ITermTreeDao>
  47             implements ITermTreeService {
  48
  49     private ITermNodeDao termNodeDao;
  50
  51     @Autowired
  52     private ITermNodeService termNodeService;
  53
  54     @Override
  55     @Autowired
  56     protected void setDao(ITermTreeDao dao) {
  57         this.dao = dao;
  58     }
  59
  60     @Autowired
  61     protected void setTermNodeDao(ITermNodeDao termNodeDao) {
  62         this.termNodeDao = termNodeDao;
  63     }
  64
  65     @Override
  66     @Transactional(readOnly = false)
  67     public UpdateResult updateCaches(Class<? extends TermTree> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TermTree> cacheStrategy, IProgressMonitor monitor) {
  68         if (clazz == null){
  69             clazz = TermTree.class;
  70         }
  71         return super.updateCachesImpl(clazz, stepSize, cacheStrategy, monitor);
  72     }
  73
  74     @Override
  75     public Map<UUID, TermNode> saveNodesAll(Collection<TermNode> nodeCollection) {
  76         return termNodeDao.saveAll(nodeCollection);
  77     }
  78
  79     @Override
  80     public Map<UUID, TermNode> saveOrUpdateNodesAll(Collection<TermNode> nodeCollection) {
  81         return termNodeDao.saveOrUpdateAll(nodeCollection);
  82     }
  83
  84
  85     @Override
  86     @Transactional(readOnly = false)
  87     public UpdateResult saveOrUpdateTermTreeDtoList(List<TermTreeDto> dtos){
  88         UpdateResult result = new UpdateResult();
  89         MergeResult<TermTree> mergeResult;
  90         List<UUID> uuids = new ArrayList<>();
  91         dtos.stream().forEach(dto -> uuids.add(dto.getUuid()));
  92         List<TermTree> trees = dao.list(uuids, null, 0, null, null);
  93         //check all attributes for changes and adapt
  94         for (TermTree tree: trees){
  95             for (TermTreeDto dto: dtos){
  96
  97                 if (dto.getUuid().equals(tree.getUuid())){
  98                     tree.setTitleCache(dto.getTitleCache(), true);
  99                     tree.setAllowDuplicates(dto.isAllowDuplicate());
 100                     tree.setFlat(dto.isFlat());
 101                     tree.setOrderRelevant(dto.isOrderRelevant());
 102                 }
 103
 104                 mergeResult = dao.merge(tree, true);
 105                 result.addUpdatedObject(mergeResult.getMergedEntity());
 106             }
 107         }
 108         return result;
 109     }
 110
 111     @Override
 112     public TermTree loadWithNodes(UUID uuid, List<String> propertyPaths, List<String> nodePaths) {
 113
 114         if(nodePaths==null){
 115             nodePaths = new ArrayList<>();
 116         }
 117
 118         if(!nodePaths.contains("children")) {
 119             nodePaths.add("children");
 120         }
 121
 122         List<String> rootPaths = new ArrayList<>();
 123         rootPaths.add("root");
 124         for(String path : nodePaths) {
 125             rootPaths.add("root." + path);
 126         }
 127
 128         if(propertyPaths != null) {
 129             rootPaths.addAll(propertyPaths);
 130         }
 131
 132         TermTree featureTree = load(uuid, rootPaths);
 133         if(featureTree == null){
 134             throw new EntityNotFoundException("No FeatureTree entity found for " + uuid);
 135         }
 136         dao.deepLoadNodes(featureTree.getRoot().getChildNodes(), nodePaths);
 137         return featureTree;
 138     }
 139
 140     /**
 141      * Returns the featureTree specified by the given <code>uuid</code>.
 142      * The specified featureTree either can be one of those stored in the CDM database or can be the
 143      * DefaultFeatureTree (contains all Features in use).
 144      * The uuid of the DefaultFeatureTree is defined in {@link ITermTreeDao#DefaultFeatureTreeUuid}.
 145       *
 146      * @see eu.etaxonomy.cdm.api.service.ServiceBase#load(java.util.UUID, java.util.List)
 147      */
 148     @Override
 149     public TermTree load(UUID uuid, List<String> propertyPaths) {
 150         return super.load(uuid, propertyPaths);
 151     }
 152
 153     @Override
 154     public DeleteResult delete(UUID treeUuid){
 155         DeleteResult result = new DeleteResult();
 156         TermTree<?> tree = dao.load(treeUuid);
 157
 158         TermNode<?> rootNode = CdmBase.deproxy(tree.getRoot());
 159         TermNodeDeletionConfigurator config = new TermNodeDeletionConfigurator();
 160         config.setChildHandling(ChildHandling.DELETE);
 161         result = termNodeService.deleteNode(rootNode.getUuid(), config);
 162         //FIXME test if this is necessary
 163         tree.removeRootNode();
 164         if (result.isOk()){
 165           dao.delete(tree);
 166           result.addDeletedObject(tree);
 167         }
 168         return result;
 169     }
 170
 171     @Override
 172     public <S extends TermTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,
 173             String pattern) {
 174         return dao.getUuidAndTitleCacheByTermType(clazz, termType, limit, pattern);
 175     }
 176
 177     @Override
 178     public List<TermTree> list(TermType termType, Integer limit, Integer start, List<OrderHint> orderHints,
 179             List<String> propertyPaths) {
 180         return dao.list(null, buildTermTypeFilterRestrictions(termType), limit, start, orderHints, propertyPaths);
 181     }
 182
 183     @Override
 184     public Pager<TermTree> page(TermType termType, Integer pageSize, Integer pageIndex, List<OrderHint> orderHints, List<String> propertyPaths) {
 185
 186         return page(null, buildTermTypeFilterRestrictions(termType), pageSize, pageIndex, orderHints, propertyPaths);
 187     }
 188
 189     @Override
 190     public List<Restriction<?>> buildTermTypeFilterRestrictions(TermType termType) {
 191         List<Restriction<?>> filterRestrictions = null;
 192         if(termType != null){
 193            Set<TermType> termTypes = termType.getGeneralizationOf(true);
 194            termTypes.add(termType);
 195            filterRestrictions = Arrays.asList(new Restriction<>("termType", null, termTypes.toArray()));
 196         }
 197         return filterRestrictions;
 198     }
 199
 200     @Override
 201     public List<TermTreeDto> listTermTreeDtosByTermType(TermType termType) {
 202         return dao.listTermTreeDtosByTermType(termType);
 203     }
 204
 205     @Override
 206     public TermTreeDto getTermTreeDtoByUuid(UUID uuid) {
 207         return dao.getTermTreeDtosByUuid(uuid);
 208     }
 209
 210 }