EDIT

      <handler

            class="eu.etaxonomy.taxeditor.navigation.navigator.handler.ChangeAcceptedTaxonToSynonymHandler"

            commandId="eu.etaxonomy.taxeditor.navigator.command.update.changeAcceptedToSynonym">

         <activeWhen>

            <test

                  property="eu.etaxonomy.taxeditor.preference.CdmStorePropertyTester.isRemoting">

            </test>

         </activeWhen>

      </handler>

// $Id$

/**

* Copyright (C) 2015 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.navigation.navigator.handler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorReference;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.handlers.HandlerUtil;

import eu.etaxonomy.cdm.model.common.ITreeNode;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.taxeditor.editor.TaxonEditorInput;

/**

 * @author cmathew

 * @date 16 Jun 2015

 *

 */

public class NavigatorHandlerUtils {

    protected static boolean closeObsoleteEditor(ExecutionEvent event, TaxonNode taxonNode){

        IWorkbenchPage activePage = HandlerUtil.getActiveWorkbenchWindow(event).getActivePage();

        boolean result = true;

        for (IEditorReference ref : activePage.getEditorReferences()) {

            try {

                String treeIndex = ((ITreeNode)taxonNode).treeIndex();

                IEditorInput input = ref.getEditorInput();

                if (input instanceof TaxonEditorInput) {

                    TaxonNode node = ((TaxonEditorInput) input).getTaxonNode();

                    //if node is a child of taxonNode then close the editor

                    if( ((ITreeNode) node).treeIndex().startsWith(treeIndex)){

                    //if (taxonNode.equals(node)) {

                        result &= activePage.closeEditor(ref.getEditor(false), true);

                    }

                }

            } catch (PartInitException e) {

                continue;

            }

        }

        return result;

    }

}

/**

 *

 */

package eu.etaxonomy.taxeditor.navigation.navigator.handler;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.viewers.TreeSelection;

import org.eclipse.ui.handlers.HandlerUtil;

import eu.etaxonomy.cdm.api.conversation.ConversationHolderMock;

import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.taxeditor.operation.RemotingCdmHandler;

import eu.etaxonomy.taxeditor.ui.dialog.selection.TaxonNodeSelectionDialog;

/**

 * <p>ChangeAcceptedTaxonToSynonymHandler class.</p>

 *

 * @author n.hoffmann

 * @created Jan 4, 2010

 * @version 1.0

 */

public class RemotingChangeAcceptedTaxonToSynonymHandler extends RemotingCdmHandler {

    private static final Logger logger = Logger

            .getLogger(RemotingChangeAcceptedTaxonToSynonymHandler.class);

    private static final String CHANGE_ACCEPTED_TAXON_TO_SYNONYM_LABEL = "Change Accepted Taxon to Synonym";

    private static final String SINGLE_TAXON_SELECTION_MESSAGE = "The operation move accepted taxon to synonymy is available only for a single taxon.";

    private static final String SOURCE_TAXON_HAS_CHILDREN_MESSAGE = "The accepted taxon must not have any childen. You need to move all childen to " +

            "another taxon node in the TaxonNavigator before attempting to turn the accepted " +

            "taxon into a synonym.";

    private static final String RELATED_EDITORS_NOT_CLOSED_MESSAGE = "Could not close related taxon anme editors. " +

            "Please close them manually.";

    private ITaxonTreeNode oldAcceptedTaxonNode;

	/**

     * @param label

     */

