EDIT

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

               getView().getInReferenceCombobox().selectNewItem(bean);

           }

           if(event.getReason().equals(Reason.DELETE)){

               getView().getInReferenceCombobox().selectNewItem(null);

    /**

     * {@inheritDoc}

     */

    @Override

    protected DeleteResult executeServiceDeleteOperation(Reference bean) {

        return getRepo().getReferenceService().delete(bean);

    }

                new ReferenceEditorAction(AbstractEditorAction.Action.ADD, null, inReferenceCombobox, this)

                    new ReferenceEditorAction(

                            AbstractEditorAction.Action.EDIT,

                            inReferenceCombobox.getValue().getId(),

                            inReferenceCombobox,

                            this)

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

    /**

     * {@inheritDoc}

     */

    @Override

    protected DeleteResult executeServiceDeleteOperation(Registration bean) {

        return getRepo().getRegistrationService().delete(bean);

    }

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

import eu.etaxonomy.cdm.api.service.config.NameDeletionConfigurator;

    /**

     * {@inheritDoc}

     */

    @Override

    protected DeleteResult executeServiceDeleteOperation(TaxonNameBase bean) {

        NameDeletionConfigurator config = new NameDeletionConfigurator();

        return getRepo().getNameService().delete(bean.getUuid(), config);

    }

public class ToOneRelatedEntityCombobox<V extends Object> extends CompositeCustomField<V> implements ToOneRelatedEntityField<V> {

        setCaption(caption);

        lazySelect.addValueChangeListener(e -> {

            // update the itemContainer immediately so that the edit button acts on the chosen item

            lazySelect.commit();

        });

    @Override

    public void selectNewItem(V bean){

        lazySelect.refresh();

        lazySelect.setValue(bean);

        lazySelect.markAsDirty();

    }

public interface ToOneRelatedEntityField<V extends Object> {

    public void selectNewItem(V bean);

public class ToOneRelatedEntityListSelect<V extends Object> extends CompositeCustomField<V> implements ToOneRelatedEntityField<V> {

        setCaption(caption);

    /**

     * {@inheritDoc}

     */

    @Override

    public void selectNewItem(V bean) {

      select.addItem(bean);

      select.select(bean);

    }

import com.vaadin.ui.Notification;

import com.vaadin.ui.UI;

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

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

    public void onEditorPreSaveEvent(EditorPreSaveEvent<DTO> preSaveEvent){

        startTransaction();

        // merge the bean and update the fieldGroup with the merged bean, so that updating

        // of field values in turn of the commit are can not cause LazyInitializationExeptions

        // the bean still has the original values at this point

        logger.trace(this._toString() + ".onEditorPreSaveEvent - merging bean into session");

        mergedBean(preSaveEvent.getBean());

    }

    /**

     *

     */

    protected void startTransaction() {

        DTO bean = mergedBean((DTO) saveEvent.getBean());

    private DTO mergedBean(DTO bean) {

            ((AbstractPopupEditor<DTO, AbstractCdmEditorPresenter<DTO, V>>)getView()).showInEditor(mergedBean);

    @Override

    protected final void deleteBean(DTO bean){

        startTransaction();

        logger.trace(this._toString() + ".deleteBean - deleting" + bean.toString());

        DeleteResult result = executeServiceDeleteOperation(bean);

        if(result.isOk()){

            getSession().flush();

            logger.trace(this._toString() + ".deleteBean - session flushed");

            getRepo().commitTransaction(tx);

            tx = null;

            logger.trace(this._toString() + ".deleteBean - transaction comitted");

            eventBus.publishEvent(new EntityChangeEvent(bean.getClass(), bean.getId(), Type.REMOVED));

        } else {

            String notificationTitle;

            StringBuffer messageBody = new StringBuffer();

            if(result.isAbort()){

                notificationTitle = "The delete operation as abborded by the system.";

            } else {

                notificationTitle = "An error occured during the delete operation.";

            }

            if(!result.getExceptions().isEmpty()){

                messageBody.append("<h3>").append("Exceptions:").append("</h3>").append("<ul>");

                result.getExceptions().forEach(e -> messageBody.append("<li>").append(e.getMessage()).append("</li>"));

                messageBody.append("</ul>");

            }

            if(!result.getRelatedObjects().isEmpty()){

                messageBody.append("<h3>").append("Related objects exist:").append("</h3>").append("<ul>");

                result.getRelatedObjects().forEach(e -> {

                    messageBody.append("<li>");

                    if(IdentifiableEntity.class.isAssignableFrom(e.getClass())){

                        messageBody.append(((IdentifiableEntity)e).getTitleCache());

                    } else {

                        messageBody.append(e.toString());

                    }

                    messageBody.append("</li>");

                }

                );

                messageBody.append("</ul>");

            }

            Notification notification = new Notification(

                   notificationTitle,

                   messageBody.toString(),

                   com.vaadin.ui.Notification.Type.ERROR_MESSAGE,

                   true);

            notification.show(UI.getCurrent().getPage());

        }

    }

    /**

     * Implementations will execute the {@link

     *

     * @return

     */

    protected abstract DeleteResult executeServiceDeleteOperation(DTO bean);

import eu.etaxonomy.vaadin.mvp.event.EditorDeleteEvent;

    public void onEditorPreSaveEvent(EditorPreSaveEvent<DTO> preSaveEvent){

    public void onEditorSaveEvent(EditorSaveEvent<DTO> saveEvent){

        DTO bean = saveEvent.getBean();

    // EditorDeleteEvent

    /**

    *

    * @param saveEvent

    */

   @EventListener

   public void onEditorDeleteEvent(EditorDeleteEvent<DTO> deleteEvent){

       if(!isFromOwnView(deleteEvent)){

           return;

       }

       deleteBean(deleteEvent.getBean());

   }

    /**

     * @param bean

     */

    protected abstract void deleteBean(DTO bean);

import eu.etaxonomy.vaadin.mvp.event.EditorDeleteEvent;

    private Button delete;

        delete = new Button("Delete", FontAwesome.REMOVE);

        delete.setStyleName(ValoTheme.BUTTON_DANGER);

        delete.addClickListener(e -> delete());

        buttonLayout.addComponents(delete, save, cancel);

        buttonLayout.setExpandRatio(delete, 1);

        buttonLayout.setComponentAlignment(delete, Alignment.TOP_RIGHT);

            eventBus.publishEvent(new EditorPreSaveEvent<DTO>(AbstractPopupEditor.this, fieldGroup.getItemDataSource().getBean()));

                eventBus.publishEvent(new EditorSaveEvent<DTO>(AbstractPopupEditor.this, fieldGroup.getItemDataSource().getBean()));

    /**

     * @return

     */

    private void delete() {

        eventBus.publishEvent(new EditorDeleteEvent(this, fieldGroup.getItemDataSource().getBean()));

        eventBus.publishEvent(new DoneWithPopupEvent(this, Reason.DELETE));

    }

/**

* Copyright (C) 2017 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.vaadin.mvp.event;

/**

 * @author a.kohlbecker

 * @since Jun 1, 2017

 *

 */

public interface EditorBeanEvent<DTO extends Object> {

    public DTO getBean();

}

/**

* Copyright (C) 2017 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.vaadin.mvp.event;

import eu.etaxonomy.vaadin.mvp.AbstractView;

/**

 * @author a.kohlbecker

 * @since Jun 1, 2017

 *

 */

public class EditorDeleteEvent<DTO extends Object> implements EditorViewEvent, EditorBeanEvent<DTO> {

    // FIXME this is only a iterim solution for the problem described in https://dev.e-taxonomy.eu/redmine/issues/6562

    private AbstractView<?> view;

    private DTO bean;

    public EditorDeleteEvent(AbstractView<?> view, DTO bean){

        this.view = view;

        this.bean = bean;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public AbstractView<?> getView() {

        return view;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public DTO getBean() {

        return bean;

    }

}

public class EditorPreSaveEvent<DTO extends Object> implements EditorViewEvent, EditorBeanEvent<DTO>{

    private AbstractView<?> view;

    private DTO bean;

    public EditorPreSaveEvent(AbstractView<?> view, DTO bean) {

        this.bean = bean;

    public AbstractView<?> getView() {

    /**

     * {@inheritDoc}

     */

    @Override

    public DTO getBean() {

        return bean;

    }

public class EditorSaveEvent<DTO extends Object> implements EditorViewEvent, EditorBeanEvent<DTO> {

    private AbstractView<?> view;

    private DTO bean;

    public EditorSaveEvent(AbstractView<?> view, DTO bean) {

        this.bean = bean;

    public AbstractView<?> getView() {

    /**

     * {@inheritDoc}

     */

    @Override

    public DTO getBean() {

        return bean;

    }

    public AbstractView<?> getView();

		CANCEL, SAVE, DELETE;