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

   1 /**
   2 * Copyright (C) 2007 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.List;
  14 import java.util.Set;
  15 import java.util.UUID;
  16
  17 import org.apache.log4j.Logger;
  18 import org.springframework.beans.factory.annotation.Autowired;
  19 import org.springframework.stereotype.Service;
  20 import org.springframework.transaction.annotation.Transactional;
  21
  22 import eu.etaxonomy.cdm.api.service.config.FeatureNodeDeletionConfigurator;
  23 import eu.etaxonomy.cdm.api.service.config.NodeDeletionConfigurator.ChildHandling;
  24 import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;
  25 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  26 import eu.etaxonomy.cdm.model.common.CdmBase;
  27 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  28 import eu.etaxonomy.cdm.model.description.Feature;
  29 import eu.etaxonomy.cdm.model.description.FeatureNode;
  30 import eu.etaxonomy.cdm.model.description.FeatureTree;
  31 import eu.etaxonomy.cdm.persistence.dao.description.IFeatureNodeDao;
  32
  33 /**
  34  * @author n.hoffmann
  35  * @since Aug 5, 2010
  36  * @version 1.0
  37  */
  38 @Service
  39 @Transactional(readOnly = false)
  40 public class FeatureNodeServiceImpl extends VersionableServiceBase<FeatureNode, IFeatureNodeDao> implements IFeatureNodeService {
  41         private static final Logger logger = Logger.getLogger(FeatureNodeServiceImpl.class);
  42
  43         @Override
  44     @Autowired
  45         protected void setDao(IFeatureNodeDao dao) {
  46                 this.dao = dao;
  47         }
  48
  49         @Autowired
  50     private ITermService termService;
  51
  52          @Override
  53          @Transactional(readOnly = false)
  54          public DeleteResult deleteFeatureNode(UUID nodeUuid, FeatureNodeDeletionConfigurator config) {
  55              DeleteResult result = new DeleteResult();
  56              FeatureNode node = HibernateProxyHelper.deproxy(dao.load(nodeUuid), FeatureNode.class);
  57              result = isDeletable(node, config);
  58              Feature feature;
  59              if (result.isOk()){
  60                  FeatureNode parent = node.getParent();
  61              parent = HibernateProxyHelper.deproxy(parent, FeatureNode.class);
  62                  List<FeatureNode> children = new ArrayList(node.getChildNodes());
  63
  64                  if (config.getChildHandling().equals(ChildHandling.DELETE)){
  65
  66                      for (FeatureNode child: children){
  67                          deleteFeatureNode(child.getUuid(), config);
  68                         // node.removeChild(child);
  69                      }
  70                      if (parent != null){
  71                          parent.removeChild(node);
  72                      }
  73
  74                  } else{
  75
  76                      if (parent != null){
  77                          parent.removeChild(node);
  78                          for (FeatureNode child: children){
  79                              node.removeChild(child);
  80                              parent.addChild(child);
  81                          }
  82                      }else{
  83                          result.setAbort();
  84                          result.addException(new ReferencedObjectUndeletableException("The root node can not be deleted without its child nodes"));
  85                          return result;
  86                      }
  87                  }
  88
  89                  dao.delete(node);
  90                  result.addDeletedObject(node);
  91                  if(parent!=null){
  92                      result.addUpdatedObject(parent);
  93                  }
  94                  if (config.isDeleteElement()){
  95                  feature = node.getFeature();
  96                  termService.delete(feature.getUuid());
  97                  result.addDeletedObject(feature);
  98              }
  99              }
 100              return result;
 101          }
 102
 103          @Override
 104          public UpdateResult createChildFeatureNode(FeatureNode node, Feature featureChild){
 105              DefinedTermBase feature = termService.save(featureChild);
 106              FeatureNode childNode = FeatureNode.NewInstance(featureChild);
 107              save(childNode);
 108              UpdateResult result = new UpdateResult();
 109              node.addChild(childNode);
 110              result.addUpdatedObject(node);
 111              result.setCdmEntity(node.getFeatureTree());
 112              return result;
 113          }
 114
 115          @Override
 116          public UpdateResult addChildFeatureNode(FeatureNode node, Feature featureChild){
 117              UpdateResult result = new UpdateResult();
 118              FeatureNode childNode = FeatureNode.NewInstance(featureChild);
 119              node.addChild(childNode);
 120              result.addUpdatedObject(node);
 121              result.setCdmEntity(node.getFeatureTree());
 122              return result;
 123          }
 124
 125          @Override
 126          public UpdateResult addChildFeatureNode(UUID nodeUUID, UUID featureChildUuid){
 127              FeatureNode node = load(nodeUUID);
 128              Feature child = HibernateProxyHelper.deproxy(termService.load(featureChildUuid), Feature.class);
 129              return addChildFeatureNode(node, child);
 130          }
 131
 132          @Override
 133          public DeleteResult isDeletable(FeatureNode node, FeatureNodeDeletionConfigurator config){
 134              DeleteResult result = new DeleteResult();
 135              Set<CdmBase> references = commonService.getReferencingObjectsForDeletion(node);
 136              for (CdmBase ref:references){
 137                  if (ref instanceof FeatureNode){
 138                      break;
 139                  }
 140                  if (ref instanceof FeatureTree){
 141                      FeatureTree refTree = HibernateProxyHelper.deproxy(ref, FeatureTree.class);
 142                      if (node.getFeatureTree().equals((refTree))){
 143                          break;
 144                      }
 145                  }
 146                  result.setAbort();
 147                  result.addException(new ReferencedObjectUndeletableException("The featureNode is referenced by " + ref.getUserFriendlyDescription() +" with id " +ref.getId()));
 148
 149              }
 150              return result;
 151          }
 152
 153     /**
 154      * {@inheritDoc}
 155      */
 156     @Override
 157     public UpdateResult moveFeatureNode(UUID movedNodeUuid, UUID targetNodeUuid, int position) {
 158         UpdateResult result = new UpdateResult();
 159         FeatureNode movedNode = HibernateProxyHelper.deproxy(load(movedNodeUuid), FeatureNode.class);
 160         FeatureNode targetNode = HibernateProxyHelper.deproxy(load(targetNodeUuid), FeatureNode.class);
 161         FeatureNode parent = HibernateProxyHelper.deproxy(movedNode.getParent(), FeatureNode.class);
 162         if(position<0){
 163             targetNode.addChild(movedNode);
 164         }
 165         else{
 166             targetNode.addChild(movedNode, position);
 167         }
 168         result.addUpdatedObject(targetNode);
 169         if(parent!=null){
 170             result.addUpdatedObject(parent);
 171         }
 172         result.setCdmEntity(targetNode.getFeatureTree());
 173         return result;
 174     }
 175
 176     /**
 177      * {@inheritDoc}
 178      */
 179     @Override
 180     public UpdateResult moveFeatureNode(UUID movedNodeUuid, UUID targetNodeUuid) {
 181         return moveFeatureNode(movedNodeUuid, targetNodeUuid, -1);
 182     }
 183
 184 }