    public RemotingChangeAcceptedTaxonToSynonymHandler() {

        super(CHANGE_ACCEPTED_TAXON_TO_SYNONYM_LABEL);

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.operation.RemotingCdmHandler#allowOperations(org.eclipse.core.commands.ExecutionEvent)

     */

    @Override

    public IStatus allowOperations(ExecutionEvent event) {

        TreeSelection selection = (TreeSelection) HandlerUtil.getCurrentSelection(event);

        // check that only a single taxon has been selected

        if(selection.size() > 0) {

            return new Status(IStatus.ERROR,

                    "unknown",

                    SINGLE_TAXON_SELECTION_MESSAGE);

        }

        Iterator selectionIterator = selection.iterator();

        Set<ITaxonTreeNode> treeNodes = new HashSet<ITaxonTreeNode>();

        ITaxonTreeNode treeNode = treeNodes.iterator().next();

        oldAcceptedTaxonNode = treeNode;

        // check that the source taxon node does not have children

        if(((TaxonNode)oldAcceptedTaxonNode).getCountChildren() > 0) {

            return new Status(IStatus.ERROR,

                    "unknown",

                    SOURCE_TAXON_HAS_CHILDREN_MESSAGE);

        }

        // check all editors related to this taxon node are closed

        boolean allEditorsClosed = true;

        for (ITaxonTreeNode tn : treeNodes){

            if(treeNode instanceof TaxonNode) {

                allEditorsClosed &= NavigatorHandlerUtils.closeObsoleteEditor(event, (TaxonNode) tn);

            }

        }

        if(allEditorsClosed != true) {

            return new Status(IStatus.ERROR,

                    "unknown",

                    RELATED_EDITORS_NOT_CLOSED_MESSAGE);

        }

        return Status.OK_STATUS;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.operation.RemotingCdmHandler#doOperations(org.eclipse.core.commands.ExecutionEvent)

     */

    @Override

    public IStatus doOperations(ExecutionEvent event) {

        List<UUID> excludeTaxa = new ArrayList<UUID>();

        excludeTaxa.add(oldAcceptedTaxonNode.getUuid());

        TaxonNode newAcceptedTaxonNode = TaxonNodeSelectionDialog.select(HandlerUtil.getActiveShell(event),

                new ConversationHolderMock(),

                "Choose the accepted taxon",

                excludeTaxa,

                null,

                ((TaxonNode)oldAcceptedTaxonNode).getClassification());

        if (newAcceptedTaxonNode == null) {

            return null;

        }

        // run operation

        return Status.OK_STATUS;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.operation.RemotingCdmHandler#postOperations(org.eclipse.core.commands.ExecutionEvent)

     */

    @Override

    public void postOperations(ExecutionEvent event) {

        // TODO Auto-generated method stub

    }

}

// $Id$

/**

* Copyright (C) 2015 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.operation;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.jface.dialogs.ErrorDialog;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

/**

 * @author cmathew

 * @date 16 Jun 2015

 *

 */

public abstract class RemotingCdmHandler extends AbstractHandler {

    private final String label;

    public RemotingCdmHandler(String label) {

        this.label = label;

    }

    /* (non-Javadoc)

     * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)

     */

    @Override

    public Object execute(ExecutionEvent event) throws ExecutionException {

        IStatus allowStatus = allowOperations(event);

        if(allowStatus.isOK()) {

            IStatus opStatus = doOperations(event);

            onComplete(event, opStatus);

        } else {

            MessagingUtils.warningDialog("Can not perform " + label, event.getTrigger(), allowStatus);

        }

        return null;

    }

    public void onComplete(ExecutionEvent event, IStatus status) {

        if(!status.isOK() && status.getException() != null) {

            ErrorDialog.openError(null, "Error executing " + label, null, status);

        }

        postOperations(event);

    }

    public abstract IStatus allowOperations(ExecutionEvent event);

    public abstract IStatus doOperations(ExecutionEvent event);

    public abstract void postOperations(ExecutionEvent event);

}

// $Id$

/**

* Copyright (C) 2015 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.operation;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.commands.operations.AbstractOperation;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

/**

 * @author cmathew

 * @date 16 Jun 2015

 *

 */

public abstract class RemotingCdmOperation extends AbstractOperation {

    public RemotingCdmOperation(String label) {

        super(label);

    }

    /* (non-Javadoc)

     * @see org.eclipse.core.commands.operations.AbstractOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)

     */

    @Override

    public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {

       boolean success = doExecute(monitor, info);

       postExecute(success);

       return onComplete(success);

    }

    public abstract boolean doExecute(IProgressMonitor monitor, IAdaptable info);

    public void postExecute(boolean success) {}

    public abstract IStatus onComplete(boolean success);

    /* (non-Javadoc)

     * @see org.eclipse.core.commands.operations.AbstractOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)

     */

    @Override

    public IStatus redo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {

        // TODO Auto-generated method stub

        return null;

    }

    /* (non-Javadoc)

     * @see org.eclipse.core.commands.operations.AbstractOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)

     */

    @Override

    public IStatus undo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {

        // TODO Auto-generated method stub

        return null;

    }

}

// $Id$

/**

* Copyright (C) 2015 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.operation;

import java.util.Collection;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.MultiStatus;

import org.eclipse.core.runtime.Status;

import eu.etaxonomy.cdm.api.service.UpdateResult;

/**

 * @author cmathew

 * @date 16 Jun 2015

 *

 */

public abstract class RemotingCdmUpdateOperation extends RemotingCdmOperation {

    private UpdateResult updateResult;

    /**

     * @param label

     */

    public RemotingCdmUpdateOperation(String label) {

        super(label);

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.operation.RemotingCdmOperation#doExecute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)

     */

    @Override

    public boolean doExecute(IProgressMonitor monitor, IAdaptable info) {

        updateResult = doUpdateExecute(monitor, info);

        return updateResult.isOk();

    }

    public abstract UpdateResult doUpdateExecute(IProgressMonitor monitor, IAdaptable info);

    /* (non-Javadoc)

     * @see eu.etaxonomy.taxeditor.operation.RemotingCdmOperation#onComplete(boolean)

     */

    @Override

    public IStatus onComplete(boolean success) {

        if(success) {

            return Status.OK_STATUS;

        }

        if(updateResult != null) {

            Collection<Exception> exceptions = updateResult.getExceptions();

            Status[] childStatus = new Status[exceptions.size()];

            for(Exception ex : exceptions) {

                Status status = new Status(IStatus.ERROR,

                        "unknown",

                        IStatus.ERROR,

                        ex.getLocalizedMessage(),

                        ex);

            }

            MultiStatus multiStatus = new MultiStatus("unknown",

                    IStatus.ERROR,

                    childStatus,

                    getLabel() + " is in error",

                    null);

            return multiStatus;

        }

        return null;

    }

}

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

    private static final String EDITOR_IS_CONNECTED_TO_DB = "isCdmStoreConnected";

    private static final String IS_REMOTING = "isRemoting";

    @Override

    public boolean test(Object receiver, String property, Object[] args,

            Object expectedValue) {

        if(EDITOR_IS_CONNECTED_TO_DB.equals(property)){

            return isCdmStoreConnected();

        }

        if(IS_REMOTING.equals(property)){

            return isRemoting();

        }

        return false;

    }

    private boolean isCdmStoreConnected(){

        boolean active = CdmStore.isActive();

        return active;

    }

    private boolean isRemoting() {

        return CdmStore.getCurrentSessionManager().isRemoting();

    }