cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/Taxon.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonComparator.java -text
-cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonComparatorSearch.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonNaturalComparator.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonNode.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonNodeAgentRelation.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonNodeByNameComparator.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonNodeComparator.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonRelationship.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonRelationshipType.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/package-info.java -text
@Type(type = "eu.etaxonomy.cdm.hibernate.EnumUserType",\r
parameters = {@org.hibernate.annotations.Parameter(name = "enumClass", value = "eu.etaxonomy.cdm.model.common.TermType")}\r
)\r
+ @Audited\r
private TermType termType;\r
\r
@XmlElementWrapper(name = "Representations")\r
this.titleCache = null; //force titleCache refresh\r
}else{\r
repr = Representation.NewInstance(null, label, null, language);\r
- this.addRepresentation(repr);\r
- }\r
+ this.addRepresentation(repr);\r
}\r
}\r
+ }\r
\r
@Transient\r
public String getDescription() {\r
@Type(type = "eu.etaxonomy.cdm.hibernate.EnumUserType",
parameters = {@org.hibernate.annotations.Parameter(name="enumClass", value="eu.etaxonomy.cdm.model.name.RankClass")}
)
+ @Audited
private RankClass rankClass;
@Type(type = "eu.etaxonomy.cdm.hibernate.EnumUserType",
parameters = {@org.hibernate.annotations.Parameter(name = "enumClass", value = "eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType")}
)
+ @Audited
private SpecimenOrObservationType recordBasis;
this.countChildren = childNodes.size();\r
child.setParent(null);\r
child.setTreeIndex(null);\r
- updateSortIndex(childNodes, index);\r
+ updateSortIndex(index);\r
child.setSortIndex(null);\r
}\r
}\r
protected void setParentTreeNode(TaxonNode parent, int index){\r
// remove ourselves from the old parent\r
TaxonNode formerParent = this.getParent();\r
-\r
+ formerParent = HibernateProxyHelper.deproxy(formerParent, TaxonNode.class);\r
if (formerParent != null){\r
//special case, child already exists for same parent\r
//FIXME document / check for correctness\r
\r
//sortIndex\r
//TODO workaround (see sortIndex doc)\r
- updateSortIndex(parentChildren, index);\r
+ this.getParent().updateSortIndex(index);\r
//only for debugging\r
if (! this.getSortIndex().equals(index)){\r
logger.warn("index and sortindex are not equal");\r
* @param parentChildren\r
* @param index\r
*/\r
- private void updateSortIndex(List<TaxonNode> children, int index) {\r
- for(int i = index; i < children.size(); i++){\r
- TaxonNode child = children.get(i);\r
+ private void updateSortIndex(int index) {\r
+ for(int i = index; i < this.childNodes.size(); i++){\r
+ TaxonNode child = childNodes.get(i);\r
if (child != null){\r
// child = CdmBase.deproxy(child, TaxonNode.class); //deproxy not needed as long as setSortIndex is protected or public #4200\r
child.setSortIndex(i);\r
* @date 18.03.2010\r
*\r
*/\r
-public class TaxonComparatorSearch implements Serializable, Comparator<TaxonBase> {\r
+public class TaxonNodeComparator implements Serializable, Comparator<TaxonNode> {\r
private static final long serialVersionUID = 2596641007876609704L;\r
-\r
- public int compare(TaxonBase taxon1, TaxonBase taxon2) {\r
+ \r
+ public int compare(TaxonNode node1, TaxonNode node2) {\r
+ \r
\r
- if (taxon1.getUuid().equals(taxon2.getUuid())){\r
+ if (node1.getUuid().equals(node2.getUuid())){\r
return 0;\r
}\r
- TaxonNameBase<?,?> name1 = taxon1.getName();\r
- TaxonNameBase<?,?> name2 = taxon2.getName();\r
+ TaxonBase taxon1 = node1.getTaxon();\r
+ TaxonBase taxon2 = node2.getTaxon();\r
+ \r
+ TaxonNameBase name1 = taxon1.getName();\r
+ TaxonNameBase name2 = taxon2.getName();\r
\r
Rank rankTax1 = (name1 == null) ? null : name1.getRank();\r
Rank rankTax2 = (name2 == null) ? null : name2.getRank();\r
}\r
}\r
\r
+ \r
+\r
}\r
import org.junit.Test;\r
\r
import eu.etaxonomy.cdm.model.agent.Person;\r
+import eu.etaxonomy.cdm.model.name.BotanicalName;\r
+import eu.etaxonomy.cdm.model.name.HybridRelationship;\r
+import eu.etaxonomy.cdm.model.name.HybridRelationshipType;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
private NonViralName<?> abiesAlba;\r
private NonViralName<?> abiesAlbaMichx;\r
private NonViralName<?> abiesAlbaMill;\r
+ private NonViralName<?> abiesAlbaxPinusBeta;\r
+ private NonViralName<?> pinusBeta;\r
\r
private Taxon abiesTaxon;\r
private Taxon abiesMillTaxon;\r
\r
private NonViralName<?> abiesBalsamea;\r
private Taxon abiesBalsameaTaxon;\r
+ private Taxon abiesAlbaxPinusBetaTaxon;\r
/**\r
* @throws java.lang.Exception\r
*/\r
abiesBalsamea.setTitleCache("Abies sect. Balsamea L.", true);\r
abiesBalsameaTaxon = Taxon.NewInstance(abiesBalsamea, sec);\r
\r
+ abiesAlbaxPinusBeta = NonViralName.NewInstance(Rank.SPECIES());\r
+ pinusBeta = NonViralName.NewInstance(Rank.SPECIES());\r
+ pinusBeta.setGenusOrUninomial("Pinus");\r
+ pinusBeta.setSpecificEpithet("beta");\r
+ abiesAlbaxPinusBeta.setHybridFormula(true);\r
+ abiesAlbaxPinusBeta.addHybridParent(abiesAlba, HybridRelationshipType.FIRST_PARENT(), null);\r
+ abiesAlbaxPinusBeta.addHybridParent(pinusBeta, HybridRelationshipType.SECOND_PARENT(), null);\r
+ \r
}\r
\r
/**\r
compareResult = (abiesMill.compareTo(abies) == 0);\r
equalsResult = abiesMill.equals(abies);\r
assertEquals(compareResult, equalsResult);\r
+ \r
+ //Abies alba x Pinus beta < Abies alba xinus\r
+ BotanicalName abiesAlbaXinus = BotanicalName.NewInstance(Rank.SUBSPECIES());\r
+ abiesAlbaXinus.setGenusOrUninomial("Abies");\r
+ abiesAlbaXinus.setSpecificEpithet("alba");\r
+ abiesAlbaXinus.setInfraSpecificEpithet("xinus");\r
+ result = abiesAlbaxPinusBeta.compareTo(abiesAlbaXinus);\r
+ assertTrue(result < 0);\r
}\r
\r
/**\r
<?xml version='1.0' encoding='UTF-8'?>\r
<dataset>\r
<TAXONNODE ID="1" CREATED="2009-06-18 13:47:59.0" UUID="cf0316c9-1963-4268-8c2e-8d833c460ac3" SORTINDEX="-1" TREEINDEX="#t1#1#" COUNTCHILDREN="4" CLASSIFICATION_ID="1"/>\r
- <TAXONNODE ID="2" CREATED="2009-06-18 13:47:59.0" UUID="770239f6-4fa8-496b-8738-fe8f7b2ad519" SORTINDEX="1" TREEINDEX="#t1#1#2#" COUNTCHILDREN="0" CLASSIFICATION_ID="1" PARENT_ID="1" TAXON_ID="37"/>\r
- <TAXONNODE ID="3" CREATED="2009-06-18 13:47:59.0" UUID="20c8f083-5870-4cbd-bf56-c5b2b98ab6a7" SORTINDEX="2" TREEINDEX="#t1#1#3#" COUNTCHILDREN="1" CLASSIFICATION_ID="1" PARENT_ID="1" TAXON_ID="36"/>\r
+ <TAXONNODE ID="2" CREATED="2009-06-18 13:47:59.0" UUID="770239f6-4fa8-496b-8738-fe8f7b2ad519" SORTINDEX="0" TREEINDEX="#t1#1#2#" COUNTCHILDREN="0" CLASSIFICATION_ID="1" PARENT_ID="1" TAXON_ID="37"/>\r
+ <TAXONNODE ID="3" CREATED="2009-06-18 13:47:59.0" UUID="20c8f083-5870-4cbd-bf56-c5b2b98ab6a7" SORTINDEX="1" TREEINDEX="#t1#1#3#" COUNTCHILDREN="1" CLASSIFICATION_ID="1" PARENT_ID="1" TAXON_ID="36"/>\r
<TAXONNODE ID="4" CREATED="2009-06-18 13:47:59.0" UUID="0b5846e5-b8d2-4ca9-ac51-099286ea4adc" SORTINDEX="0" TREEINDEX="#t1#1#3#4#" COUNTCHILDREN="0" CLASSIFICATION_ID="1" PARENT_ID="3" TAXON_ID="38"/>\r
- <TAXONNODE ID="5" CREATED="2009-06-18 13:47:59.0" UUID="4f73adcc-a535-4fbe-a97a-c05ee8b12191" SORTINDEX="3" TREEINDEX="#t1#1#5#" COUNTCHILDREN="0" CLASSIFICATION_ID="1" PARENT_ID="1" TAXON_ID="42"/>\r
+ <TAXONNODE ID="5" CREATED="2009-06-18 13:47:59.0" UUID="4f73adcc-a535-4fbe-a97a-c05ee8b12191" SORTINDEX="2" TREEINDEX="#t1#1#5#" COUNTCHILDREN="0" CLASSIFICATION_ID="1" PARENT_ID="1" TAXON_ID="42"/>\r
</dataset>
\ No newline at end of file
\r
import java.util.ArrayList;\r
import java.util.List;\r
+import java.util.UUID;\r
\r
import org.apache.log4j.Logger;\r
import org.springframework.beans.factory.annotation.Autowired;\r
}\r
\r
@Override\r
- public DeleteResult delete(AgentBase base){\r
-\r
+ public DeleteResult delete(UUID agentUUID){\r
+ AgentBase base = dao.load(agentUUID);\r
DeleteResult result = this.isDeletable(base, null);\r
\r
if (result.isOk()){\r
return result;\r
}\r
\r
+ @Override\r
+ public DeleteResult delete(AgentBase agent){\r
+ return delete(agent.getUuid());\r
+ }\r
+ \r
@Override\r
public Person convertTeam2Person(Team team) throws MergeException {\r
Person result = null;\r
}
@Override
- public DeleteResult delete(Group group){
- String groupUUID = group.getUuid().toString();
+ public DeleteResult delete(UUID groupUUID ){
+
+ String groupUUIDString = groupUUID.toString();
//org.springframework.security.provisioning.GroupManager#deleteGroup needs a string argument
- this.deleteGroup(groupUUID);
+ this.deleteGroup(groupUUIDString);
//there is no feedback from the deleteGroup method...
return new DeleteResult();
}
\r
import java.util.List;\r
\r
+import eu.etaxonomy.cdm.api.service.config.SwitchAgentConfigurator;\r
import eu.etaxonomy.cdm.api.service.pager.Pager;\r
import eu.etaxonomy.cdm.model.agent.Address;\r
import eu.etaxonomy.cdm.model.agent.AgentBase;\r
* @return a list of <code>UuidAndTitleCache</code> instances\r
*/\r
public List<UuidAndTitleCache<Institution>> getInstitutionUuidAndTitleCache();\r
+\r
\r
/**\r
* If the given {@link Team} is a single member team all links to the team are redirected to the\r
* @param treeNode
* @return
*/
+
public UUID removeTreeNode(ITaxonTreeNode treeNode);
/**
* @param config\r
*\r
*/\r
- public DeleteResult delete(TaxonNameBase name, NameDeletionConfigurator config);\r
+ public DeleteResult delete(UUID nameUUID, NameDeletionConfigurator config);\r
\r
/**\r
* Removes the given type designation from the given taxon name and deletes it from\r
\r
public List<HashMap<String, String>> getNameRecords();\r
\r
+\r
}
\ No newline at end of file
\r
\r
import java.util.Collection;\r
+import java.util.HashMap;\r
import java.util.List;\r
import java.util.Map;\r
import java.util.Set;\r
* @return the unique identifier of the deleted entity\r
* @return deleteResult\r
*/\r
- public DeleteResult delete(T persistentObject) ;\r
+ public DeleteResult delete(UUID persistentObjectUUID) ;\r
\r
- public DeleteResult delete(UUID uuid) ;\r
+ \r
\r
/**\r
* Returns true if an entity of type <T> with a unique identifier matching the\r
*/\r
public List<T> list(T example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths);\r
\r
+ public DeleteResult delete(T persistentObject);\r
+\r
+ \r
\r
}
\ No newline at end of file
* @param synonym
* @param acceptedTaxon
* @param synonymRelationshipType the relationship type the newly created synonym will have. Defaults to SYNONYM_OF
+ * @return
*/
- public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon);
+ public UpdateResult swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon);
/**
* Changes a synonym into an accepted taxon and removes
@Deprecated
public long deleteSynonymRelationships(Synonym syn, Taxon taxon);
- /**
- * Deletes a taxon from the underlying database according to the given {@link TaxonDeletionConfigurator configurator}.
- * @param taxon
- * @param config
- *
- */
- public DeleteResult deleteTaxon(Taxon taxon, TaxonDeletionConfigurator config, Classification classification) ;
-
+
/**
* Changes the homotypic group of a synonym into the new homotypic group.
* All relations to taxa are updated correctly depending on the homotypic
Reference reference, String referenceDetail, boolean keepReference)
throws HomotypicalGroupChangeException;
+ public UpdateResult moveFactualDateToAnotherTaxon(UUID fromTaxonUuid,
+ UUID toTaxonUuid);
+
* @see eu.etaxonomy.cdm.api.service.ServiceBase#delete(eu.etaxonomy.cdm.model.common.CdmBase)\r
*/\r
@Override\r
- public DeleteResult delete(TaxonNameBase name){\r
+ public DeleteResult delete(UUID nameUUID){\r
NameDeletionConfigurator config = new NameDeletionConfigurator();\r
- DeleteResult result = delete(name, config);\r
+ \r
+ DeleteResult result = delete(nameUUID, config);\r
\r
\r
return result;\r
\r
}\r
+ \r
+ @Override\r
+ public DeleteResult delete(TaxonNameBase name){\r
+ return delete(name.getUuid());\r
+ }\r
\r
/* (non-Javadoc)\r
* @see eu.etaxonomy.cdm.api.service.INameService#delete(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.api.service.NameDeletionConfigurator)\r
*/\r
@Override\r
- public DeleteResult delete(TaxonNameBase name, NameDeletionConfigurator config) {\r
+ public DeleteResult delete(UUID nameUUID, NameDeletionConfigurator config) {\r
DeleteResult result = new DeleteResult();\r
-\r
+ TaxonNameBase name = dao.load(nameUUID);\r
+ \r
if (name == null){\r
result.setAbort();\r
return result;\r
return dao.getNameRecords();\r
\r
}\r
-\r
+ \r
}\r
\r
@Override\r
@Transactional(readOnly = false)\r
- public DeleteResult delete(T persistentObject) {\r
+ public DeleteResult delete(UUID persistentObjectUUID) {\r
DeleteResult result = new DeleteResult();\r
try{\r
+ T persistentObject = dao.load(persistentObjectUUID);\r
dao.delete(persistentObject);\r
- result.setCdmEntity(persistentObject);\r
} catch(DataAccessException e){\r
result.setError();\r
result.addException(e);\r
}\r
return result;\r
}\r
-\r
@Override\r
@Transactional(readOnly = false)\r
- public DeleteResult delete(UUID uuid) {\r
- return delete(dao.load(uuid));\r
+ public DeleteResult delete(T persistentObject) {\r
+ DeleteResult result = new DeleteResult();\r
+ try{\r
+ dao.delete(persistentObject);\r
+ result.setCdmEntity(persistentObject);\r
+ } catch(DataAccessException e){\r
+ result.setError();\r
+ result.addException(e);\r
+ }\r
+ return result;\r
}\r
\r
+ \r
+\r
@Override\r
@Transactional(readOnly = true)\r
public boolean exists(UUID uuid) {\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.taxon.Classification;
-import eu.etaxonomy.cdm.model.taxon.ITaxonNodeComparator;
+import eu.etaxonomy.cdm.model.taxon.TaxonNodeComparator;
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
import eu.etaxonomy.cdm.model.taxon.Taxon;
+
import eu.etaxonomy.cdm.model.taxon.TaxonNaturalComparator;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
+import eu.etaxonomy.cdm.model.taxon.TaxonNodeByNameComparator;
+
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;
@Autowired
private IBeanInitializer defaultBeanInitializer;
- private Comparator<? super TaxonNode> taxonNodeComparator;
+ private Comparator<? super TaxonNode> taxonNodeComparator = new TaxonNodeByNameComparator();
@Autowired
private ITaxonService taxonService;
@Autowired
private IClassificationService classService;
- @Autowired
- public void setTaxonNodeComparator(ITaxonNodeComparator<? super TaxonNode> taxonNodeComparator){
- this.taxonNodeComparator = (Comparator<? super TaxonNode>) taxonNodeComparator;
- }
+
@Override
public List<TaxonNode> loadChildNodesOfTaxonNode(TaxonNode taxonNode,
if (sortMode == null){
sortMode = NodeSortMode.RankAndAlphabeticalOrder;
}
+ Comparator<TaxonNode> comparator = null;
if (sortMode.equals(NodeSortMode.NaturalOrder)){
- TaxonNaturalComparator comparator = new TaxonNaturalComparator();
- Collections.sort(childNodes, comparator);
+ comparator = new TaxonNaturalComparator();
+
} else if (sortMode.equals(NodeSortMode.AlphabeticalOrder)){
- Collections.sort(childNodes, this.taxonNodeComparator);
+ comparator = new TaxonNodeByNameComparator();
+
+ } else if (sortMode.equals(NodeSortMode.RankAndAlphabeticalOrder)){
+ comparator = new TaxonNodeComparator();
+
+ }
+ if (comparator != null){
+ Collections.sort(childNodes, comparator);
}
defaultBeanInitializer.initializeAll(childNodes, propertyPaths);
return childNodes;
// conf.setDeleteNameIfPossible(false);
if (result.isOk()){
- result = taxonService.deleteTaxon(oldTaxon, conf, null);
+ result = taxonService.deleteTaxon(oldTaxon.getUuid(), conf, null);
}else{
result.setStatus(Status.OK);
TaxonNodeDeletionConfigurator config = new TaxonNodeDeletionConfigurator();
saveOrUpdate(taxonNode);
TaxonDeletionConfigurator configNew = new TaxonDeletionConfigurator();
- DeleteResult resultTaxon = taxonService.deleteTaxon(taxon, configNew, classification);
+ DeleteResult resultTaxon = taxonService.deleteTaxon(taxon.getUuid(), configNew, classification.getUuid());
if (!resultTaxon.isOk()){
result.addExceptions(resultTaxon.getExceptions());
result.setStatus(resultTaxon.getStatus());
saveOrUpdate(taxonNode);
taxonService.saveOrUpdate(taxon);
- DeleteResult resultTaxon = taxonService.deleteTaxon(taxon, configNew, classification);
+ DeleteResult resultTaxon = taxonService.deleteTaxon(taxon.getUuid(), configNew, null);
+
if (!resultTaxon.isOk()){
result.addExceptions(resultTaxon.getExceptions());
result.setStatus(resultTaxon.getStatus());
}
DeleteResult result = new DeleteResult();
if (config.getTaxonNodeConfig().isDeleteTaxon()){
- result = taxonService.deleteTaxon(taxon, config, node.getClassification());
+ result = taxonService.deleteTaxon(taxon.getUuid(), config, node.getClassification().getUuid());
if (result.isOk()){
return result;
}
\r
import javax.persistence.EntityNotFoundException;\r
\r
+import org.apache.commons.lang.StringUtils;\r
import org.apache.log4j.Logger;\r
import org.apache.lucene.index.CorruptIndexException;\r
import org.apache.lucene.queryParser.ParseException;\r
import eu.etaxonomy.cdm.hibernate.search.GroupByTaxonClassBridge;\r
import eu.etaxonomy.cdm.hibernate.search.MultilanguageTextFieldBridge;\r
import eu.etaxonomy.cdm.model.CdmBaseType;\r
+import eu.etaxonomy.cdm.model.common.Annotation;\r
+import eu.etaxonomy.cdm.model.common.AnnotationType;\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
import eu.etaxonomy.cdm.model.common.DefinedTerm;\r
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;\r
\r
@Override\r
@Transactional(readOnly = false)\r
- public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon){\r
-\r
+ public UpdateResult swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon){\r
+ UpdateResult result = new UpdateResult();\r
TaxonNameBase<?,?> synonymName = synonym.getName();\r
synonymName.removeTaxonBase(synonym);\r
TaxonNameBase<?,?> taxonName = acceptedTaxon.getName();\r
\r
synonym.setName(taxonName);\r
acceptedTaxon.setName(synonymName);\r
+ result.addUpdatedObject(acceptedTaxon);\r
+ result.addUpdatedObject(synonym);\r
+ return result;\r
\r
// the accepted taxon needs a new uuid because the concept has changed\r
// FIXME this leads to an error "HibernateException: immutable natural identifier of an instance of eu.etaxonomy.cdm.model.taxon.Taxon was altered"\r
}\r
\r
\r
- @Override\r
- @Transactional(readOnly = false)\r
- public UpdateResult swapSynonymAndAcceptedTaxon(UUID synonymUuid, UUID acceptedTaxonUuid) {\r
- UpdateResult result = new UpdateResult();\r
- Synonym synonym = (Synonym)dao.load(synonymUuid);\r
- Taxon taxon = (Taxon)dao.load(acceptedTaxonUuid);\r
- result.addUpdatedObject(synonym);\r
- result.addUpdatedObject(taxon);\r
- result.setCdmEntity(synonym);\r
- swapSynonymAndAcceptedTaxon(synonym, taxon);\r
- return result;\r
- }\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon)\r
- */\r
-\r
@Override\r
@Transactional(readOnly = false)\r
public Taxon changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean deleteSynonym, boolean copyCitationInfo, Reference citation, String microCitation) throws HomotypicalGroupChangeException{\r
results = dao.getTaxaByNameForEditor(configurator.isDoTaxa(), configurator.isDoSynonyms(), configurator.isDoNamesWithoutTaxa(), configurator.isDoMisappliedNames(),configurator.getTitleSearchStringSqlized(), configurator.getClassification(), configurator.getMatchMode(), configurator.getNamedAreas());\r
}\r
if (configurator.isDoTaxaByCommonNames()) {\r
-\r
//if(configurator.getPageSize() == null ){\r
List<UuidAndTitleCache<IdentifiableEntity>> commonNameResults = dao.getTaxaByCommonNameForEditor(configurator.getTitleSearchStringSqlized(), configurator.getClassification(), configurator.getMatchMode(), configurator.getNamedAreas());\r
if(commonNameResults != null){\r
}\r
\r
@Override\r
- @Transactional(readOnly = true)\r
- public DeleteResult deleteTaxon(UUID taxonUuid, TaxonDeletionConfigurator config, UUID classificationUuid) {\r
- return deleteTaxon((Taxon)dao.load(taxonUuid), config, classificationDao.load(classificationUuid));\r
- }\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator)\r
- */\r
-\r
- @Override\r
- public DeleteResult deleteTaxon(Taxon taxon, TaxonDeletionConfigurator config, Classification classification) {\r
+ public DeleteResult deleteTaxon(UUID taxonUUID, TaxonDeletionConfigurator config, UUID classificationUuid) {\r
\r
if (config == null){\r
config = new TaxonDeletionConfigurator();\r
}\r
-\r
+ Taxon taxon = (Taxon)dao.load(taxonUUID);\r
+ Classification classification = HibernateProxyHelper.deproxy(classificationDao.load(classificationUuid), Classification.class);\r
DeleteResult result = isDeletable(taxon, config);\r
\r
if (result.isOk()){\r
if (config.isDeleteMisappliedNamesAndInvalidDesignations()){\r
if (taxRel.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) || taxRel.getType().equals(TaxonRelationshipType.INVALID_DESIGNATION_FOR())){\r
if (taxon.equals(taxRel.getToTaxon())){\r
- this.deleteTaxon(taxRel.getFromTaxon(), config, classification);\r
+ \r
+ this.deleteTaxon(taxRel.getFromTaxon().getUuid(), config, classificationUuid);\r
}\r
}\r
}\r
" which also describes specimens or abservations";\r
//throw new ReferencedObjectUndeletableException(message);\r
}\r
-\r
removeDescriptions.add(desc);\r
-\r
+ \r
\r
}\r
for (TaxonDescription desc: removeDescriptions){\r
\r
//remove name if possible (and required)\r
if (name != null && config.isDeleteNameIfPossible()){\r
- nameResult = nameService.delete(name, config.getNameDeletionConfig());\r
+ nameResult = nameService.delete(name.getUuid(), config.getNameDeletionConfig());\r
}\r
\r
if (nameResult.isError()){\r
}\r
\r
@Transactional(readOnly = false)\r
- public UUID delete(Synonym syn){\r
- UUID result = syn.getUuid();\r
- this.deleteSynonym(syn, null);\r
- return result;\r
+ public DeleteResult delete(UUID synUUID){\r
+ DeleteResult result = new DeleteResult();\r
+ Synonym syn = (Synonym)dao.load(synUUID);\r
+ \r
+ return this.deleteSynonym(syn, null);\r
}\r
\r
@Transactional(readOnly = false)\r
this.saveOrUpdate(relatedTaxon);\r
}\r
this.saveOrUpdate(synonym);\r
- result.addUpdatedObject(taxon);\r
+\r
//TODO remove name from homotypical group?\r
\r
//remove synonym (if necessary)\r
//remove name if possible (and required)\r
if (name != null && config.isDeleteNameIfPossible()){\r
\r
- DeleteResult nameDeleteresult = nameService.delete(name, config.getNameDeletionConfig());\r
+ DeleteResult nameDeleteresult = nameService.delete(name.getUuid(), config.getNameDeletionConfig());\r
if (nameDeleteresult.isAbort()){\r
result.addExceptions(nameDeleteresult.getExceptions());\r
result.addUpdatedObject(name);\r
\r
}\r
\r
-\r
- @Transactional(readOnly = false)\r
- @Override\r
- public DeleteResult deleteSynonym(UUID synonymUuid, UUID taxonUuid, SynonymDeletionConfigurator config) {\r
- return deleteSynonym((Synonym)dao.load(synonymUuid), (Taxon)dao.load(taxonUuid), config);\r
- }\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNameIds(java.util.List)\r
- */\r
-\r
@Override\r
public List<TaxonNameBase> findIdenticalTaxonNameIds(List<String> propertyPath) {\r
\r
//TODO: configurator and classification\r
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();\r
config.setDeleteNameIfPossible(false);\r
- this.deleteTaxon(fromTaxon, config, null);\r
+ this.deleteTaxon(fromTaxon.getUuid(), config, null);\r
return synonymRelationship.getSynonym();\r
\r
}\r
Taxon newTaxon = (Taxon) dao.load(newTaxonUUID);\r
return moveSynonymToAnotherTaxon(oldSynonymRelation, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, reference, referenceDetail, keepReference);\r
}\r
+ \r
+ @Override\r
+ public UpdateResult moveFactualDateToAnotherTaxon(UUID fromTaxonUuid, UUID toTaxonUuid){\r
+ UpdateResult result = new UpdateResult();\r
+ \r
+ Taxon fromTaxon = (Taxon)dao.load(fromTaxonUuid);\r
+ Taxon toTaxon = (Taxon) dao.load(toTaxonUuid);\r
+ for(TaxonDescription description : fromTaxon.getDescriptions()){\r
+ //reload to avoid session conflicts\r
+ description = HibernateProxyHelper.deproxy(description, TaxonDescription.class);\r
+\r
+ String moveMessage = String.format("Description moved from %s", fromTaxon);\r
+ if(description.isProtectedTitleCache()){\r
+ String separator = "";\r
+ if(!StringUtils.isBlank(description.getTitleCache())){\r
+ separator = " - ";\r
+ }\r
+ description.setTitleCache(description.getTitleCache() + separator + moveMessage, true);\r
+ }\r
+ Annotation annotation = Annotation.NewInstance(moveMessage, Language.getDefaultLanguage());\r
+ annotation.setAnnotationType(AnnotationType.TECHNICAL());\r
+ description.addAnnotation(annotation);\r
+ toTaxon.addDescription(description);\r
+ dao.saveOrUpdate(toTaxon);\r
+ dao.saveOrUpdate(fromTaxon);\r
+ result.addUpdatedObject(toTaxon);\r
+ result.addUpdatedObject(fromTaxon);\r
+ \r
+ }\r
+\r
+ \r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public DeleteResult deleteSynonym(UUID synonymUuid, UUID taxonUuid,\r
+ SynonymDeletionConfigurator config) {\r
+ TaxonBase base = this.load(synonymUuid);\r
+ Synonym syn = HibernateProxyHelper.deproxy(base, Synonym.class);\r
+ base = this.load(taxonUuid);\r
+ Taxon taxon = HibernateProxyHelper.deproxy(base, Taxon.class); \r
+ \r
+ return this.deleteSynonym(syn, taxon, config);\r
+ }\r
+\r
+ @Override\r
+ public UpdateResult swapSynonymAndAcceptedTaxon(UUID synonymUUid,\r
+ UUID acceptedTaxonUuid) {\r
+ TaxonBase base = this.load(synonymUUid);\r
+ Synonym syn = HibernateProxyHelper.deproxy(base, Synonym.class);\r
+ base = this.load(acceptedTaxonUuid);\r
+ Taxon taxon = HibernateProxyHelper.deproxy(base, Taxon.class); \r
+ \r
+ return this.swapSynonymAndAcceptedTaxon(syn, taxon);\r
+ }\r
+\r
+\r
+ \r
}\r
NameDeletionConfigurator config = new NameDeletionConfigurator();\r
\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
- DeleteResult result = nameService.delete(name1, config);\r
+ DeleteResult result = nameService.delete(name1.getUuid(), config);\r
if (result.isOk()){\r
Assert.fail("This should throw an error as long as name relationships exist.");\r
}\r
config.setIgnoreIsBasionymFor(true);\r
\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
- nameService.delete(name1, config);\r
+ nameService.delete(name1.getUuid(), config);\r
commitAndStartNewTransaction(tableNames);\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
Assert.assertNull("Name should not be in database anymore",name1);\r
NameDeletionConfigurator config = new NameDeletionConfigurator();\r
\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
- DeleteResult result = nameService.delete(name1, config);\r
+ DeleteResult result = nameService.delete(name1.getUuid(), config);\r
if (result.isOk()){\r
Assert.fail("Delete should throw an error as long as name relationships exist.");\r
}\r
config.setRemoveAllNameRelationships(true);\r
\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
- result = nameService.delete(name1, config);\r
+ result = nameService.delete(name1.getUuid(), config);\r
logger.debug(result);\r
commitAndStartNewTransaction(tableNames);\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
config.setIgnoreHasBasionym(false);\r
\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
- DeleteResult result = nameService.delete(name1, config);\r
+ DeleteResult result = nameService.delete(name1.getUuid(), config);\r
if (result.isOk()){\r
Assert.fail("Delete should throw an error as long as name relationships exist.");\r
}\r
config.setIgnoreHasBasionym(true);\r
try {\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
- result = nameService.delete(name1, config);\r
+ result = nameService.delete(name1.getUuid(), config);\r
logger.debug(result);\r
commitAndStartNewTransaction(tableNames);\r
name1 = (NonViralName<?>)nameService.find(name1.getUuid());\r
Taxon taxon = (Taxon)taxonService.load(UUID_ACHERONTINII);\r
try{\r
// try {\r
- DeleteResult result = taxonService.deleteTaxon(taxon, null, null);\r
+ DeleteResult result = taxonService.deleteTaxon(taxon.getUuid(), null, null);\r
/*} catch (DataChangeNoRollbackException e) {\r
Assert.fail();\r
}*/\r
context.setAuthentication(authentication);\r
\r
Taxon taxon = (Taxon)taxonService.load(UUID_LACTUCA);\r
- DeleteResult result = taxonService.deleteTaxon(taxon, null, null);\r
- if (!result.isError()) {\r
- Assert.fail();\r
+ try{\r
+ DeleteResult result = taxonService.deleteTaxon(taxon.getUuid(), null, null);\r
+ Assert.fail();\r
+ }catch(PermissionDeniedException e){\r
+ \r
}\r
endTransaction();\r
startNewTransaction();\r
Taxon actualTaxon = (Taxon)taxonService.find(UUID.fromString("7b8b5cb3-37ba-4dba-91ac-4c6ffd6ac331"));\r
\r
//try {\r
- DeleteResult result = taxonService.deleteTaxon(actualTaxon, null, null);\r
+ DeleteResult result = taxonService.deleteTaxon(actualTaxon.getUuid(), null, null);\r
/*} catch (DataChangeNoRollbackException e) {\r
Assert.fail();\r
}*/\r
assertEquals(3,t2.getSynonyms().size());
assertEquals(2, t2.getDescriptions().size());
- result = taxonService.deleteTaxon(t1, null, null);
+ result = taxonService.deleteTaxon(t1.getUuid(), null, null);
if (result.isAbort() || result.isError()){
Assert.fail();
}
//root of new classification
Classification classification2 = classificationService.load(classification2Uuid);
node1 = taxonNodeService.load(node1Uuid);
+ classification2.setRootNode(HibernateProxyHelper.deproxy(classification2.getRootNode(),TaxonNode.class));
classification2.addChildNode(node1, null, null);
taxonNodeService.saveOrUpdate(node1);
commitAndStartNewTransaction(new String[]{"TaxonNode"});
Taxon taxon = Taxon.NewInstance(BotanicalName.NewInstance(Rank.UNKNOWN_RANK()), null);\r
UUID uuid = service.save(taxon);\r
// try {\r
- service.deleteTaxon(taxon, null, null);\r
+ service.deleteTaxon(taxon.getUuid(), null, null);\r
/*} catch (DataChangeNoRollbackException e) {\r
// TODO Auto-generated catch block\r
e.printStackTrace();\r
\r
}\r
@Test\r
- @DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")\r
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")\r
public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedNameDeleteAllNameRelations(){\r
final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",\r
"SynonymRelationship","SynonymRelationship_AUD",\r
//try {\r
//commitAndStartNewTransaction(tableNames);\r
\r
- DeleteResult result = service.deleteTaxon(child1, config, null);\r
+ DeleteResult result = service.deleteTaxon(child1.getUuid(), config, null);\r
if (result.isOk()){\r
Assert.fail("Delete should throw an error as long as name is used in classification.");\r
}\r
\r
// try {\r
\r
- result = service.deleteTaxon(child1, config, null);\r
+ result = service.deleteTaxon(child1\r
+ .getUuid(), config, null);\r
if (result.isOk()){\r
Assert.fail("Delete should throw an exception because of the determination event");\r
}\r
assertEquals(0, child1.getTaxonNodes().size());\r
// try {\r
\r
- result = service.deleteTaxon(child1, config, null);\r
+ result = service.deleteTaxon(child1.getUuid(), config, null);\r
\r
if (!result.isOk()){\r
Assert.fail("Delete should not throw an exception anymore");\r
Taxon child2 =(Taxon) service.find(TaxonGenerator.SPECIES2_UUID);\r
\r
// try {\r
- result = service.deleteTaxon(child2, config, null);\r
+ result = service.deleteTaxon(child2.getUuid(), config, null);\r
if (!result.isOk()){\r
Assert.fail("Delete should not throw an exception");\r
}\r
\r
\r
// try {\r
- DeleteResult result = service.deleteTaxon(speciesTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(speciesTaxon.getUuid(), config, null);\r
if (!result.isOk()){\r
Assert.fail();\r
}\r
config.setDeleteNameIfPossible(true);\r
Taxon newTaxon = Taxon.NewInstance(BotanicalName.NewInstance(Rank.SPECIES()), null);\r
service.save(newTaxon);\r
- result = service.deleteTaxon(newTaxon, config, null);\r
+ result = service.deleteTaxon(newTaxon.getUuid()\r
+ , config, null);\r
if (!result.isOk()){\r
Assert.fail();\r
}\r
config.setDeleteSynonymsIfPossible(false);\r
\r
\r
- DeleteResult result = service.deleteTaxon(speciesTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(speciesTaxon.getUuid(), config, null);\r
if (!result.isOk()){\r
Assert.fail();\r
}\r
\r
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();\r
config.setDeleteNameIfPossible(true);\r
- DeleteResult result = service.deleteTaxon(speciesTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(speciesTaxon.getUuid(), config, null);\r
if (!result.isOk()){\r
Assert.fail();\r
}\r
secondClassification.addChildTaxon(testTaxon, null, null);\r
//delete the taxon in all classifications\r
//try {\r
- DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, null);\r
if (!result.isOk()){\r
Assert.fail();\r
}\r
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
config.setDeleteInAllClassifications(false);\r
// try {\r
- DeleteResult result = service.deleteTaxon(testTaxon, config, secondClassification);\r
+ DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, secondClassification.getUuid());\r
/* Assert.fail("The taxon should not be deletable because it is used in a second classification and the configuration is set to deleteInAllClassifications = false");\r
} catch (DataChangeNoRollbackException e) {\r
logger.debug(e.getMessage());\r
config.getTaxonNodeConfig().setChildHandling(ChildHandling.MOVE_TO_PARENT);\r
\r
\r
- DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, null);\r
if(!result.isOk()){\r
Assert.fail();\r
}\r
config.getTaxonNodeConfig().setChildHandling(ChildHandling.DELETE);\r
\r
// try {\r
- DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, null);\r
if(!result.isOk()){\r
Assert.fail();\r
}\r
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
config.getTaxonNodeConfig().setChildHandling(ChildHandling.DELETE);\r
\r
- DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, null);\r
\r
if(!result.isOk()){\r
Assert.fail();\r
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
config.setDeleteMisappliedNamesAndInvalidDesignations(true);\r
\r
- DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, null);\r
if(!result.isOk()){\r
Assert.fail();\r
}\r
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
config.setDeleteMisappliedNamesAndInvalidDesignations(false);\r
\r
- DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, null);\r
if(!result.isOk()){\r
Assert.fail();\r
}\r
\r
\r
// try {\r
- service.deleteTaxon(misappliedNameTaxon, config, null);\r
+ service.deleteTaxon(misappliedNameTaxon.getUuid(), config, null);\r
// } catch (DataChangeNoRollbackException e) {\r
// e.printStackTrace();\r
\r
private INameService nameService;\r
@SpringBeanByType\r
private ICdmMassIndexer indexer;\r
+ \r
+ @SpringBeanByType\r
+ private ITaxonNodeService nodeService;\r
\r
private static final int BENCHMARK_ROUNDS = 300;\r
\r
Assert.assertEquals("expecting Abies balsamea sec.", childNode.getTaxon().getUuid().toString(), ABIES_BALSAMEA_UUID);\r
Assert.assertEquals("expecting default classification", childNode.getClassification().getUuid().toString(), CLASSIFICATION_UUID);\r
\r
- // moving the taxon around\r
+ // moving the taxon around, the rootnode is only a proxy\r
+ alternateClassification.setRootNode(HibernateProxyHelper.deproxy(alternateClassification.getRootNode(), TaxonNode.class));\r
alternateClassification.addChildNode(childNode, null, null);\r
+ \r
classificationService.saveOrUpdate(alternateClassification);\r
commitAndStartNewTransaction(null);\r
\r
ITaxonService taxonService = appCtr.getTaxonService();\r
Taxon taxon = node.getTaxon();\r
//try {\r
- taxonService.deleteTaxon(taxon, new TaxonDeletionConfigurator(), node.getClassification());\r
+ taxonService.deleteTaxon(taxon.getUuid(), new TaxonDeletionConfigurator(), node.getClassification().getUuid());\r
\r
/*} catch (DataChangeNoRollbackException e) {\r
e.printStackTrace();\r
logger.info("Remove taxon ...");\r
UUID uuid = null;\r
\r
- DeleteResult result = taxonService.deleteTaxon(taxon1, null, null);\r
+ DeleteResult result = taxonService.deleteTaxon(taxon1.getUuid(), null, null);\r
\r
if(!result.isOk()){ \r
Assert.fail();\r
BGBM BDI Projects / cdmlib.git / commitdiff