/ - Diff - EDIT - EDIT Project Management

+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     */
     package eu.etaxonomy.cdm.model.common;
-...
     // ************************* FACTORY METHODS ***********************************************/
     	/**
     	 * @param type the {@link TermType term type}, must be the same as for all included terms
     	 * @return
-...
     	public static OrderedTermVocabulary NewInstance(TermType type){
     		return new OrderedTermVocabulary(type);
+    	}
     	/**
     	 * @param type the {@link TermType term type}, must be the same as for all included terms
     	 * @param description the description of this vocabulary
     	 * @param label
     	 * @param label
     	 * @param labelAbbrev
     	 * @param termSourceUri
     	 * @return
-...
     	public static OrderedTermVocabulary NewInstance(TermType type, String description, String label, String labelAbbrev, URI termSourceUri){
     		return new OrderedTermVocabulary(type, description, label, labelAbbrev, termSourceUri);
+    	}
     //************************ CONSTRUCTOR *****************************************************/
     //************************ CONSTRUCTOR *****************************************************/
     	//for hibernate use only
     	@Deprecated
     	protected OrderedTermVocabulary() {
     		super();
+    	}
     	/**
     	 * @param term
     	 * @param label
-...
     	protected OrderedTermVocabulary(TermType type) {
     		super(type);
+    	}
     	/**
     	 * @param term
     	 * @param label
-...
+    	}
     //************************* METHODS **************************************/
     //************************* METHODS **************************************/
     	@Transient
     	@Override
     	public Set<T> getNewTermSet() {
     		return new TreeSet<T>();
+    	}
     	@Transient
     	public SortedSet<T> getOrderedTerms() {
     		SortedSet<T> result = getSortedSetOfTerms();
-...
     	public SortedSet<T> getLowerAndEqualTerms(T otb) {
     		SortedSet<T> result = new TreeSet<T>();
     		SortedSet<T> sortedSet = getSortedSetOfTerms();
     		result.addAll( sortedSet.headSet(otb));
     		//headSet Returns a view of the portion of this set whose elements are STRICTLY less than toElement
     		result = getLowerTerms(otb);
     		/*SortedSet<T> sortedSet = getSortedSetOfTerms();
     		result.addAll( sortedSet.headSet(otb));*/
     		//getLowerTerms Returns a view of the portion of this set whose elements are STRICTLY less than toElement
     		for (T setObject : terms){
     			if (setObject.compareTo(otb) == 0){
     				result.add(setObject);
-...
+    		}
     		return result;
+    	}
     	public SortedSet<T> getLowerTerms(T otb) {
     		SortedSet<T> result = getLowerAndEqualTerms(otb);
     		/*SortedSet<T> result = getLowerAndEqualTerms(otb);
     		for (T setObject : terms){
     			if (setObject.compareTo(otb) == 0){
     				result.remove(setObject);
+    			}
+    		}
     		}*/
     	    SortedSet<T> result = new TreeSet<T>();
             SortedSet<T> sortedSet = getSortedSetOfTerms();
             //headSet Returns a view of the portion of this set whose elements are STRICTLY less than toElement
             result.addAll( sortedSet.headSet(otb));
     		return result;
+    	}
-...
+    		}
     		return result;
+    	}
     	public T getNextHigherTerm(T otb) {
     		try {
     			return getHigherTerms(otb).first();
-...
     			return null;
+    		}
+    	}
     	public T getNextLowerTerm(T otb) {
     		try {
     			return getLowerTerms(otb).last();
-...
     			return null;
+    		}
+    	}
     	@Transient
     	public T getHighestTerm() {
     		try {
-...
     			return null;
+    		}
+    	}
     	/**
     	 * Adds a term to the the end / lowest
     	 * @see eu.etaxonomy.cdm.model.common.TermVocabulary#addTerm(eu.etaxonomy.cdm.model.common.DefinedTermBase)
     	 */
     	public void addTerm(T term) {
     	@Override
         public void addTerm(T term) {
     		SortedSet<T> sortedTerms = getSortedSetOfTerms();
     		int lowestOrderIndex;
     		if (sortedTerms.isEmpty()){
-...
     			lowestOrderIndex = first.orderIndex;
+    		}
     		term.orderIndex = lowestOrderIndex + 1;
     		super.addTerm(term);
     		super.addTerm(term);
+    	}
     	public void addTermAbove(T termToBeAdded, T lowerTerm)  {
     		int orderInd = lowerTerm.orderIndex;
     		termToBeAdded.orderIndex = orderInd;
     		//increment all orderIndexes of terms below
     		//increment all orderIndexes of terms below
     		Iterator<T> iterator = terms.iterator();
     		while(iterator.hasNext()){
     			T term = iterator.next();
-...
     	public void addTermBelow(T termToBeAdded, T higherTerm)  {
     		int orderInd = higherTerm.orderIndex;
     		termToBeAdded.orderIndex = orderInd + 1;
     		//increment all orderIndexes of terms below
     		//increment all orderIndexes of terms below
     		Iterator<T> iterator = getLowerTerms(higherTerm).iterator();
     		while(iterator.hasNext()){
     			T term = iterator.next();
-...
+    		}
     		super.addTerm(termToBeAdded);
+    	}
     	public void addTermEqualLevel(T termToBeAdded, T equalLevelTerm) throws WrongTermTypeException {
     		int orderInd = equalLevelTerm.orderIndex;
     		termToBeAdded.orderIndex = orderInd;
     		super.addTerm(termToBeAdded);
+    	}
     	@Override
     	public void removeTerm(T term) {
     		if (term == null){
-...
     		if (this.getEqualTerms(term).size() == 0){
     			Iterator<T> iterator = getLowerTerms(term).iterator();
     			while (iterator.hasNext()){
     				T otb = iterator.next();
     				T otb = iterator.next();
     				toBeChangedByObject = otb;
     				otb.decreaseIndex(this);
     				toBeChangedByObject = null;
-...
+    		}
     		super.removeTerm(term);
+    	}
     	@Transient
     	private T toBeChangedByObject;
     	public boolean indexChangeAllowed(OrderedTermBase<T> orderedTermBase){
     		return orderedTermBase == toBeChangedByObject ;
+    	}
     	@Transient
     	private SortedSet<T> getSortedSetOfTerms(){
     		SortedSet<T> sortedSet = new TreeSet<T>();

     	@Override
     	public Set<CdmBase> getReferencingObjectsForDeletion(CdmBase referencedCdmBase){
     	    if (referencedCdmBase == null){
     	        return null;
+    	    }
     		Set<CdmBase> result = getReferencingObjects(referencedCdmBase);
     		Set<ReferenceHolder> holderSet = referenceMap.get(IdentifiableEntity.class);
     		try {

     /**
     * Copyright (C) 2007 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.cdm.persistence.hibernate;
     import java.util.Set;
     import org.apache.log4j.Logger;
     import org.hibernate.HibernateException;
     import org.hibernate.event.spi.DeleteEvent;
     import org.hibernate.event.spi.DeleteEventListener;
     import eu.etaxonomy.cdm.model.common.RelationshipBase;
     /**
      * @author a.mueller
      * @created 04.03.2009
      * @version 1.0
      */
     public class CdmDeleteListener implements DeleteEventListener {
         private static final long serialVersionUID = -5511287200489449838L;
         protected static final Logger logger = Logger.getLogger(CdmDeleteListener.class);
         @Override
         public void onDelete(DeleteEvent event) throws HibernateException {
             Object entity = event.getObject();
             if(entity != null && RelationshipBase.class.isAssignableFrom(entity.getClass())) {
                 logger.info("Deleting " + entity);
                 deleteRelationship(event, entity);
+            }
+        }
         @Override
         public void onDelete(DeleteEvent event, Set transientEntities)throws HibernateException {
             Object entity = event.getObject();
             if(entity != null && RelationshipBase.class.isAssignableFrom(entity.getClass())) {
                 logger.info("Deleting " + entity);
                 deleteRelationship(event, entity);
+            }
+        }
         /**
          * @param event
          * @param entity
          */
         private void deleteRelationship(DeleteEvent event, Object entity) {
             RelationshipBase relationshipEntity = (RelationshipBase)entity;
           /*  if (relationshipEntity.isRemoved()){
                 Set<IRelated> deletedObjects = relationshipEntity.getDeletedObjects();
                 for (IRelated rel : deletedObjects){
                     if (rel != null){
                         logger.info("Updating related entity " + rel);
                         Object o = CdmBase.deproxy(rel, CdmBase.class);
                         EntityEntry entry = event.getSession().getPersistenceContext().getEntry(o);
                         if (entry == null){
     //						System.out.println();
+                        }
                         if (!entry.getStatus().equals(Status.DELETED)){
                             event.getSession().update(rel);
+                        }
+                    }
+                }
             }*/
+        }
+    }

     /**
     * Copyright (C) 2007 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.cdm.persistence.hibernate;
     import java.util.Set;
     import org.apache.log4j.Logger;
     import org.hibernate.HibernateException;
     import org.hibernate.event.spi.DeleteEvent;
     import org.hibernate.event.spi.DeleteEventListener;
     import eu.etaxonomy.cdm.model.common.RelationshipBase;
     /**
      * @author a.mueller
      * @created 04.03.2009
      * @version 1.0
      */
     public class CdmDeleteListener implements DeleteEventListener {
         private static final long serialVersionUID = -5511287200489449838L;
         protected static final Logger logger = Logger.getLogger(CdmDeleteListener.class);
         @Override
         public void onDelete(DeleteEvent event) throws HibernateException {
             Object entity = event.getObject();
             if(entity != null && RelationshipBase.class.isAssignableFrom(entity.getClass())) {
                 logger.info("Deleting " + entity);
                 deleteRelationship(event, entity);
+            }
+        }
         @Override
         public void onDelete(DeleteEvent event, Set transientEntities)throws HibernateException {
             Object entity = event.getObject();
             if(entity != null && RelationshipBase.class.isAssignableFrom(entity.getClass())) {
                 logger.info("Deleting " + entity);
                 deleteRelationship(event, entity);
+            }
+        }
         /**
          * @param event
          * @param entity
          */
         private void deleteRelationship(DeleteEvent event, Object entity) {
             RelationshipBase relationshipEntity = (RelationshipBase)entity;
           /*  if (relationshipEntity.isRemoved()){
                 Set<IRelated> deletedObjects = relationshipEntity.getDeletedObjects();
                 for (IRelated rel : deletedObjects){
                     if (rel != null){
                         logger.info("Updating related entity " + rel);
                         Object o = CdmBase.deproxy(rel, CdmBase.class);
                         EntityEntry entry = event.getSession().getPersistenceContext().getEntry(o);
                         if (entry == null){
     //						System.out.println();
+                        }
                         if (!entry.getStatus().equals(Status.DELETED)){
                             event.getSession().update(rel);
+                        }
+                    }
+                }
             }*/
+        }
+    }

         @Override
         @Transactional(readOnly = false)
         public DeleteResult deleteTaxonNode(UUID nodeUUID, TaxonDeletionConfigurator config) {
         	TaxonNode node = HibernateProxyHelper.deproxy(dao.load(nodeUUID), TaxonNode.class);
         	return deleteTaxonNode(node, config);
+        }
-...
         @Override
         @Transactional(readOnly = false)
         public DeleteResult deleteTaxonNode(TaxonNode node, TaxonDeletionConfigurator config) {
             DeleteResult result = new DeleteResult();
             if (node == null){
                 result.setAbort();
                 result.addException(new Exception("The TaxonNode is already deleted."));
                 return result;
+            }
             Taxon taxon = null;
             try{
                 taxon = (Taxon)HibernateProxyHelper.deproxy(node.getTaxon());
             }catch(NullPointerException e){
                 result.setAbort();
                 result.addException(new Exception("The Taxon is already deleted."));
         	Taxon taxon = (Taxon)HibernateProxyHelper.deproxy(node.getTaxon());
+            }
         	TaxonNode parent = HibernateProxyHelper.deproxy(node.getParent(), TaxonNode.class);
         	if (config == null){
         		config = new TaxonDeletionConfigurator();
+        	}
         	DeleteResult result = new DeleteResult();
         	if (config.getTaxonNodeConfig().getChildHandling().equals(ChildHandling.MOVE_TO_PARENT)){
         	   Object[] children = node.getChildNodes().toArray();
-...
         	    deleteTaxonNodes(node.getChildNodes(), config);
+        	}
         	if (config.getTaxonNodeConfig().isDeleteTaxon() && (config.isDeleteInAllClassifications() || taxon.getTaxonNodes().size() == 1)){
         		result = taxonService.deleteTaxon(taxon.getUuid(), config, node.getClassification().getUuid());
         		result.addUpdatedObject(parent);
         		if (result.isOk()){
         			return result;
+        		}
         	} else {
         	    result.addUpdatedObject(taxon);
         	if (taxon != null){
             	if (config.getTaxonNodeConfig().isDeleteTaxon() && (config.isDeleteInAllClassifications() || taxon.getTaxonNodes().size() == 1)){
             		result = taxonService.deleteTaxon(taxon.getUuid(), config, node.getClassification().getUuid());
             		result.addUpdatedObject(parent);
             		if (result.isOk()){
             			return result;
+            		}
             	} else {
             	    result.addUpdatedObject(taxon);
+            	}
+        	}
         	result.setCdmEntity(node);
         	boolean success = taxon.removeTaxonNode(node);
         	dao.save(parent);

                 config = new TaxonDeletionConfigurator();
+            }
         	Taxon taxon = (Taxon)dao.load(taxonUUID);
         	DeleteResult result = new DeleteResult();
         	if (taxon == null){
         	    result.setAbort();
         	    result.addException(new Exception ("The taxon was already deleted."));
         	    return result;
+        	}
         	taxon = (Taxon) HibernateProxyHelper.deproxy(taxon);
         	Classification classification = HibernateProxyHelper.deproxy(classificationDao.load(classificationUuid), Classification.class);
             DeleteResult result = isDeletable(taxon, config);
             result = isDeletable(taxon, config);
             if (result.isOk()){
                 // --- DeleteSynonymRelations
-...
             DeleteResult result = new DeleteResult();
         	if (synonym == null){
         		result.setAbort();
         		result.addException(new Exception("The synonym was already deleted."));
         		return result;
+            }
             if (config == null){
                 config = new SynonymDeletionConfigurator();
+            }
             result = isDeletable(synonym, config);

Project

General

Profile

EDIT

Revision d1cf4a26

Added by Katja Luther over 8 years ago