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.navigator.operation.ChangeAcceptedTaxonToSynonymOperation;
  33 import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
  34 import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
  35 import eu.etaxonomy.taxeditor.ui.dialog.selection.TaxonNodeSelectionDialog;
  36
  37 /**
  38  * <p>ChangeAcceptedTaxonToSynonymHandler class.</p>
  39  *
  40  * @author n.hoffmann
  41  * @created Jan 4, 2010
  42  * @version 1.0
  43  */
  44 public class ChangeAcceptedTaxonToSynonymHandler extends DeleteHandler
  45                 implements IHandler, IPostOperationEnabled {
  46         private static final Logger logger = Logger
  47                         .getLogger(ChangeAcceptedTaxonToSynonymHandler.class);
  48         private ChangeAcceptedTaxonToSynonymOperation operation;
  49
  50         private UUID newAcceptedTaxonNodeUuid;
  51         private TaxonNameEditor editor;
  52
  53         /* (non-Javadoc)
  54          * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)
  55          */
  56         /** {@inheritDoc} */
  57         @Override
  58     public Object execute(ExecutionEvent event) throws ExecutionException {
  59
  60
  61                  activePage = HandlerUtil.getActiveWorkbenchWindow(event).getActivePage();
  62
  63                 taxonNavigator = NavigationUtil.showNavigator();
  64
  65                 TreeSelection selection = (TreeSelection) HandlerUtil.getCurrentSelection(event);
  66
  67                 String plural = selection.size() > 1 ? "s" : "";
  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("Prerequisite not met", this,
  97                                                         "The accepted taxon must not have any childen. You need to move all childen to " +
  98                                                         "another taxon node in the TaxonNavigator before attempting to turn the accepted " +
  99                                                         "taxon into a synonym.");
 100                                         return null;
 101                                 }
 102                                 /*if(((TaxonNode)oldAcceptedTaxonNode).getTaxon().hasSynonyms()) {
 103                                         EditorUtil.warningDialog("Prerequisite not met", this,
 104                                                         "The accepted taxon must not have any synonyms. You need to move all synonyms to " +
 105                                                         "another taxon before attempting to turn the accepted " +
 106                                                         "taxon into a synonym.");
 107                                         return null;
 108                                 }*/
 109
 110                                 List<UUID> excludeTaxa = new ArrayList<UUID>();
 111                                 excludeTaxa.add(oldAcceptedTaxonNode.getUuid());
 112                                 TaxonNode newAcceptedTaxonNode = TaxonNodeSelectionDialog.select(HandlerUtil.getActiveShell(event),
 113                                                 taxonNavigator.getConversationHolder(),
 114                                                 "Choose the accepted taxon",
 115                                                 excludeTaxa,
 116                                                 null,
 117                                                 ((TaxonNode)oldAcceptedTaxonNode).getClassification());
 118
 119                                 if (newAcceptedTaxonNode == null) {
 120                                         return null;
 121                                 }
 122
 123                                 if (allEditorsClosed){
 124
 125                                                 operation = new ChangeAcceptedTaxonToSynonymOperation(event.getCommand().getName(),
 126                                                         NavigationUtil.getUndoContext(),
 127                                                         oldAcceptedTaxonNode,
 128                                                         newAcceptedTaxonNode,
 129                                                                 taxonNavigator,
 130                                                                 taxonNavigator,
 131                                                                 taxonNavigator);
 132
 133                                                 NavigationUtil.executeOperation(operation);
 134                                                 //}
 135                                 }
 136
 137
 138
 139                         } catch (NotDefinedException e) {
 140                                 MessagingUtils.warn(getClass(), "Command name not set");
 141                         }
 142                 } else{
 143                         if( MessageDialog.openConfirm(HandlerUtil.getActiveShell(event), "Moving to synonymy", "The operation move accepted taxon to synonymy is available only for a single taxon.")){
 144                                 return null;
 145                         }
 146                 }
 147
 148
 149                 return null;
 150
 151         }
 152
 153         /* (non-Javadoc)
 154          * @see eu.etaxonomy.taxeditor.operations.IPostOperationEnabled#postOperation(eu.etaxonomy.cdm.model.common.CdmBase)
 155          */
 156         /** {@inheritDoc} */
 157         @Override
 158     public boolean postOperation(CdmBase objectAffectedByOperation) {
 159                 Display.getDefault().asyncExec(new Runnable(){
 160
 161                         @Override
 162             public void run() {
 163                                 EditorUtil.close(editor.getMultiPageTaxonEditor());
 164
 165                                 try {
 166                                         MultiPageTaxonEditor possibleOpenEditor = (MultiPageTaxonEditor) EditorUtil.findEditorByTaxonNodeUuid(newAcceptedTaxonNodeUuid);
 167                                         if(possibleOpenEditor != null){
 168                                                 EditorUtil.close(possibleOpenEditor);
 169                                         }
 170                                         EditorUtil.openTaxonNode(newAcceptedTaxonNodeUuid);
 171                                 } catch (PartInitException e) {
 172                                         MessagingUtils.error(this.getClass(), e);
 173                                         throw new RuntimeException(e);
 174                                 } catch (Exception e) {
 175                                         MessagingUtils.warningDialog("Could not create Taxon", this, e.getMessage());
 176                                 }
 177                         }
 178
 179                 });
 180
 181
 182                 return true;
 183         }
 184
 185         /**
 186          * <p>onComplete</p>
 187          *
 188          * @return a boolean.
 189          */
 190         @Override
 191     public boolean onComplete() {
 192                 // TODO Auto-generated method stub
 193                 return false;
 194         }
 195 }