EDIT

/**

 * 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.

 */

package eu.etaxonomy.taxeditor.editor.name.e4;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.apache.commons.lang3.StringUtils;

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

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

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.e4.core.contexts.IEclipseContext;

import org.eclipse.e4.core.di.annotations.Optional;

import org.eclipse.e4.core.services.events.IEventBroker;

import org.eclipse.e4.ui.di.Focus;

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.di.UIEventTopic;

import org.eclipse.e4.ui.di.UISynchronize;

import org.eclipse.e4.ui.model.application.MApplication;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.services.EMenuService;

import org.eclipse.e4.ui.workbench.modeling.EModelService;

import org.eclipse.e4.ui.workbench.modeling.EPartService;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.DropTarget;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.ISelectionListener;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchPartReference;

import org.eclipse.ui.forms.ManagedForm;

import org.eclipse.ui.forms.widgets.FormToolkit;

import org.eclipse.ui.forms.widgets.ScrolledForm;

import org.eclipse.ui.forms.widgets.TableWrapLayout;

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

import eu.etaxonomy.cdm.model.name.HomotypicalGroup;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

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

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

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

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

import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;

import eu.etaxonomy.taxeditor.editor.CdmDataTransfer;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.ISecuredEditor;

import eu.etaxonomy.taxeditor.editor.ITaxonEditor;

import eu.etaxonomy.taxeditor.editor.e4.TaxonEditorInput;

import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AbstractGroup;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AbstractGroupedContainerE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AcceptedGroup;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AcceptedNameContainerE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.ConceptContainer;

import eu.etaxonomy.taxeditor.editor.name.e4.container.ContainerFactory;

import eu.etaxonomy.taxeditor.editor.name.e4.container.HomotypicalSynonymGroup;

import eu.etaxonomy.taxeditor.editor.name.e4.container.MisappliedGroup;

import eu.etaxonomy.taxeditor.editor.name.e4.dnd.NameEditorDropTargetListener;

import eu.etaxonomy.taxeditor.event.EventUtility;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartChangeListener;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasFactualData;

import eu.etaxonomy.taxeditor.model.IPartContentHasMedia;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.model.TaxeditorPartService;

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.security.RequiredPermissions;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

/**

 * @author pplitzner

 * @date Aug 24, 2017

 */

