EDIT

import org.springframework.transaction.IllegalTransactionStateException;

import org.springframework.transaction.TransactionDefinition;

import org.springframework.transaction.support.DefaultTransactionDefinition;

import com.vaadin.server.ServletPortletHelper;

import com.vaadin.server.VaadinRequest;

import com.vaadin.server.VaadinService;

import com.vaadin.server.VaadinSession;

import com.vaadin.ui.UI;

import eu.etaxonomy.cdm.vaadin.server.CdmSpringVaadinServletService;

import eu.etaxonomy.cdm.vaadin.server.RequestStartListener;

import eu.etaxonomy.cdm.vaadin.session.IntraViewConversationDirector;

import eu.etaxonomy.cdm.vaadin.session.ViewScopeConversationHolder;

public abstract class AbstractPresenter<V extends ApplicationView> implements Serializable, IntraViewConversationDirector, RequestStartListener {

	private ViewScopeConversationHolder conversationHolder;

	protected DefaultTransactionDefinition definition = null;

    protected boolean conversationBound;

	@Autowired

	private void setConversationHolder(ViewScopeConversationHolder conversationHolder){

	    this.conversationHolder = conversationHolder;

	    this.conversationHolder.setDefinition(getTransactionDefinition());

	}

	protected TransactionDefinition getTransactionDefinition(){

	    if(definition == null){

    	    definition = new DefaultTransactionDefinition();

    	    definition.setReadOnly(true);

	    }

	    return definition;

	}

	    if(!conversationBound){

	        // this is the central access point for getting access to the service layer.

	        // In case the presenter needs access to the repository, it most probably will use

	        // a service, so it is a good idea to bind the conversation at this point.

	        bindConversation();

	    }

        Session session = conversationHolder.getSession();

	protected final void init(V view) {

		// bind the conversation to the thread of the first request send to the according View

		// all other requests are handled in onRequestStart()

		// logger.trace(String.format(">>>>> %s init() bind()", _toString()));

	    ensureBoundConversation();

	    // register as request start and end listener

	    VaadinService service = UI.getCurrent().getSession().getService();

	    if(service instanceof CdmSpringVaadinServletService){

	        logger.trace(String.format("~~~~~ %s register as request listener", _toString()));

	        ((CdmSpringVaadinServletService)service).addRequestEndListener(this);

	        if(logger.isTraceEnabled()){

	            ((CdmSpringVaadinServletService)service).addRequestStartListener(this);

	        }

	    } else {

	        throw new RuntimeException("Using the CdmSpringVaadinServletService is required for proper per view conversation handling");

	    }

	/**

	 * Returns <code>true</code> for:

	 * <ul>

	 *   <li>..</li>

	 * <ul>

	 *

	 * Return <code>false</code> for:

	 *

	 * <ul>

     *   <li>UILD request in a existing view, like clicking on a button</li>

     * <ul>

     *

	 * @return

	protected boolean isActiveView(){

        return UI.getCurrent() != null && getView() != null && getView() == navigationManager.getCurrentView();

    }

	 */

    /**

     *

     */

	protected void bindConversation() {

        logger.trace(String.format(">>>>> %s bind()", _toString()));

        conversationHolder.bind();

        conversationBound = true;

    }

    @Override

    public void ensureBoundConversation() {

        if(!conversationBound){

            bindConversation();

        }

        if(!conversationHolder.isTransactionActive()){

            logger.trace(String.format(">>   %s starting transaction ", _toString()));

            conversationHolder.startTransaction();

        }

    }

    /**

     *

     */

    protected void unbindConversation() {

        logger.trace(String.format("<<<<< %s unbind()", _toString()));

        conversationHolder.unbind();

        // FIXME conversationHolder.isTransactionActive() always returns true

        // see https://dev.e-taxonomy.eu/redmine/issues/6780

        if(false && conversationHolder.isTransactionActive()){

            logger.trace(String.format("<<    %s comitting transaction ", _toString()));

            try{

                conversationHolder.commit(false);

            } catch (IllegalTransactionStateException | IllegalStateException e){

                // log this exception, but stop from propagating

                // FIXME remove this catch once https://dev.e-taxonomy.eu/redmine/issues/6780 is fixed

                logger.error(e.getMessage());

            }

        }

        conversationBound = false;

    }

     * <b>ONLY USED FOR LOGGING</b> when Level==TRACE

     * {@inheritDoc}

     */

    @Override

    public void onRequestStart(VaadinRequest request){

        if( ! requestNeedsConversation(request) ){

            // ignore hartbeat, fileupload, push etc

            logger.trace("ignoring request:" + request.getPathInfo());

            return;

        }

        logger.trace("onRequestStart() " + request.getPathInfo() + " " + _toString());

    }

    /**

     * @param request

    protected boolean requestNeedsConversation(VaadinRequest request) {

        return !(

                ServletPortletHelper.isAppRequest(request) // includes published file request

             || ServletPortletHelper.isFileUploadRequest(request)

             || ServletPortletHelper.isHeartbeatRequest(request)

             || ServletPortletHelper.isPushRequest(request)

             );

    }

    @Override

    public void onRequestEnd(VaadinRequest request, VaadinSession session){

        if( ! requestNeedsConversation(request) ){

            // ignore hartbeat, fileupload, push etc

            logger.trace("ignoring request:" + request.getPathInfo());

            return;

        }

        // always unbind at the end of a request to clean up the threadLocal variables in the

        // TransactionManager. This is crucial since applications containers manage threads in a pool

        // and the recycled threads may still have a reference to a SessionHolder from the processing

        // of a former request

        logger.trace("onRequestEnd() " + request.getPathInfo() + " " + _toString());

        if(conversationBound){

            unbindConversation();

        }

	public final void onViewExit() {

	    // un-register as request start and end listener

	    if(conversationBound){

    	    logger.trace(String.format("<<<<< %s onViewExit() unbind()", _toString()));

            conversationHolder.unbind();

            conversationBound = false;

	    }

	    logger.trace(String.format("<<<<< %s onViewExit() close()", _toString()));

	    conversationHolder.close();

        VaadinService service = UI.getCurrent().getSession().getService();

        if(service instanceof CdmSpringVaadinServletService){

            logger.trace(String.format("~~~~~ %s un-register as request listener", _toString()));

            ((CdmSpringVaadinServletService)service).removeRequestEndListener(this);

            if(logger.isTraceEnabled()){

                ((CdmSpringVaadinServletService)service).removeRequestStartListener(this);

            }

        } else {

            throw new RuntimeException("Using the CdmSpringVaadinServletService is required for proper per view conversation handling");

        }

    protected ViewScopeConversationHolder getConversationHolder(){

        return conversationHolder;

    }