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