}else if(taxonBase instanceof Synonym){
Synonym synonym = (Synonym) taxonBase;
- Set<Taxon> taxa = synonym.getAcceptedTaxa();
+ Set<Taxon> taxa = new HashSet<>();
+ Taxon taxon = synonym.getAcceptedTaxon();
+ if (taxon != null){
+ taxa.add(taxon);
+ }
setInputForMultipleTaxa(conversation, taxa);
}
}
package eu.etaxonomy.taxeditor.editor.name.dnd;
import org.eclipse.core.runtime.Assert;
-import org.eclipse.swt.SWTException;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTargetAdapter;
import org.eclipse.swt.dnd.DropTargetEvent;
import eu.etaxonomy.cdm.model.common.ICdmBase;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
-import eu.etaxonomy.cdm.model.reference.Reference;
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.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.taxeditor.editor.IDropTargetable;
import eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor;
import eu.etaxonomy.taxeditor.editor.name.container.AbstractHomotypicalGroupContainer;
-import eu.etaxonomy.taxeditor.editor.name.container.HomotypicalSynonymGroup;
import eu.etaxonomy.taxeditor.editor.name.container.MisappliedGroup;
import eu.etaxonomy.taxeditor.editor.name.operation.ChangeConceptRelationshipTypeOperation;
import eu.etaxonomy.taxeditor.editor.name.operation.ChangeConceptToSynonymOperation;
package eu.etaxonomy.taxeditor.editor.name.handler;
-import java.util.Set;
-
import org.eclipse.core.expressions.PropertyTester;
import org.eclipse.jface.viewers.IStructuredSelection;
public NameEditorMenuPropertyTester() {
}
- /* (non-Javadoc)
- * @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)
- */
/** {@inheritDoc} */
@Override
public boolean test(Object receiver, String property, Object[] args,
private boolean isNotHomotypicSynonymOfAcceptedTaxon(Object selectedElement) {
if (isSynonym(selectedElement)){
Synonym synonym = (Synonym) selectedElement;
- for (Taxon taxon:synonym.getAcceptedTaxa()){
- if (taxon.getHomotypicGroup().equals(synonym.getHomotypicGroup())){
- return false;
- }
+ Taxon taxon = synonym.getAcceptedTaxon();
+ if (taxon != null &&
+ taxon.getHomotypicGroup().equals(synonym.getHomotypicGroup())){
+ return false;
}
}
return true;
return ((Taxon) selectedElement).isOrphaned();
}
else if(selectedElement instanceof Synonym){
- Set<Taxon> acceptedTaxa = ((Synonym) selectedElement).getAcceptedTaxa();
- for (Taxon taxon : acceptedTaxa) {
- if(!taxon.isOrphaned()){
- return false;
- }
- }
+ return ((Synonym) selectedElement).isOrphaned();
}
return false;
}
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.taxon.Synonym;
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
private TaxonRelationship taxonRelationship;
private TaxonRelationshipType oldRelationshipType;
- private SynonymRelationship newSynonymRelationship;
-
/**
* <p>Constructor for ChangeConceptToSynonymOperation.</p>
*
this.homotypicalGroup = homotypicalGroup != null ? homotypicalGroup : HomotypicalGroup.NewInstance();
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info)
return postExecute(synonym);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus redo(IProgressMonitor monitor, IAdaptable info)
return null;
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
*
* @author n.hoffmann
* @created 19.01.2009
- * @version 1.0
*/
public class ChangeHomotypicGroupOperation extends AbstractPostTaxonOperation {
this.newHomotypicalGroup = newHomotypicalGroup != null ? newHomotypicalGroup : HomotypicalGroup.NewInstance();
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info)
monitor.worked(40);
newHomotypicalGroup = HibernateProxyHelper.deproxy(newHomotypicalGroup, HomotypicalGroup.class);
newHomotypicalGroup.addTypifiedName(synonymName);
-
- if(! synonym.getAcceptedTaxa().contains(element)){
- for(Taxon acceptedTaxon : synonym.getAcceptedTaxa()){
- acceptedTaxon.removeSynonym(synonym);
+
+ Taxon acc = synonym.getAcceptedTaxon();
+ if(acc == null || !acc.equals(element)){
+ if(acc != null){
+ acc.removeSynonym(synonym);
}
-
+
SynonymRelationshipType type = SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF();
if(newHomotypicalGroup.getTypifiedNames().contains(element.getName())){
type = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF();
return postExecute(synonym);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus redo(IProgressMonitor monitor, IAdaptable info)
return execute(monitor, info);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
//this.namesInHomotypicGroup = namesInHomotypicalGroup;
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
+
/** {@inheritDoc} */
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info)
newNode = (TaxonNode) CdmStore.getService(ITaxonService.class).changeSynonymToAcceptedTaxon(synonym.getUuid(),
element.getUuid(),
parentNode.getUuid(),
- true,
- true,
- null,
- null).getCdmEntity();
+ true).getCdmEntity();
} catch (HomotypicalGroupChangeException e) {
MessagingUtils.warningDialog("Operation may lead to inconsistent data", getClass(), e.getMessage());
return postExecute(null);
return postExecute(newNode);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus redo(IProgressMonitor monitor, IAdaptable info)
return execute(monitor, info);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.NonViralName;
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
+import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
*
* @author n.hoffmann
* @created 02.02.2009
- * @version 1.0
*/
public class CreateSynonymInExistingHomotypicalGroupOperation extends
AbstractPostTaxonOperation {
private final HomotypicalGroup group;
private final NonViralName newSynonymName;
- private SynonymRelationship synonymRelationship;
+ private Synonym synonym;
/**
* <p>Constructor for CreateSynonymInExistingHomotypicalGroupOperation.</p>
this.newSynonymName = newSynonymName;
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info)
// Create a new synonym for the taxon
// TODO add citations
if(group.equals(element.getHomotypicGroup())){
- synonymRelationship = element.addHomotypicSynonymName(newSynonymName, null, null);
+ synonym = element.addHomotypicSynonymName(newSynonymName);
}else{
- synonymRelationship = element.addHeterotypicSynonymName(newSynonymName);
+ synonym = element.addHeterotypicSynonymName(newSynonymName);
}
monitor.worked(40);
// }
// }
- return postExecute(synonymRelationship.getSynonym());
+ return postExecute(synonym);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus redo(IProgressMonitor monitor, IAdaptable info)
return execute(monitor, info);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
- element.removeSynonymRelation(synonymRelationship);
+ element.removeSynonym(synonym);
return postExecute(null);
}
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
+import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
* @author p.ciardelli
* @author n.hoffmann
* @created 16.01.2009
- * @version 1.0
*/
public class CreateSynonymInNewGroupOperation extends AbstractPostTaxonOperation {
- // TODO replace this with TaxonNameBase
private final TaxonNameBase newSynonymName;
- private SynonymRelationship newSynonymRelationship;
+ private Synonym newSynonym;
/**
* <p>Constructor for CreateSynonymInNewGroupOperation.</p>
this.newSynonymName = newSynonymName;
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info)
monitor.worked(20);
HibernateProxyHelper.deproxy(element);
// Create a new synonym for the taxon
- newSynonymRelationship = element.addHeterotypicSynonymName(newSynonymName);
+ newSynonym = element.addHeterotypicSynonymName(newSynonymName);
monitor.worked(40);
- return postExecute(newSynonymRelationship.getSynonym());
+ return postExecute(newSynonym);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus redo(IProgressMonitor monitor, IAdaptable info)
return execute(monitor, info);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
// Remove the synonym
- element.removeSynonymRelation(newSynonymRelationship);
- newSynonymRelationship = null;
+ element.removeSynonym(newSynonym);
+ newSynonym = null;
return postExecute(null);
}
*
* @author p.ciardelli
* @created 14.01.2009
- * @version 1.0
*/
public class DeleteSynonymOperation extends AbstractPostTaxonOperation {
private final Synonym synonym;
- private Set<SynonymRelationshipType> synonymTypes;
+ private SynonymRelationshipType synonymType;
/**
* <p>Constructor for DeleteSynonymOperation.</p>
this.synonym = synonym;
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus execute(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
// Store synonymRelationshipType for later undo operations
- synonymTypes = synonym.getRelationType(element);
- monitor.worked(20);
-
- // Remove synonym from taxon
-
- ICdmApplicationConfiguration controller;
-
- controller = CdmStore.getCurrentApplicationConfiguration();
-
- ITaxonService service = controller.getTaxonService();
- if (synonym.getId() == 0){
- element.removeSynonym(synonym);
-
- } else {
-//TODO: this should be moved to the handler, the operations should not contain ui code
- DeleteResult result = service.deleteSynonym(synonym.getUuid(), element.getUuid(), null);
- if (result.isError()){
- DeleteResultMessagingUtils.messageDialogWithDetails(result, "Delete failed", TaxeditorEditorPlugin.PLUGIN_ID);
- } else if (!result.getUpdatedObjects().isEmpty()){
- DeleteResultMessagingUtils.messageDialogWithDetails(result, "The Synonym could be deleted, but related object(s) could not be deleted", TaxeditorEditorPlugin.PLUGIN_ID);
- }
- }
- // taxon.removeSynonym(synonym);
+ synonymType = synonym.getType();
+ monitor.worked(20);
+
+ // Remove synonym from taxon
+ ICdmApplicationConfiguration controller;
+
+ controller = CdmStore.getCurrentApplicationConfiguration();
+
+ ITaxonService service = controller.getTaxonService();
+ if (synonym.getId() == 0){
+ element.removeSynonym(synonym);
+
+ } else {
+ //TODO: this should be moved to the handler, the operations should not contain ui code
+ DeleteResult result = service.deleteSynonym(synonym.getUuid(), null);
+ if (result.isError()){
+ DeleteResultMessagingUtils.messageDialogWithDetails(result, "Delete failed", TaxeditorEditorPlugin.PLUGIN_ID);
+ } else if (!result.getUpdatedObjects().isEmpty()){
+ DeleteResultMessagingUtils.messageDialogWithDetails(result, "The Synonym could be deleted, but related object(s) could not be deleted", TaxeditorEditorPlugin.PLUGIN_ID);
+ }
+ }
+ // taxon.removeSynonym(synonym);
// CdmStore.getTaxonService().deleteSynonymRelationships(synonym);
// CdmStore.getTaxonService().delete(synonym);
- monitor.worked(40);
+ monitor.worked(40);
- // Redraw editor if exists
+ // Redraw editor if exists
- return postExecute(element);
+ return postExecute(element);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus redo(IProgressMonitor monitor, IAdaptable info)
return execute(monitor, info);
}
- /* (non-Javadoc)
- * @see org.eclipse.core.commands.operations.AbstractOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
- */
/** {@inheritDoc} */
@Override
public IStatus undo(IProgressMonitor monitor, IAdaptable info)
throws ExecutionException {
// Add synonym to taxon
- for (SynonymRelationshipType synonymType : synonymTypes){
- element.addSynonym(synonym, synonymType);
- }
+ element.addSynonym(synonym, synonymType);
// Redraw editor if exists
return postExecute(synonym);
import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.taxon.Synonym;\r
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.taxeditor.editor.EditorUtil;\r
import eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor;\r
TaxonNameBase<?, ?> synonymName = synonym.getName();\r
monitor.worked(20);\r
\r
-\r
-\r
// Switch groups\r
\r
monitor.worked(40);\r
- SynonymRelationship synRel = synonym.getSynonymRelations().iterator().next();\r
-\r
-\r
\r
((TaxonNameEditor)EditorUtil.getActiveMultiPageTaxonEditor().getActiveEditor()).getConversationHolder().commit();\r
UpdateResult result;\r
\r
-\r
try {\r
- result = CdmStore.getService(ITaxonService.class).moveSynonymToAnotherTaxon(synRel,\r
+ result = CdmStore.getService(ITaxonService.class).moveSynonymToAnotherTaxon(synonym,\r
this.element.getUuid(),\r
true,\r
- synRel.getType(),\r
+ synonym.getType(),\r
null,\r
null,\r
true);\r
}\r
((TaxonNameEditor)EditorUtil.getActiveMultiPageTaxonEditor().getActiveEditor()).getConversationHolder().commit();\r
\r
-\r
-\r
// Redraw editor if it exists\r
- return postExecute(synRel.getSynonym());\r
+ return postExecute(synonym);\r
}\r
\r
@Override\r
Assert.assertTrue("Taxon should have synonyms.", taxon.getSynonyms().size() > 0);
Assert.assertTrue("Taxon should not have taxon relationship.", taxon.getTaxonRelations().size() == 0);
Assert.assertEquals("Not the expected synonym.", synonym, taxon.getSynonyms().toArray(new Synonym[0])[0]);
- Assert.assertEquals("SynonymRelationshipType is not the expected.", synonymRelationshipType, taxon.getSynonyms().toArray(new Synonym[0])[0].getRelationType(taxon));
+ Assert.assertEquals("SynonymRelationshipType is not the expected.", synonymRelationshipType, taxon.getSynonyms().iterator().next().getType());
}
/**
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.NonViralName;
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.taxeditor.store.operations.AbstractTaxeditorOperationTestBase;
Assert.assertTrue("Taxon should have a synonym now.", taxon.getSynonyms().size() > 0);
Assert.assertTrue("Taxon should have a homotypic group", taxon.getHomotypicSynonymyGroups().size() > 0);
- Assert.assertEquals("Synonym relationship should be heterotypic", SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), taxon.getSynonymRelations().toArray(new SynonymRelationship[0])[0].getType());
+ Assert.assertEquals("Synonym relationship should be heterotypic", SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), taxon.getSynonyms().iterator().next().getType());
}
Assert.assertTrue("Taxon should have a synonym now.", taxon.getSynonyms().size() > 0);
Assert.assertTrue("Taxon should have a homotypic group", taxon.getHomotypicSynonymyGroups().size() > 0);
- Assert.assertEquals("Synonym relationship should be heterotypic", SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), taxon.getSynonymRelations().toArray(new SynonymRelationship[0])[0].getType());
+ Assert.assertEquals("Synonym relationship should be heterotypic", SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), taxon.getSynonyms().iterator().next().getType());
}
}
// childTaxon.setTaxonomicParent(taxon, null, null);
// Create a homotypic synonym for the accepted taxon
- taxon.addHomotypicSynonymName(NonViralName.NewInstance(null), null, null);
+ taxon.addHomotypicSynonymName(NonViralName.NewInstance(null));
// homotypicSynonym = Synonym.NewInstance(NonViralName.NewInstance(null), null);
// HomotypicalGroup acceptedHomotypicalGroup = HomotypicalGroup.NewInstance();
// acceptedHomotypicalGroup.addTypifiedName(oldTaxon.getName());
package eu.etaxonomy.taxeditor.navigation;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
}else if(selection instanceof Synonym){
Synonym synonym = (Synonym) selection;
- handleOpeningOfMultipleTaxa(synonym.getAcceptedTaxa());
+ Set<Taxon> accTaxa = new HashSet<Taxon>();
+ if (synonym.getAcceptedTaxon() != null){
+ accTaxa.add(synonym.getAcceptedTaxon());
+ }
+ handleOpeningOfMultipleTaxa(accTaxa);
}else{
MessagingUtils.warningDialog("Not implemented yet", NavigationUtil.class, "You chose to open a name that has no connection to a taxon. The Editor does not support editing of such a content type at the moment.");
BGBM BDI Projects / taxeditor.git / commitdiff