From e00608f5d4302fd1a7bc33eb483190c3ac74d151 Mon Sep 17 00:00:00 2001 From: "p.ciardelli" Date: Tue, 11 Aug 2009 15:31:26 +0000 Subject: [PATCH] . --- .../ChangeAcceptedTaxonToSynonymHandler.java | 247 +++++++++++++++++- .../handler/FilteredTaxonSelectionDialog.java | 177 +++++++++++-- .../SwapSynonymAndAcceptedHandler.java | 2 +- 3 files changed, 387 insertions(+), 39 deletions(-) diff --git a/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/ChangeAcceptedTaxonToSynonymHandler.java b/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/ChangeAcceptedTaxonToSynonymHandler.java index 0b88c1380..11e4bce75 100644 --- a/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/ChangeAcceptedTaxonToSynonymHandler.java +++ b/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/ChangeAcceptedTaxonToSynonymHandler.java @@ -3,21 +3,35 @@ */ package eu.etaxonomy.taxeditor.editor.name.handler; +import java.util.HashSet; +import java.util.Set; +import java.util.UUID; + +import org.apache.log4j.Logger; import org.eclipse.core.commands.AbstractHandler; import org.eclipse.core.commands.ExecutionEvent; import org.eclipse.core.commands.ExecutionException; import org.eclipse.core.commands.IHandler; +import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.ui.IEditorPart; import org.eclipse.ui.PartInitException; import org.eclipse.ui.handlers.HandlerUtil; +import eu.etaxonomy.cdm.api.conversation.ConversationHolder; +import eu.etaxonomy.cdm.model.description.TaxonDescription; +import eu.etaxonomy.cdm.model.name.TaxonNameBase; +import eu.etaxonomy.cdm.model.reference.ReferenceBase; +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.TaxonNode; +import eu.etaxonomy.cdm.model.taxon.TaxonRelationship; +import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType; import eu.etaxonomy.taxeditor.editor.EditorUtil; -import eu.etaxonomy.taxeditor.editor.Page; -import eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor; import eu.etaxonomy.taxeditor.propertysheet.name.TaxonBasePropertySource; +import eu.etaxonomy.taxeditor.store.CdmStore; /** * @author p.ciardelli @@ -25,6 +39,8 @@ import eu.etaxonomy.taxeditor.propertysheet.name.TaxonBasePropertySource; */ public class ChangeAcceptedTaxonToSynonymHandler extends AbstractHandler implements IHandler { + private static final Logger logger = Logger + .getLogger(ChangeAcceptedTaxonToSynonymHandler.class); /* (non-Javadoc) * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent) @@ -35,24 +51,58 @@ public class ChangeAcceptedTaxonToSynonymHandler extends AbstractHandler // "Not yet implemented", // "'Change Accepted Taxon to Synonym' not yet implemented."); - TaxonNameEditor editor = (TaxonNameEditor) EditorUtil.getActiveEditorPage( - Page.NAME); ISelection menuSelection = HandlerUtil.getActiveMenuSelection(event); - - - TaxonBasePropertySource taxonBasePropertySource = (TaxonBasePropertySource) ((StructuredSelection) menuSelection).getFirstElement(); - Taxon taxon = (Taxon) taxonBasePropertySource.getTaxonBase(); - - Taxon newAcceptedTaxon = FilteredTaxonSelectionDialog.getTaxon(HandlerUtil.getActiveShell(event), taxon); -// TaxonNameBase newTaxonName = FilteredNameSelectionDialog.getName(HandlerUtil.getActiveShell(event), taxon.getName()); + Taxon oldAcceptedTaxon = (Taxon) taxonBasePropertySource.getTaxonBase(); + // Choose new accepted taxon + Taxon newAcceptedTaxon = FilteredTaxonSelectionDialog.getTaxon(HandlerUtil.getActiveShell(event), oldAcceptedTaxon); + + if (newAcceptedTaxon == null) { + return null; + } -// IEditorInput input = TaxonEditorInput.NewInstance(newAcceptedTaxon.getUuid()); try { - TaxonNode taxonNode = newAcceptedTaxon.getTaxonNodes().iterator().next(); - EditorUtil.open(taxonNode.getUuid()); + ConversationHolder conversation = CdmStore.NewTransactionalConversation(); + conversation.bind(); + Taxon newTaxon = (Taxon) CdmStore.getTaxonService().getTaxonByUuid(newAcceptedTaxon.getUuid()); + Taxon oldTaxon = (Taxon) CdmStore.getTaxonService().getTaxonByUuid(oldAcceptedTaxon.getUuid()); + + // Check for multiple nodes + if (newTaxon.getTaxonNodes().size() > 1 || oldTaxon.getTaxonNodes().size() > 1) { + MessageDialog.openInformation(HandlerUtil.getActiveShell(event), + "Taxon implemented in multiple trees", + "One or both of these taxa is implemented in multiple taxonomic trees."); + return null; + } + + // Close editor + IEditorPart editor = HandlerUtil.getActiveEditor(event); + boolean proceed = HandlerUtil.getActiveWorkbenchWindowChecked(event).getActivePage(). + closeEditor(editor, true); + if (!proceed) { + return null; + } + + makeTaxonSynonym(oldTaxon, newTaxon, null, null, null); + + // TEMP +// Set descriptions = new HashSet(); +// for(TaxonDescription taxDescription : oldTaxon.getDescriptions()){ +// descriptions.add(taxDescription); +// } +// for(TaxonDescription taxDescription : descriptions){ +// newTaxon.addDescription(taxDescription); +// } + +// CdmStore.getTaxonService().makeTaxonSynonym(oldTaxon, newTaxon, null, null, null); + conversation.commit(); + Set nodes = newTaxon.getTaxonNodes(); + UUID uuid = nodes.iterator().next().getUuid(); + + EditorUtil.open(uuid); + } catch (PartInitException e) { // TODO Auto-generated catch block e.printStackTrace(); @@ -60,4 +110,173 @@ public class ChangeAcceptedTaxonToSynonymHandler extends AbstractHandler return null; } + + /** + * @param oldTaxon + * @param newTaxon + */ + private void makeTaxonSynonym(Taxon oldTaxon, Taxon newAcceptedTaxon, SynonymRelationshipType synonymType, ReferenceBase citation, String citationMicroReference) { + if (oldTaxon == null || newAcceptedTaxon == null || oldTaxon.getName() == null){ + return; + } + + // Move oldTaxon to newTaxon + TaxonNameBase synonymName = oldTaxon.getName(); + if (synonymType == null){ + if (synonymName.isHomotypic(newAcceptedTaxon.getName())){ + synonymType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF(); + }else{ + //TODO synonymType + synonymType = SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(); + } + } + SynonymRelationship synRel = newAcceptedTaxon.addSynonymName(synonymName, synonymType, citation, citationMicroReference); + + //Move Synonym Relations to new Taxon + for(SynonymRelationship synRelation : oldTaxon.getSynonymRelations()){ + synRelation.setAcceptedTaxon(newAcceptedTaxon); +// newAcceptedTaxon.addSynonym(synRelation.getSynonym(), synRelation.getType(), +// synRelation.getCitation(), synRelation.getCitationMicroReference()); + } + + //Move Taxon RelationShips to new Taxon + Set removableTaxonRels = new HashSet(); + for(TaxonRelationship taxonRelation : oldTaxon.getTaxonRelations()){ + //CHILDREN + if (taxonRelation.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())){ + if (taxonRelation.getFromTaxon() == oldTaxon){ + taxonRelation.setFromTaxon(newAcceptedTaxon); +// removableTaxonRels.add(taxonRelation); + }else if(taxonRelation.getToTaxon() == oldTaxon){ + taxonRelation.setToTaxon(newAcceptedTaxon); +// newAcceptedTaxon.addTaxonomicChild(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference()); +// removableTaxonRels.add(taxonRelation); + }else{ + logger.warn("Taxon is not part of its own Taxonrelationship"); + } + } + //MISAPPLIED NAMES + if (taxonRelation.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR())){ + if (taxonRelation.getFromTaxon() == oldTaxon){ + taxonRelation.setFromTaxon(newAcceptedTaxon); +// newAcceptedTaxon.addMisappliedName(taxonRelation.getToTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference()); +// removableTaxonRels.add(taxonRelation); + }else if(taxonRelation.getToTaxon() == oldTaxon){ + taxonRelation.setToTaxon(newAcceptedTaxon); +// newAcceptedTaxon.addMisappliedName(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference()); +// removableTaxonRels.add(taxonRelation); + }else{ + logger.warn("Taxon is not part of its own Taxonrelationship"); + } + } + //Concept Relationships + //FIXME implement + } + +// for(TaxonRelationship taxonRel : removableTaxonRels) { +// oldTaxon.removeTaxonRelation(taxonRel); +// } + + //Move Descriptions to new Taxon + Set descriptions = new HashSet(); + for(TaxonDescription taxDescription : oldTaxon.getDescriptions()){ + descriptions.add(taxDescription); + } + for(TaxonDescription taxDescription : descriptions){ + newAcceptedTaxon.addDescription(taxDescription); + } + + CdmStore.getTaxonService().saveTaxon(newAcceptedTaxon); + oldTaxon.getTaxonNodes().iterator().next().remove(); + CdmStore.getTaxonService().removeTaxon(oldTaxon); + } + +// /** +// * @param oldTaxon +// * @param newTaxon +// */ +// private void makeTaxonSynonym(Taxon oldTaxon, Taxon newAcceptedTaxon, SynonymRelationshipType synonymType, ReferenceBase citation, String citationMicroReference) { +// if (oldTaxon == null || newAcceptedTaxon == null || oldTaxon.getName() == null){ +// return; +// } +// +// // Move oldTaxon to newTaxon +// TaxonNameBase synonymName = oldTaxon.getName(); +// if (synonymType == null){ +// if (synonymName.isHomotypic(newAcceptedTaxon.getName())){ +// synonymType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF(); +// }else{ +// //TODO synonymType +// synonymType = SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(); +// } +// } +// SynonymRelationship synRel = newAcceptedTaxon.addSynonymName(synonymName, synonymType, citation, citationMicroReference); +// +// //Move Synonym Relations to new Taxon +// for(SynonymRelationship synRelation : oldTaxon.getSynonymRelations()){ +// newAcceptedTaxon.addSynonym(synRelation.getSynonym(), synRelation.getType(), +// synRelation.getCitation(), synRelation.getCitationMicroReference()); +// } +// +// //Move Taxon RelationShips to new Taxon +// Set removableTaxonRels = new HashSet(); +// for(TaxonRelationship taxonRelation : oldTaxon.getTaxonRelations()){ +// //CHILDREN +// if (taxonRelation.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())){ +// if (taxonRelation.getFromTaxon() == oldTaxon){ +// removableTaxonRels.add(taxonRelation); +//// oldTaxon.removeTaxonRelation(taxonRelation); +// }else if(taxonRelation.getToTaxon() == oldTaxon){ +// newAcceptedTaxon.addTaxonomicChild(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference()); +// removableTaxonRels.add(taxonRelation); +//// oldTaxon.removeTaxonRelation(taxonRelation); +// }else{ +// logger.warn("Taxon is not part of its own Taxonrelationship"); +// } +// } +// //MISAPPLIED NAMES +// if (taxonRelation.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR())){ +// if (taxonRelation.getFromTaxon() == oldTaxon){ +// newAcceptedTaxon.addMisappliedName(taxonRelation.getToTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference()); +// removableTaxonRels.add(taxonRelation); +//// oldTaxon.removeTaxonRelation(taxonRelation); +// }else if(taxonRelation.getToTaxon() == oldTaxon){ +// newAcceptedTaxon.addMisappliedName(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference()); +// removableTaxonRels.add(taxonRelation); +//// oldTaxon.removeTaxonRelation(taxonRelation); +// }else{ +// logger.warn("Taxon is not part of its own Taxonrelationship"); +// } +// } +// //Concept Relationships +// //FIXME implement +//// if (taxonRelation.getType().equals(TaxonRelationshipType.MISAPPLIEDNAMEFOR())){ +//// if (taxonRelation.getFromTaxon() == oldTaxon){ +//// newAcceptedTaxon.addMisappliedName(taxonRelation.getToTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference()); +//// removableTaxonRels.add(taxonRelation); +//// }else if(taxonRelation.getToTaxon() == oldTaxon){ +//// newAcceptedTaxon.addMisappliedName(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference()); +//// removableTaxonRels.add(taxonRelation); +//// }else{ +//// logger.warn("Taxon is not part of its own Taxonrelationship"); +//// } +//// } +// } +// +// for(TaxonRelationship taxonRel : removableTaxonRels) { +// oldTaxon.removeTaxonRelation(taxonRel); +// } +// +// //Move Descriptions to new Taxon +// Set descriptions = new HashSet(); +// for(TaxonDescription taxDescription : oldTaxon.getDescriptions()){ +// descriptions.add(taxDescription); +// } +// for(TaxonDescription taxDescription : descriptions){ +// newAcceptedTaxon.addDescription(taxDescription); +// } +// +// CdmStore.getTaxonService().saveTaxon(newAcceptedTaxon); +//// CdmStore.getTaxonService().removeTaxon(oldTaxon); +// } } \ No newline at end of file diff --git a/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/FilteredTaxonSelectionDialog.java b/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/FilteredTaxonSelectionDialog.java index a26c70fbd..07b2a0894 100644 --- a/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/FilteredTaxonSelectionDialog.java +++ b/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/FilteredTaxonSelectionDialog.java @@ -3,34 +3,52 @@ */ package eu.etaxonomy.taxeditor.editor.name.handler; -import java.util.List; +import java.text.Collator; +import java.util.Comparator; +import java.util.Map; +import java.util.UUID; import org.apache.log4j.Logger; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.jface.dialogs.IDialogSettings; +import org.eclipse.jface.viewers.ILabelProvider; +import org.eclipse.jface.viewers.LabelProvider; import org.eclipse.jface.window.Window; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Shell; +import org.eclipse.ui.dialogs.FilteredItemsSelectionDialog; -import eu.etaxonomy.cdm.model.name.TaxonNameBase; import eu.etaxonomy.cdm.model.taxon.Taxon; -import eu.etaxonomy.taxeditor.dialogs.FilteredCdmResourceSelectionDialog; import eu.etaxonomy.taxeditor.store.CdmStore; +import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin; /** * @author p.ciardelli * */ -public class FilteredTaxonSelectionDialog extends FilteredCdmResourceSelectionDialog { +//public class FilteredTaxonSelectionDialog extends FilteredCdmResourceSelectionDialog { +/** + * @author p.ciardelli + * + */ +public class FilteredTaxonSelectionDialog extends FilteredItemsSelectionDialog { + private static final Logger logger = Logger .getLogger(FilteredTaxonSelectionDialog.class); + public static final String SETTINGS = FilteredTaxonSelectionDialog.class.getCanonicalName(); + /** * @param taxon * @return */ public static Taxon getTaxon(Shell shell, Taxon excludeTaxon) { FilteredTaxonSelectionDialog dialog = new FilteredTaxonSelectionDialog(shell, - "Choose a taxon"); + "Choose a taxon", false); if (dialog.open() == Window.CANCEL) { return null; } @@ -38,23 +56,29 @@ public class FilteredTaxonSelectionDialog extends FilteredCdmResourceSelectionDi } private Taxon taxon; + private Map allTaxonBases; /** * @param shell * @param title */ - public FilteredTaxonSelectionDialog(Shell shell, String title) { - super(shell, title); - setMessage("Choose your shit here, bro"); - } - - /* (non-Javadoc) - * @see eu.etaxonomy.taxeditor.dialogs.FilteredCdmResourceSelectionDialog#getSettings() - */ - @Override - public String getSettings() { - // TODO Auto-generated method stub - return null; + public FilteredTaxonSelectionDialog(Shell shell, String title, boolean multi) { + super(shell, multi); + setTitle(title); + setMessage("Choose"); + + ILabelProvider labelProvider = new LabelProvider() { + public String getText(Object element) { + if (element == null) { + return null; + } + return ((TaxonUuidAndTitleCache) element).getTitleCache(); + } + }; + setListLabelProvider(labelProvider); + setDetailsLabelProvider(labelProvider); + + allTaxonBases = CdmStore.getTaxonService().getUuidAndTitleCacheOfAcceptedTaxa(); } /* (non-Javadoc) @@ -64,13 +88,10 @@ public class FilteredTaxonSelectionDialog extends FilteredCdmResourceSelectionDi protected void fillContentProvider(AbstractContentProvider contentProvider, ItemsFilter itemsFilter, IProgressMonitor progressMonitor) throws CoreException { - progressMonitor.beginTask("Looking for taxa", 1000); - List allTaxonBases = CdmStore.searchTaxaByName("*"+itemsFilter.getPattern()+"*"); - for (Object obj : allTaxonBases){ - if (obj instanceof Taxon) { - contentProvider.add((Taxon) obj, itemsFilter); - } - progressMonitor.worked(1); + progressMonitor.beginTask("Looking for taxa", 1000); // Why no progres monitor? + for (UUID uuid : allTaxonBases.keySet()) { + TaxonUuidAndTitleCache taxon = new TaxonUuidAndTitleCache(uuid, allTaxonBases.get(uuid)); + contentProvider.add(taxon, itemsFilter); } } @@ -81,4 +102,112 @@ public class FilteredTaxonSelectionDialog extends FilteredCdmResourceSelectionDi Object[] result = getResult(); return result[0] == null ? null : (Taxon) result[0]; } + + /* (non-Javadoc) + * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#createExtendedContentArea(org.eclipse.swt.widgets.Composite) + */ + @Override + protected Control createExtendedContentArea(Composite parent) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#createFilter() + */ + @Override + protected ItemsFilter createFilter() { + return new ItemsFilter() { + + @Override + public boolean isConsistentItem(Object item) { + return false; + } + + @Override + public boolean matchItem(Object item) { + return matches(((TaxonUuidAndTitleCache) item).titleCache); + } + + }; + } + + /* (non-Javadoc) + * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#getDialogSettings() + */ + @Override + protected IDialogSettings getDialogSettings() { + IDialogSettings settings = TaxeditorStorePlugin.getDefault().getDialogSettings().getSection(getSettings()); + + if (settings == null) { + settings = TaxeditorStorePlugin.getDefault().getDialogSettings().addNewSection(getSettings()); + } + return settings; + } + + /* (non-Javadoc) + * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#getElementName(java.lang.Object) + */ + @Override + public String getElementName(Object item) { + return ((TaxonUuidAndTitleCache) item).getTitleCache(); + } + + /* (non-Javadoc) + * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#getItemsComparator() + */ + @Override + protected Comparator getItemsComparator() { + return new Comparator() { + public int compare(TaxonUuidAndTitleCache entity1, + TaxonUuidAndTitleCache entity2) { + Collator collator = Collator.getInstance(); + return collator.compare(entity1.getTitleCache(), entity2.getTitleCache()); + } + }; + } + + /* (non-Javadoc) + * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#validateItem(java.lang.Object) + */ + @Override + protected IStatus validateItem(Object item) { + return Status.OK_STATUS; + } + + protected void restoreDialog(IDialogSettings settings) { + + } + + public String getSettings() { + if(SETTINGS == null){ + throw new IllegalStateException("No SETTINGS set."); + } + return SETTINGS; + } + + class TaxonUuidAndTitleCache { + + UUID uuid; + String titleCache; + + TaxonUuidAndTitleCache(UUID uuid, String titleCache) { + this.uuid = uuid; + this.titleCache = titleCache; + } + + /** + * @return the titleCache + */ + public String getTitleCache() { + return titleCache; + } + + /** + * @return the uuid + */ + public UUID getUuid() { + return uuid; + } + } } \ No newline at end of file diff --git a/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/SwapSynonymAndAcceptedHandler.java b/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/SwapSynonymAndAcceptedHandler.java index 5f1ecbb6f..2db21b86c 100644 --- a/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/SwapSynonymAndAcceptedHandler.java +++ b/taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/handler/SwapSynonymAndAcceptedHandler.java @@ -43,7 +43,7 @@ public class SwapSynonymAndAcceptedHandler extends AbstractHandler implements */ public Object execute(ExecutionEvent event) throws ExecutionException { MultiPageTaxonEditor multiEditor = EditorUtil.getActiveEditor(); - + TaxonNameEditor editor = (TaxonNameEditor) multiEditor.getPage(Page.NAME); ISelection menuSelection = HandlerUtil.getActiveMenuSelection(event); -- 2.34.1