eu.etaxonomy.taxeditor.navigation/src/main/java/eu/etaxonomy/taxeditor/navigation/navigator/handler/ChangeAcceptedTaxonToSynonymHandler.java

   1 /**
   2  *
   3  */
   4 package eu.etaxonomy.taxeditor.navigation.navigator.handler;
   5
   6 import java.util.ArrayList;
   7 import java.util.HashSet;
   8 import java.util.Iterator;
   9 import java.util.List;
  10 import java.util.Set;
  11 import java.util.UUID;
  12
  13 import org.apache.log4j.Logger;
  14 import org.eclipse.core.commands.AbstractHandler;
  15 import org.eclipse.core.commands.ExecutionEvent;
  16 import org.eclipse.core.commands.ExecutionException;
  17 import org.eclipse.core.commands.IHandler;
  18 import org.eclipse.core.commands.common.NotDefinedException;
  19 import org.eclipse.core.commands.operations.IUndoContext;
  20 import org.eclipse.jface.dialogs.MessageDialog;
  21 import org.eclipse.jface.viewers.TreeSelection;
  22 import org.eclipse.swt.widgets.Display;
  23 import org.eclipse.ui.PartInitException;
  24 import org.eclipse.ui.handlers.HandlerUtil;
  25
  26 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  27 import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
  28 import eu.etaxonomy.cdm.model.common.CdmBase;
  29 import eu.etaxonomy.cdm.model.taxon.Classification;
  30 import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
  31 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  32 import eu.etaxonomy.taxeditor.editor.EditorUtil;
  33 import eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor;
  34 import eu.etaxonomy.taxeditor.editor.Page;
  35 import eu.etaxonomy.taxeditor.editor.TaxonEditorInput;
  36 import eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor;
  37 import eu.etaxonomy.taxeditor.navigation.NavigationUtil;
  38 import eu.etaxonomy.taxeditor.navigation.navigator.operation.ChangeAcceptedTaxonToSynonymOperation;
  39 import eu.etaxonomy.taxeditor.navigation.navigator.operation.DeleteOperation;
  40 import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
  41 import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
  42 import eu.etaxonomy.taxeditor.ui.dialog.selection.TaxonNodeSelectionDialog;
  43
  44 /**
  45  * <p>ChangeAcceptedTaxonToSynonymHandler class.</p>
  46  *
  47  * @author n.hoffmann
  48  * @created Jan 4, 2010
  49  * @version 1.0
  50  */
  51 public class ChangeAcceptedTaxonToSynonymHandler extends DeleteHandler
  52                 implements IHandler, IPostOperationEnabled {
  53         private static final Logger logger = Logger
  54                         .getLogger(ChangeAcceptedTaxonToSynonymHandler.class);
  55         private ChangeAcceptedTaxonToSynonymOperation operation;
  56
  57         private UUID newAcceptedTaxonNodeUuid;
  58         private TaxonNameEditor editor;
  59
  60         /* (non-Javadoc)
  61          * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
  62          */
  63         /** {@inheritDoc} */
  64         public Object execute(ExecutionEvent event) throws ExecutionException {
  65
  66
  67                  activePage = HandlerUtil.getActiveWorkbenchWindow(event).getActivePage();
  68
  69                 taxonNavigator = NavigationUtil.showNavigator();
  70
  71                 TreeSelection selection = (TreeSelection) HandlerUtil.getCurrentSelection(event);
  72
  73                 String plural = selection.size() > 1 ? "s" : "";
  74                 // Prompt user for confirmation
  75
  76
  77
  78                 Iterator selectionIterator = selection.iterator();
  79                 Set<ITaxonTreeNode> treeNodes = new HashSet<ITaxonTreeNode>();
  80
  81                 while (selectionIterator.hasNext()){
  82                         Object object = selectionIterator.next();
  83                         if(object instanceof ITaxonTreeNode) {
  84                 treeNodes.add((ITaxonTreeNode) object);
  85             }
  86                 }
  87                 boolean allEditorsClosed = true;
  88                 for (ITaxonTreeNode treeNode : treeNodes){
  89                         if(treeNode instanceof TaxonNode) {
  90                                 allEditorsClosed &= closeObsoleteEditor((TaxonNode) treeNode);
  91                         }
  92                 }
  93                 AbstractPostOperation operation = null;
  94                 if (treeNodes.size() == 1 ){
  95                         try {
  96
  97                                 ITaxonTreeNode treeNode = treeNodes.iterator().next();
  98                                 ITaxonTreeNode oldAcceptedTaxonNode =treeNode;
  99
 100                                 // check if taxon has no children
 101                                 if(((TaxonNode)oldAcceptedTaxonNode).getCountChildren() > 0) {
 102                                         EditorUtil.warningDialog("Prerequisite not met", this,
 103                                                         "The accepted taxon must not have any childen. You need to move all childen to " +
 104                                                         "another taxon node in the TaxonNavigator before attempting to turn the accepted " +
 105                                                         "taxon into a synonym.");
 106                                         return null;
 107                                 }
 108                                 /*if(((TaxonNode)oldAcceptedTaxonNode).getTaxon().hasSynonyms()) {
 109                                         EditorUtil.warningDialog("Prerequisite not met", this,
 110                                                         "The accepted taxon must not have any synonyms. You need to move all synonyms to " +
 111                                                         "another taxon before attempting to turn the accepted " +
 112                                                         "taxon into a synonym.");
 113                                         return null;
 114                                 }*/
 115
 116                                 List<UUID> excludeTaxa = new ArrayList<UUID>();
 117                                 excludeTaxa.add(oldAcceptedTaxonNode.getUuid());
 118                                 TaxonNode newAcceptedTaxonNode = TaxonNodeSelectionDialog.select(HandlerUtil.getActiveShell(event),
 119                                                 taxonNavigator.getConversationHolder(),
 120                                                 "Choose the accepted taxon",
 121                                                 excludeTaxa,
 122                                                 null,
 123                                                 ((TaxonNode)oldAcceptedTaxonNode).getClassification());
 124
 125                                 if (newAcceptedTaxonNode == null) {
 126                                         return null;
 127                                 }
 128
 129                                 if (allEditorsClosed){
 130
 131                                                 operation = new ChangeAcceptedTaxonToSynonymOperation(event.getCommand().getName(), NavigationUtil.getUndoContext(), oldAcceptedTaxonNode, newAcceptedTaxonNode,
 132                                                                 taxonNavigator, taxonNavigator);
 133
 134                                                 NavigationUtil.executeOperation(operation);
 135                                                 //}
 136                                 }
 137
 138
 139
 140                         } catch (NotDefinedException e) {
 141                                 NavigationUtil.warn(getClass(), "Command name not set");
 142                         }
 143                 } else{
 144                         if( MessageDialog.openConfirm(HandlerUtil.getActiveShell(event), "Moving to synonymy", "The operation move accepted taxon to synonymy is available only for a single taxon.")){
 145                                 return null;
 146                         }
 147                 }
 148
 149
 150                 return null;
 151
 152         }
 153
 154         /* (non-Javadoc)
 155          * @see eu.etaxonomy.taxeditor.operations.IPostOperationEnabled#postOperation(eu.etaxonomy.cdm.model.common.CdmBase)
 156          */
 157         /** {@inheritDoc} */
 158         public boolean postOperation(CdmBase objectAffectedByOperation) {
 159                 Display.getDefault().asyncExec(new Runnable(){
 160
 161                         public void run() {
 162                                 EditorUtil.close(editor.getMultiPageTaxonEditor());
 163
 164                                 try {
 165                                         MultiPageTaxonEditor possibleOpenEditor = (MultiPageTaxonEditor) EditorUtil.findEditorByTaxonNodeUuid(newAcceptedTaxonNodeUuid);
 166                                         if(possibleOpenEditor != null){
 167                                                 EditorUtil.close(possibleOpenEditor);
 168                                         }
 169                                         EditorUtil.openTaxonNode(newAcceptedTaxonNodeUuid);
 170                                 } catch (PartInitException e) {
 171                                         EditorUtil.error(this.getClass(), e);
 172                                         throw new RuntimeException(e);
 173                                 } catch (Exception e) {
 174                                         EditorUtil.warningDialog("Could not create Taxon", this, e.getMessage());
 175                                 }
 176                         }
 177
 178                 });
 179
 180
 181                 return true;
 182         }
 183
 184         /**
 185          * <p>onComplete</p>
 186          *
 187          * @return a boolean.
 188          */
 189         public boolean onComplete() {
 190                 // TODO Auto-generated method stub
 191                 return false;
 192         }
 193 }