public class TaxonEditor

        implements IDirtyMarkable, IPartContentHasDetails,

            IPartContentHasSupplementalData, IPartContentHasMedia, IPartContentHasFactualData, IPartChangeListener,

            ISelectionListener, ISecuredEditor, IE4SavablePart, ITaxonEditor, IDropTargetable {

    private Taxon taxon;

    private ManagedForm managedForm;

    private ScrolledForm scrolledForm;

    private Composite parent;

    @Inject

    private EModelService modelService;

    @Inject

    private EPartService partService;

    private TaxonBase<?> selection;

    private AcceptedGroup acceptedGroup;

    private List<HomotypicalSynonymGroup> heterotypicSynonymGroups = new ArrayList<>();

    private MisappliedGroup misappliedGroup;

    private DropTarget target;

    @Inject

    private UISynchronize sync;

    private TaxonBase<?> objectAffectedByLastOperation;

    @Inject

    private EMenuService menuService;

    @Inject

    private ESelectionService selService;

    @Inject

    private IEclipseContext context;

    @Inject

    private MDirtyable dirty;

    @Inject

    private MApplication application;

    private MPart thisPart;

    private TaxonEditorInput input;

    private UndoContext undoContext;

    @Inject

    private IEventBroker eventBroker;

    @Inject

    public TaxonEditor() {

        undoContext = new UndoContext();

    }

    @PostConstruct

    public void createPartControl(Composite parent, MPart thisPart) {

        this.thisPart = thisPart;

        createManagedForm(parent);

        TaxeditorPartService.getInstance().addListener(TaxeditorPartService.PART_ACTIVATED, this);

    }

    protected void createManagedForm(Composite composite) {

        managedForm = new ManagedForm(composite) {

            @Override

            public void dirtyStateChanged() {

                dirty.setDirty(true);

            }

            @Override

            public boolean setInput(Object input) {

                if (input instanceof AbstractGroupedContainerE4) {

                    TaxonBase<?> newSelection = ((AbstractGroupedContainerE4<?>) input).getData();

                    if (selection != newSelection || TaxonEditor.this.isDirty()) {

                        selection = newSelection;

                        selService.setSelection(new StructuredSelection(selection));

                    }

                } else if (input == null) {

                    selection = null;

                    selService.setSelection(new StructuredSelection());

                }

                return super.setInput(input);

            }

        };

        scrolledForm = managedForm.getForm();

        parent = scrolledForm.getBody();

        parent.setData(taxon);

        TableWrapLayout layout = new TableWrapLayout();

        layout.leftMargin = 0;

        layout.rightMargin = 0;

        layout.topMargin = 0;

        layout.bottomMargin = 0;

        layout.verticalSpacing = 0;

        layout.horizontalSpacing = 0;

        parent.setLayout(layout);

        parent.setBackground(AbstractUtility.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));

    }

    public void createOrUpdateNameComposites(boolean accepted, boolean heterotypicGroups, boolean misappliedNames) {

        if (accepted) {

            ContainerFactory.createOrUpdateAcceptedTaxonsHomotypicGroup(this);

        }

        if (heterotypicGroups) {

            ContainerFactory.createOrUpdateHeterotypicSynonymyGroups(this);

        }

        if (misappliedNames) {

            ContainerFactory.createOrUpdateMisapplicationsGroup(this);

        }

        ContainerFactory.setMenuToAllContainers(this);

        // Redraw composite

        parent.pack();

        managedForm.refresh();

        managedForm.reflow(true);

    }

    @Override

    public Taxon getTaxon() {

        return HibernateProxyHelper.deproxy(taxon);

    }

    @Override

    public void addOperation(AbstractPostOperation operation) {

        input.addOperation(operation);

    }

    public void setDirty() {

        managedForm.dirtyStateChanged();

    }

    @Focus

    public void setFocus() {

        // make sure to bind again if maybe in another view the conversation was

        // unbound

        eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, this);

        if (EditorUtil.isFactsVisible()){

            EditorUtil.showFacts(modelService, partService);

            EditorUtil.setFactsVisible(false);

        }

        if (EditorUtil.isMediaVisible()){

            EditorUtil.showMedia(modelService, partService);

            EditorUtil.setMediaVisible(false);

        }

        if (input != null) {

            if (getSelectedContainer() == null) {

                throw new IllegalStateException(Messages.TaxonNameEditor_THERE_SHOULD_ALWAYS_BE);

            }

            if (input.getCdmEntitySession() != null && !input.getCdmEntitySession().isActive()) {

                input.bind();

            }

        }

        // check permissions

        boolean doEnable = permissionsSatisfied();

        managedForm.getForm().setEnabled(doEnable);

    }

    @Override

    public boolean permissionsSatisfied() {

        boolean doEnable = false;

        if (input != null){

            TaxonNode taxonNode = input.getTaxonNode();

            doEnable = CdmStore.currentAuthentiationHasPermission(taxonNode,

                    RequiredPermissions.TAXON_EDIT);

        }

        return doEnable;

    }

    /**

     * Redraws this editor return true on success

     *

     * @return a boolean.

     */

    public boolean redraw() {

        return redraw(true, true, true, true);

    }

    /**

     * {@inheritDoc}

     *

     * Redraws the editor controls

     */

    public boolean redraw(boolean focus, boolean accepted, boolean heterotypic, boolean misappliedNames) {

        createOrUpdateNameComposites(accepted, heterotypic, misappliedNames);

        if (focus) {

            setFocus();

        }

        return true;

    }

    @Override

    public boolean postOperation(Object objectAffectedByOperation) {

        if (objectAffectedByOperation instanceof TaxonBase) {

            objectAffectedByLastOperation = (TaxonBase<?>) objectAffectedByOperation;

        }

        redraw(true, true, true, true);

        changed(objectAffectedByOperation);

        onComplete();

        getContainer(objectAffectedByLastOperation).setFocus();

        return true;

    }

    public ManagedForm getManagedForm() {

        return managedForm;

    }

    /**

     * <p>

     * checkForEmptyNames

     * </p>

     *

     * @return true if there are empty names

     */

    public boolean checkForEmptyNames() {

        for (AbstractGroupedContainerE4<?> container : getGroupedContainers()) {

            if (container != null

                    && (container.getName() == null || StringUtils.isEmpty(container.getName().getTitleCache()))) {

                return true;

            }

        }

        return false;

    }

    public Set<AbstractGroupedContainerE4> getEmptyContainers() {

        Set<AbstractGroupedContainerE4> containersWithEmptyNames = new HashSet<>();

        for (AbstractGroupedContainerE4<?> container : getGroupedContainers()) {

            if (container.getName() == null || StringUtils.isEmpty(container.getName().getTitleCache())) {

                containersWithEmptyNames.add(container);

            }

        }

        return containersWithEmptyNames;

    }

    @Override

    @Persist

    public void save(IProgressMonitor monitor) {

        monitor.beginTask(Messages.TaxonNameEditor_SAVING_NAMES, getGroupedContainers().size());

        monitor.worked(1);

        //this.getDirtyNames().forEach(container -> container.refresh());

        // check for empty names

        if (checkForEmptyNames()) {

            MessageDialog.openWarning(AbstractUtility.getShell(), Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED,

                    Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED_MESSAGE);

            return;

        }

        for (AbstractGroupedContainerE4<?> container : getGroupedContainers()) {

            monitor.subTask(Messages.TaxonNameEditor_SAVING_COMPOSITES + container.getTaxonBase().getTitleCache());

            container.persistName();

            // because of missing cascading the concepts need to be saved

            // separately

            if (container instanceof ConceptContainer) {

                input.addToSaveConcept((Taxon) container.getData());

            }

            // In case the progress monitor was canceled throw an exception.

            if (monitor.isCanceled()) {

                throw new OperationCanceledException();

            }

            // Otherwise declare this step as done.

            monitor.worked(1);

        }

        input.setSync(sync);

        input.merge();

        dirty.setDirty(false);

        EventUtility.postEvent(WorkbenchEventConstants.REFRESH_NAVIGATOR, new TaxonNodeDto(input.getTaxonNode().getParent()));

        EventUtility.postEvent(WorkbenchEventConstants.SAVE_TAXON, true);

        // Stop the progress monitor.

        monitor.done();

    }

    public void init(TaxonEditorInput input) {

        if (this.input != null) {

            this.input.dispose();

            // this.acceptedGroup = null;

            // this.heterotypicSynonymGroups.clear();

            // this.misappliedGroup = null;

        }

        eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, this);

        if (!(input != null)) {

            MessagingUtils.error(this.getClass(), new Exception(Messages.TaxonNameEditor_INVALID_INPUT));

            return;

        }

        if (input.getAdapter(Taxon.class) != null) {

            taxon = CdmBase.deproxy(input.getAdapter(Taxon.class), Taxon.class);

        } else {

            MessagingUtils.error(this.getClass(), new Exception(Messages.TaxonNameEditor_INVALID_INPUT_TAXON_NULL));

            return;

        }

        this.input = input;

        createOrUpdateNameComposites(true, true, true);

        createDragSupport();

        setPartName();

