EDIT

import com.vaadin.server.DeploymentConfiguration;

import com.vaadin.server.ServiceException;

import com.vaadin.server.VaadinServletService;

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

        @Override

        protected VaadinServletService createServletService(

                DeploymentConfiguration deploymentConfiguration)

                throws ServiceException {

            //  - The SpringVaadinServletService is needed when using a custom service URL

            //  - The CdmSpringVaadinServletService allows to attach listeners to the requestEnd and 

            //    requestStart method this is important for proper unbinding of Conversations from 

            //    the request threads.

            //    see ViewScopeConversationHolder

            CdmSpringVaadinServletService service = new CdmSpringVaadinServletService(

                    this, deploymentConfiguration, getServiceUrlPath());

            service.init();

            return service;

        }

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

    private IIdentifiableEntityService<T> service;

    private ConversationDirector conversationDirector;

    public CdmFilterablePagingProvider(IIdentifiableEntityService<T> service, ConversationDirector conversationDirector) {

        this.conversationDirector = conversationDirector;

    public CdmFilterablePagingProvider(IIdentifiableEntityService<T> service, MatchMode matchMode, List<OrderHint> orderHints, ConversationDirector conversationDirector) {

        this.conversationDirector = conversationDirector;

        conversationDirector.ensureBoundConversation();

        conversationDirector.ensureBoundConversation();

import org.springframework.transaction.support.DefaultTransactionDefinition;

    TransactionStatus txNonConversational = null;

    /**

     * @return the conversationHolder

     */

    public ConversationHolder getConversationHolder() {

        return conversationHolder;

    }

    protected DefaultTransactionDefinition txDefinition = null;

     * constructor which takes a ConversationHolder. The supplying class of the conversationHolder needs

     * to care for <code>bind()</code>, <code>unbind()</code> and <code>close()</code> since the store is

     * only responsible for starting and committing of transactions.

     *

     * @param repo

     * @param service

     * @param conversationHolder

    public CdmStore(CdmRepository repo, S service, ConversationHolder conversationHolder) {

        this.repo = repo;

        this.service = service;

        this.conversationHolder = conversationHolder;

    public TransactionStatus startTransaction() {

        if(conversationHolder != null && !conversationHolder.isTransactionActive()){

            //conversationHolder.setDefinition(getTransactionDefinition());

            return conversationHolder.startTransaction();

        } else {

            checkExistingTransaction();

            txNonConversational = repo.startTransaction();

            return txNonConversational;

        }

        if (txNonConversational != null) {

            throw new RuntimeException("Opening a second transaction in the same" + this.getClass().getSimpleName() + " is not supported");

        Session session;

        if(conversationHolder != null){

            session = conversationHolder.getSession();

        } else {

            session = repo.getSession();

        }

        if(txNonConversational == null || (conversationHolder != null && !conversationHolder.isTransactionActive())){

            // no running transaction, start one ...

            startTransaction();

        }

        session.flush();

        commitTransction();

        startTransaction();

            getSession().flush();

            commitTransction();

            txNonConversational = null;

    protected void commitTransction() {

        if(conversationHolder != null){

            conversationHolder.commit();

        } else {

            repo.commitTransaction(txNonConversational);

            txNonConversational = null;

    }

    /**

     * @param entityId

     */

    public T loadBean(int entityId) {

        conversationHolder.startTransaction();

        return service.find(entityId);

    public S getService() {

        return service;

/**

* 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.cdm.vaadin.component;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.UUID;

import com.vaadin.data.util.BeanItemContainer;

import eu.etaxonomy.cdm.api.application.CdmRepository;

import eu.etaxonomy.cdm.api.service.pager.Pager;

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

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

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

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

import eu.etaxonomy.cdm.persistence.query.OrderHint;

/**

 * @author a.kohlbecker

 * @since Apr 6, 2017

 *

 */

public class CdmBeanItemContainerFactory {

    private CdmRepository repo;

    private final static List<String> INIT_STRATEGY = Arrays.asList(new String[]{"$", "representations"});

    private static List<OrderHint> orderHints = new ArrayList<>();

    static {

        orderHints.add(OrderHint.BY_ORDER_INDEX);

        orderHints.add(OrderHint.ORDER_BY_TITLE_CACHE);

    }

    /**

     * Constructor to be used by presenter classes directly

     *

     * @param repo

     */

    public CdmBeanItemContainerFactory(CdmRepository repo){

        this.repo = repo;

    }

    /**

     * @param termType

     */

    public BeanItemContainer<DefinedTermBase> buildBeanItemContainer(TermType termType) {

        // TODO use TermCacher?

        List<DefinedTermBase> terms = repo.getTermService().listByTermType(termType, null, null, orderHints, INIT_STRATEGY);

        BeanItemContainer<DefinedTermBase> termItemContainer = new BeanItemContainer<>(DefinedTermBase.class);

        termItemContainer.addAll(terms);

        return termItemContainer;

    }

    /**

     * @param termType

     */

    public BeanItemContainer<DefinedTermBase> buildBeanItemContainer(UUID vocabularyUuid) {

        TermVocabulary vocab = repo.getVocabularyService().find(vocabularyUuid);

        Pager<DefinedTermBase> terms = repo.getVocabularyService().getTerms(vocab, null, null, orderHints, INIT_STRATEGY);

        BeanItemContainer<DefinedTermBase> termItemContainer = new BeanItemContainer<>(DefinedTermBase.class);

        termItemContainer.addAll(terms.getRecords());

        return termItemContainer;

    }

    /**

     * @param termType

     */

    public BeanItemContainer<DefinedTermBase> buildTermItemContainer(UUID ... termUuid) {

        return buildTermItemContainer(Arrays.asList(termUuid));

    }

    /**

     * @param derivation_EVENT_TYPE_UUIDS

     * @return

     */

    public BeanItemContainer<DefinedTermBase> buildTermItemContainer(List<UUID> termsUuids) {

        List<DefinedTermBase> terms = repo.getTermService().load(termsUuids, INIT_STRATEGY);

        BeanItemContainer<DefinedTermBase> termItemContainer = new BeanItemContainer<>(DefinedTermBase.class);

        termItemContainer.addAll(terms);

        return termItemContainer;

    }

    /**

     * @param termType

     */

    public <T extends CdmBase> BeanItemContainer<T> buildBeanItemContainer(Class<T> type, List<OrderHint> orderHints) {

        if(orderHints == null){

            orderHints = OrderHint.defaultOrderHintsFor(type);

        }

        List<T> terms = repo.getCommonService().list(type, (Integer)null, (Integer)null,

                orderHints,

                Arrays.asList(new String[]{"$"}));

        BeanItemContainer<T> termItemContainer = new BeanItemContainer<>(type);

        termItemContainer.addAll(terms);

        return termItemContainer;

    }

    public <T extends CdmBase> BeanItemContainer<T> buildBeanItemContainer(Class<T> type) {

        return buildBeanItemContainer(type, null);

    }

}

import eu.etaxonomy.cdm.vaadin.util.converter.TypeDesignationSetManager.TypeDesignationWorkingSetType;

    private List<TypeDesignationWorkingSetButton> typeDesignationButtons = new ArrayList<>();

                typeDesignationButtons.add(new TypeDesignationWorkingSetButton(

                        typeDesignationWorkingSet.getWorkingsetType(),

    public List<TypeDesignationWorkingSetButton> getTypeDesignationButtons() {

    public class TypeDesignationWorkingSetButton {

        private Integer id;

        private TypeDesignationWorkingSetType type;

        private Button button;

        public TypeDesignationWorkingSetButton(TypeDesignationWorkingSetType type, Integer id, Button button){

            this.type = type;

            this.id = id;

            this.button = button;

        }

        /**

         * @return the id

         */

        public Integer getId() {

            return id;

        }

        /**

         * @return the button

         */

        public Button getButton() {

            return button;

        }

        /**

         * @return the type

         */

        public TypeDesignationWorkingSetType getType() {

            return type;

        }

    }

        private Class<T> entityType;

            this.entityType = type;

            return entityType;

import eu.etaxonomy.cdm.vaadin.util.converter.TypeDesignationSetManager.TypeDesignationWorkingSetType;

    private TypeDesignationWorkingSetType workingSetType;

     *

     * @param action

     * @param typeDesignationWorkingsetId

     * @param workingSetType

     * @param registrationId

     * @param source

     * @param sourceView

    public TypeDesignationWorkingsetEditorAction(Action action, Integer typeDesignationWorkingsetId, TypeDesignationWorkingSetType workingSetType, int registrationId,

            Component source, AbstractView sourceView) {

        this.workingSetType = workingSetType;

     *

     * @param action

     * @param workingSetType

     * @param registrationId

     * @param source

     * @param sourceView

    public TypeDesignationWorkingsetEditorAction(Action action, TypeDesignationWorkingSetType workingSetType, int registrationId,

        this.workingSetType = workingSetType;

     * @return

    public TypeDesignationWorkingSetType getWorkingSetType() {

        return workingSetType;

/**

* 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.cdm.vaadin.server;

import java.util.ArrayList;

import java.util.List;

import com.vaadin.server.DeploymentConfiguration;

import com.vaadin.server.ServiceException;

import com.vaadin.server.VaadinRequest;

import com.vaadin.server.VaadinResponse;

import com.vaadin.server.VaadinServlet;

import com.vaadin.server.VaadinSession;

import com.vaadin.spring.server.SpringVaadinServletService;

/**

 * @author a.kohlbecker

 * @since Jul 4, 2017

 *

 */

public class CdmSpringVaadinServletService extends SpringVaadinServletService {

    private static final long serialVersionUID = 5956798985059823698L;

    List<RequestEndListener> requestEndListeners = new ArrayList<>();

    List<RequestStartListener> requestStartListeners = new ArrayList<>();

    /**

     * @param servlet

     * @param deploymentConfiguration

     * @param serviceUrl

     * @throws ServiceException

     */

    public CdmSpringVaadinServletService(VaadinServlet servlet, DeploymentConfiguration deploymentConfiguration,

            String serviceUrl) throws ServiceException {

        super(servlet, deploymentConfiguration, serviceUrl);

    }

    @Override

    public void requestStart(VaadinRequest request, VaadinResponse response) {

        super.requestStart(request, response);

        requestStartListeners.forEach(l -> l.onRequestStart(request));

    }

    @Override

    public void requestEnd(VaadinRequest request, VaadinResponse response,

            VaadinSession session) {

        super.requestEnd(request, response, session);

        requestEndListeners.forEach(l -> l.onRequestEnd(request, session));

    }

    public void addRequestStartListener(RequestStartListener requestStartListener){

        requestStartListeners.add(requestStartListener);

    }

    public void removeRequestStartListener(RequestStartListener requestStartListener){

        requestStartListeners.remove(requestStartListener);

    }

    public void addRequestEndListener(RequestEndListener requestEndListener){

        requestEndListeners.add(requestEndListener);

    }

    public void removeRequestEndListener(RequestEndListener requestEndListener){

        requestEndListeners.remove(requestEndListener);

    }

}

/**

* 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.cdm.vaadin.server;

import com.vaadin.server.VaadinRequest;

import com.vaadin.server.VaadinSession;

/**

 * @author a.kohlbecker

 * @since Jul 4, 2017

 *

 */

public interface RequestEndListener {

    public void onRequestEnd(VaadinRequest request, VaadinSession session);

}

/**

* 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.cdm.vaadin.server;

import com.vaadin.server.VaadinRequest;

/**

 * @author a.kohlbecker

 * @since Jul 4, 2017

 *

 */

public interface RequestStartListener {

    public void onRequestStart(VaadinRequest request);

}

/**

* 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.cdm.vaadin.session;

/**

 * @author a.kohlbecker

 * @since Jul 6, 2017

 *

 */

public interface ConversationDirector {

    public void ensureBoundConversation();

}

/**

* 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.cdm.vaadin.session;

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

/**

 * @author a.kohlbecker

 * @since Jul 6, 2017

 *

 */

public interface IntraViewConversationDirector extends ConversationDirector, RequestEndListener {

}

/**

* 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.cdm.vaadin.session;

import java.io.Serializable;

import javax.sql.DataSource;

import org.hibernate.FlushMode;

import org.hibernate.SessionFactory;

import org.springframework.orm.hibernate5.support.OpenSessionInViewFilter;

import org.springframework.transaction.PlatformTransactionManager;

import org.springframework.transaction.TransactionDefinition;

import org.springframework.transaction.support.DefaultTransactionDefinition;

import com.vaadin.spring.annotation.SpringComponent;

import com.vaadin.spring.annotation.ViewScope;

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

import eu.etaxonomy.vaadin.mvp.AbstractEditorPresenter;

/**

 * The ViewScopeConversationHolder allows to span conversations over all request threads

 * that are involved in the creation, interaction and ending of a View.

 *

 * <p><b>NOTE</b>: Hibernate sessions created in the conversation created by this holder

 * will not fluish automatically. The flush mode is initially

 * set to {@code FlushMode.MANUAL}. It assumes to be used

 * in combination with service layer transactions that care for the flushing: The

 * active transaction manager will temporarily change the flush mode to

 * {@code FlushMode.AUTO} during a read-write transaction, with the flush

 * mode reset to {@code FlushMode.NEVER} at the end of each transaction.

 * This behavior is implemented consistently in the {@link {@link AbstractEditorPresenter} methods

 * {@link AbstractEditorPresenter#onEditorPreSaveEvent(eu.etaxonomy.vaadin.mvp.event.EditorPreSaveEvent) onEditorPreSaveEvent},

 * {@link AbstractEditorPresenter#onEditorSaveEvent(eu.etaxonomy.vaadin.mvp.event.EditorSaveEvent) onEditorSaveEvent} and

 * {@link AbstractEditorPresenter#onEditorDeleteEvent(eu.etaxonomy.vaadin.mvp.event.EditorDeleteEvent) onEditorDeleteEvent}

 * In this whole strategy this class follows the ideas of the {@link OpenSessionInViewFilter}.

 *

 * @author a.kohlbecker

 * @since Jun 30, 2017

 *

 */

@SpringComponent

@ViewScope

public class ViewScopeConversationHolder extends ConversationHolder implements Serializable {

    private static final long serialVersionUID = 1001768184000981106L;

    /**

     *

     */

    public ViewScopeConversationHolder() {

        super();

        applyDefaultSettings();

    }

    /**

     * @param dataSource

     * @param sessionFactory

     * @param transactionManager

     */

    public ViewScopeConversationHolder(DataSource dataSource, SessionFactory sessionFactory,

            PlatformTransactionManager transactionManager) {

        super(dataSource, sessionFactory, transactionManager, false);

        applyDefaultSettings();

    }

    private void applyDefaultSettings(){

        setDefaultFlushMode(FlushMode.MANUAL);

        TransactionDefinition definition = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_NESTED);

        setDefinition(definition );

    }

}

    public CdmTitleCacheCaptionGenerator(){

    }

        public TypeDesignationWorkingSetType getWorkingsetType() {

            return isSpecimenTypeDesigationWorkingSet() ? TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET : TypeDesignationWorkingSetType.NAME_TYPE_DESIGNATION_WORKINGSET;

        }

    }

    public enum TypeDesignationWorkingSetType {

        SPECIMEN_TYPE_DESIGNATION_WORKINGSET,

        NAME_TYPE_DESIGNATION_WORKINGSET,

/**

* 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.cdm.vaadin.view.name;

public class RegistrationAndWorkingsetId {

    Integer registrationId;

    Integer workingsetId;

    /**

     * @param registrationId

     * @param specimentId

     */

    public RegistrationAndWorkingsetId(Integer registrationId, Integer specimentId) {

        super();

        this.registrationId = registrationId;

        this.workingsetId = specimentId;

    }

}

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import eu.etaxonomy.cdm.vaadin.component.CdmBeanItemContainerFactory;

import eu.etaxonomy.cdm.vaadin.util.converter.TypeDesignationSetManager.TypeDesignationWorkingSet;

    private List<String> specimenTypeDesignationWorkingsetInitStrategy = Arrays.asList(new String[]{

            "typeDesignations.typeStatus.representations",

            "typeDesignations.typeSpecimen.sources",

            "typeDesignations.typeSpecimen.mediaSpecimen.representations.parts",

            "typeDesignations.typeSpecimen.collection",

            "typeDesignations.typeSpecimen.derivedFrom.type",

            "typeDesignations.typeSpecimen.derivedFrom.derivatives",

            // Need to initialize all properties of the DerivedUnit to avoid LIEs while converting DerivedUnit with the DerivedUnitConverter:

            "typeDesignations.typeSpecimen.*",

    });

    /**

     * {@inheritDoc}

     */

    @Override

    protected SpecimenTypeDesignationWorkingSetDTO loadBeanById(Object identifier) {

        SpecimenTypeDesignationWorkingSetDTO workingSet;

        if(identifier != null){

            RegistrationAndWorkingsetId registrationAndWorkingsetId = (RegistrationAndWorkingsetId)identifier;

            List<Integer> ids = new ArrayList<>();

            ids.add(registrationAndWorkingsetId.registrationId);

            Registration reg = getRepo().getRegistrationService().loadByIds(ids, specimenTypeDesignationWorkingsetInitStrategy).get(0);

            RegistrationDTO regDTO = new RegistrationDTO(reg);

            TypeDesignationWorkingSet typeDesignationWorkingSet = regDTO.getTypeDesignationWorkingSet(registrationAndWorkingsetId.workingsetId);

            workingSet = regDTO.getSpecimenTypeDesignationWorkingSetDTO(typeDesignationWorkingSet.getBaseEntityReference());

        } else {

            workingSet = null;

        }

        return workingSet;

    }

        CdmBeanItemContainerFactory selectFactory = new CdmBeanItemContainerFactory(getRepo());

            CdmFilterablePagingProvider<Collection> collectionPagingProvider = new CdmFilterablePagingProvider<Collection>(getRepo().getCollectionService(), SpecimenTypeDesignationWorkingsetEditorPresenter.this);

            CdmFilterablePagingProvider<Reference> referencePagingProvider = new CdmFilterablePagingProvider<Reference>(getRepo().getReferenceService(), SpecimenTypeDesignationWorkingsetEditorPresenter.this);

                row.collection.getSelect().setCaptionGenerator(new CdmTitleCacheCaptionGenerator<Collection>());

                row.mediaSpecimenReference.getSelect().setCaptionGenerator(new CdmTitleCacheCaptionGenerator<Reference>());

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

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

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

import eu.etaxonomy.cdm.vaadin.component.CdmBeanItemContainerFactory;

        CdmBeanItemContainerFactory selectFieldFactory = new CdmBeanItemContainerFactory(getRepo());

        getView().getRankSelect().setContainerDataSource(selectFieldFactory.buildBeanItemContainer(TermType.Rank));

        getView().getRankSelect().setItemCaptionPropertyId("label");

        CdmFilterablePagingProvider<Reference> referencePagingProvider = new CdmFilterablePagingProvider<Reference>(getRepo().getReferenceService(), TaxonNameEditorPresenter.this);

        CdmFilterablePagingProvider<TaxonName> namePagingProvider = new CdmFilterablePagingProvider<TaxonName>(getRepo().getNameService(), TaxonNameEditorPresenter.this);

    /**

     * {@inheritDoc}

     */

    protected TaxonName loadBeanById(Object identifier) {

        TaxonName bean;

        if(identifier != null){

            bean = getRepo().getNameService().find((Integer)identifier);

        } else {

            bean = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());

        }

        return bean;

    }

                if(basionymName != null){

                    if(basionymName .getUuid() != null){

                        // reload

                        basionymName = getRepo().getNameService().load(basionymName.getUuid());

                    }

                    bean.addBasionym(basionymName);

                }

        rankSelect = new ListSelect("Rank");

    /**

     * {@inheritDoc}

     */

    @Override

    public ListSelect getRankSelect() {

        return rankSelect;

    }

import com.vaadin.ui.ListSelect;

    public ListSelect getRankSelect();