EDIT

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

import java.util.ArrayList;

import java.util.List;

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.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.TreeSelection;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.handlers.HandlerUtil;

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

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

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.MultiPageTaxonEditor;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.navigation.NavigationUtil;

import eu.etaxonomy.taxeditor.navigation.navigator.TaxonNavigator;

import eu.etaxonomy.taxeditor.store.CdmStore;

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

public class MoveFactualDataHandler extends AbstractHandler {

    @SuppressWarnings("unused")

    private static final Logger logger = Logger.getLogger(MoveFactualDataHandler.class);

    @Override

    public Object execute(ExecutionEvent event) throws ExecutionException {

        ISelection currentSelection = HandlerUtil.getCurrentSelection(event);

        IWorkbenchPart activePart = AbstractUtility.getActivePart();

        TaxonNavigator navigator = null;

        if(activePart instanceof TaxonNavigator){

            navigator = (TaxonNavigator)activePart;

        }

        if(navigator!=null && currentSelection instanceof TreeSelection){

            Object object = ((TreeSelection) currentSelection).getFirstElement();

            if(object instanceof TaxonNode){

                TaxonNode taxonNode = HibernateProxyHelper.deproxy(object, TaxonNode.class);

                final TaxonNode sourceTaxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid());

                if(NavigationUtil.isDirty(sourceTaxonNode)){

                    MessageDialog.openWarning(HandlerUtil.getActiveShell(event), "Unsaved Source Taxon", "There are unsaved " +

                            "changes in the source taxon. Please save first.");

                    return null;

                }

                //reload to avoid session conflicts

                Taxon taxon = HibernateProxyHelper.deproxy(CdmStore.getService(ITaxonService.class).load(sourceTaxonNode.getTaxon().getUuid()), Taxon.class);

                if(taxon!=null){

                 // Choose the target taxon

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

                    excludeTaxa.add(taxon.getUuid());

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

                            navigator.getConversationHolder(),

                            "Choose the accepted taxon",

                            excludeTaxa,

                            null,

                            null);

                    if (dialogTaxonNode == null) {

                        return null;

                    }

                    //reload to avoid session conflicts

                    final TaxonNode targetTaxonNode = CdmStore.getService(ITaxonNodeService.class).load(dialogTaxonNode.getUuid());

                    if(NavigationUtil.isDirty(targetTaxonNode)){

                        MessageDialog.openWarning(HandlerUtil.getActiveShell(event), "Unsaved Target Taxon", "There are unsaved " +

                                "changes in the target taxon. Please save first.");

                        return null;

                    }

                    CdmStore.getService(IDescriptionService.class).moveTaxonDescriptions(taxon.getUuid(),targetTaxonNode.getTaxon().getUuid());

                    navigator.getConversationHolder().bind();

                    navigator.getConversationHolder().commit();

                    Display.getDefault().asyncExec(new Runnable(){

                        @Override

                        public void run() {

                            try {

                                //close and re-open to refresh factual data view

                                MultiPageTaxonEditor sourceEditor = (MultiPageTaxonEditor) EditorUtil.findEditorByTaxonNodeUuid(sourceTaxonNode.getUuid());

                                MultiPageTaxonEditor targetEditor = (MultiPageTaxonEditor) EditorUtil.findEditorByTaxonNodeUuid(targetTaxonNode.getUuid());

                                if(targetEditor != null){

                                    AbstractUtility.close(sourceEditor);

                                    AbstractUtility.close(targetEditor);

                                }

                                EditorUtil.openTaxonNode(sourceTaxonNode.getUuid());

                                EditorUtil.openTaxonNode(targetTaxonNode.getUuid());

                            } catch (PartInitException e) {

                                MessagingUtils.error(this.getClass(), e);

                                throw new RuntimeException(e);

                            } catch (Exception e) {

                                MessagingUtils.warningDialog("Could not create Taxon", this, e.getMessage());

                            }

                        }

                    });

                }

            }

        }

        return null;

    }

}