//        this.setFocus();

        // set initial selection

        TaxonBase<?> initiallySelectedTaxonBase = input.getInitiallySelectedTaxonBase();

        if (initiallySelectedTaxonBase != null) {

            selService.setSelection(new StructuredSelection(initiallySelectedTaxonBase));

            getContainer(initiallySelectedTaxonBase).setSelected();

        }

    }

    private void createDragSupport() {

        // Listen for names being dragged outside of existing homotypic groups -

        // user wants to create a new group

        Transfer[] types = new Transfer[] { CdmDataTransfer.getInstance() };

        int operations = DND.DROP_MOVE;

        if (target == null) {

            target = new DropTarget(parent, operations);

            target.setTransfer(types);

            target.addDropListener(new NameEditorDropTargetListener(this));

        }

    }

    public AcceptedNameContainerE4 getAcceptedNameContainer() {

        return getAcceptedGroup().getAcceptedNameContainer();

    }

    public HomotypicalSynonymGroup getHomotypicalGroupContainer(HomotypicalGroup homotypicalGroup) {

        for (HomotypicalSynonymGroup group : getHeterotypicSynonymGroups()) {

            if (group.getGroup().equals(homotypicalGroup)) {

                return group;

            }

        }

        return null;

    }

    /**

     * <p>

     * getDirtyNames

     * </p>

     *

     * @return a Set containing all composites that have been edited

     */

    public Set<AbstractGroupedContainerE4> getDirtyNames() {

        Set<AbstractGroupedContainerE4> dirtyNames = new HashSet<>();

        for (AbstractGroupedContainerE4<?> composite : getGroupedContainers()) {

            if (composite.isDirty()) {

                dirtyNames.add(composite);

            }

        }

        return dirtyNames;

    }

    public List<AbstractGroupedContainerE4> getGroupedContainers() {

        List<AbstractGroupedContainerE4> groupedComposites = new ArrayList<>();

        for (AbstractGroup group : getAllGroups()) {

            if (group != null) {

                groupedComposites.addAll(group.getGroupedContainers());

            }

        }

        return groupedComposites;

    }

    public List<AbstractGroup> getAllGroups() {

        List<AbstractGroup> allGroups = new ArrayList<>();

        allGroups.add(getAcceptedGroup());

        heterotypicSynonymGroups = getHeterotypicSynonymGroups();

        if (heterotypicSynonymGroups != null) {

            allGroups.addAll(heterotypicSynonymGroups);

        }

        if (misappliedGroup != null) {

            allGroups.add(misappliedGroup);

        }

        return allGroups;

    }

    @Override

    public IEclipseContext getContext() {

        return context;

    }

    @Override

    public boolean isDirty() {

        return dirty.isDirty();

    }

    @PreDestroy

    public void dispose() {

        if (input != null) {

            input.dispose();

        }

        dirty.setDirty(false);

        eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, null);

    }

    @Override

    public void selectionChanged(IWorkbenchPart part, ISelection selection) {

    }

    public AbstractGroupedContainerE4 getSelectedContainer() {

        if (selection == null && input != null){

            selection = this.input.getTaxon();

        }

        return (selection != null) ? getContainer(selection) : getAcceptedNameContainer();

    }

    @Override

    public void dragEntered() {

        // TODO change this

        getControl().setBackground(AbstractUtility.getColor(Resources.COLOR_DRAG_ENTER));

    }

    @Override

    public void dragLeft() {

        getControl().setBackground(AbstractUtility.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));

    }

    public void setMisapplicationsGroup(MisappliedGroup misappliedGroup) {

        this.misappliedGroup = misappliedGroup;

    }

    public FormToolkit getToolkit() {

        return managedForm.getToolkit();

    }

    public List<HomotypicalSynonymGroup> getHeterotypicSynonymGroups() {

        return heterotypicSynonymGroups;

    }

    public void addHeterotypicSynonymGroup(HomotypicalSynonymGroup group) {

        heterotypicSynonymGroups.add(group);

    }

    public AcceptedGroup getAcceptedGroup() {

        return acceptedGroup;

    }

    public void setAcceptedGroup(AcceptedGroup acceptedGroup) {

        this.acceptedGroup = acceptedGroup;

    }

    public MisappliedGroup getMisappliedGroup() {

        return misappliedGroup;

    }

    public boolean isActive() {

        return this.equals(AbstractUtility.getActivePart());

    }

    @Override

    public boolean onComplete() {

        getContainer(objectAffectedByLastOperation).setSelected();

        return true;

    }

    @Override

    public void partChanged(Integer eventType, IWorkbenchPartReference partRef) {

        if (!partRef.getPart(false).equals(this)) {

        }

    }

    public void removeGroup(AbstractGroup group) {

        if (group != null) {

            group.dispose();

            // if (heterotypicSynonymGroups != null) {

            heterotypicSynonymGroups.remove(group);

            // }

        }

    }

    public AbstractGroupedContainerE4 getContainer(TaxonBase taxonBase) {

        @SuppressWarnings("rawtypes")

        List<AbstractGroupedContainerE4> groupedContainers = getGroupedContainers();

        for (AbstractGroupedContainerE4<?> container : groupedContainers) {

            if (container.getData().equals(taxonBase) && container.getNameViewer().getTextWidget() != null) {

                return container;

            }

        }

        return getAcceptedNameContainer();

    }

    public void setOnError() {

        Color disabledColor = AbstractUtility.getColor(Resources.COLOR_EDITOR_ERROR);

        setEnabled(false, disabledColor);

    }

    public void setDisabled() {

        Color disabledColor = AbstractUtility.getColor(Resources.COLOR_TEXT_DISABLED_BACKGROUND);

        setEnabled(false, disabledColor);

    }

    protected void setEnabled(boolean enabled, Color background) {

        for (AbstractGroupedContainerE4<?> groupedContainer : getGroupedContainers()) {

            groupedContainer.setEnabled(enabled);

        }

        // send an empty selection to the current provider - TODO only on error

        // ???

        if (!enabled) {

            getManagedForm().setInput(null);

            for (AbstractGroupedContainerE4<?> groupedContainer : getGroupedContainers()) {

                groupedContainer.setBackground(background);

            }

        }

        getControl().setBackground(background);

    }

    @Override

    public void changed(Object element) {

        // setDirty(true);

        // if the attribute is null then do not set the dirty flag -> hotfix for

        // the problem that for tasks done in service methods the changes are

        // saved automatically

        if (element != null) {

            dirty.setDirty(true);

            // refresh part title

            // TODO: refresh taxon node in taxon navigator

            setPartName();

        }

        if (element instanceof TaxonBase) {

            AbstractGroupedContainerE4<?> container = getContainer((TaxonBase<?>) element);

            if (container != null) {

                container.refresh();

               // container.setDirty(true);

            }

        }

        if (element instanceof TaxonRelationship) {

            AbstractGroupedContainerE4 container = getContainer(((TaxonRelationship) element).getFromTaxon());

            if (container != null) {

                container.refresh();

//                container.setDirty(true);

            }

        }

    }

    public void setPartName() {

        // FIXME: temporary fix for #6437 to avoid outdated title caches

        thisPart.setLabel(this.taxon.getName().generateFullTitle());

        // thisPart.setLabel(this.taxon.getName().getFullTitleCache());

    }

    @Override

    public void forceDirty() {

        setDirty();

    }

    public IUndoContext getUndoContext() {

        return undoContext;

    }

    @Override

    public Composite getControl() {

        return managedForm.getForm().getBody();

    }

    public EMenuService getMenuService() {

        return menuService;

    }

    public ESelectionService getSelectionService() {

        return selService;

    }

    @Override

    public boolean canAttachMedia() {

        return true;

    }

    public TaxonEditorInput getEditorInput() {

        return input;

    }

    @Override

    public TaxonEditor getEditor() {

        return this;

    }

    @Inject

    @Optional

    private void updateView(@UIEventTopic(WorkbenchEventConstants.REFRESH_NAME_EDITOR) CdmBase cdmbase) {

          if(this.taxon != null && (this.taxon.equals(cdmbase)

                        || (this.taxon.getName() != null && this.taxon.getName().equals(cdmbase)))) {

            this.redraw(false, true, true, true);

            this.setDirty();

            if (cdmbase instanceof TaxonBase) {

                this.selection = (TaxonBase<?>) cdmbase;

            }

        }

    }

    @Inject

    @Optional

    private void updateView(@UIEventTopic(WorkbenchEventConstants.REFRESH_NAME_EDITOR) List<CdmBase> cdmBases) {

    	if (cdmBases == null){

    		return;

    	}

        for (CdmBase cdmBase: cdmBases){

            if (cdmBase instanceof Taxon || cdmBase instanceof TaxonName){

                if (this.taxon != null && (this.taxon.equals(cdmBase)

                                || (this.taxon.getName() != null && this.taxon.getName().equals(cdmBase)))) {

                    update();

                }

            }

        }

    }

    @Inject

    @Optional

    private void updateView(@UIEventTopic(WorkbenchEventConstants.REFRESH_NAME_EDITOR) UUID cdmbaseUuid) {

        if (this.taxon.getUuid().equals(cdmbaseUuid)) {

            TaxonEditorInput input = TaxonEditorInput.NewInstanceFromTaxonBase(cdmbaseUuid);

            init(input);

        }

    }

    @Inject

    @Optional

    private void updatefromDelete(@UIEventTopic(WorkbenchEventConstants.DELETE_DERIVATIVE) DeleteResult result) {

        if (taxon.getName() == null) {

            return;

        }

        Set<DerivedUnit> typeDesignationSpecimens = new HashSet<>();

        this.taxon.getName().getSpecimenTypeDesignations()

                .forEach(designation -> typeDesignationSpecimens.add(designation.getTypeSpecimen()));

        // check if any deleted object was a type specimen

        if (result.getUpdatedObjects().stream()

                // filter only DerivedUnits

                .filter(cdmBase -> cdmBase.isInstanceOf(DerivedUnit.class))

                // deproxy from CdmBase to DerivedUnit

                .map(unit -> HibernateProxyHelper.deproxy(unit, DerivedUnit.class))

                // check for match in type designations

                .anyMatch(unit -> typeDesignationSpecimens.contains(unit))) {

            EditorUtil.updateEditor(this.input.getTaxonNode(), this);

        }

    }

    @Override

    public void update() {

        EPartService partService = TaxeditorEditorPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getService(EPartService.class);

        EModelService modelService = TaxeditorEditorPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getService(EModelService.class);

        EditorUtil.openTaxonBaseE4(this.getTaxon().getUuid(), modelService, partService, application);

    }

    @Override

    public TaxonNode getTaxonNode() {

        return input.getTaxonNode();

    }

}