EDIT

    /**

     * @param termType

     */

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

        // TODO use TermCacher?

        List<DefinedTermBase> terms = repo.getTermService().load(Arrays.asList(termUuid), INIT_STRATEGY);

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

        termItemContainer.addAll(terms);

        return termItemContainer;

    }

/**

* 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.model.registration;

import java.net.URI;

import java.util.UUID;

import org.apache.commons.collections.CollectionUtils;

import eu.etaxonomy.cdm.api.utility.DerivedUnitConversionException;

import eu.etaxonomy.cdm.api.utility.DerivedUnitConverter;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

import eu.etaxonomy.cdm.model.media.Media;

import eu.etaxonomy.cdm.model.media.MediaRepresentation;

import eu.etaxonomy.cdm.model.media.MediaRepresentationPart;

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.reference.Reference;

/**

 * A DTO which is use in the context of the {@link SpecimenTypeDesignationWorkingSetDTO} which is backed up

 * <code>SpecimenTypeDesignation.typeSpecimen.derivedFrom.type</code> object graph.

 * <p>

 * The contained {@link DerivedUnit} either is a {@link MediaSpecimen} with or a {@link DerivedUnit}, depending on the

 * "kind of unit" which is defined by the associated <code>DerivationEvent.type</code>:

 *

 * <ul>

 * <li>{@link DerivationEventType#GATHERING_IN_SITU()} -&gt; {@link DerivedUnit}</li>

 * <li>{@link DerivationEventTypes#CULTURE_METABOLIC_INACTIVE()} -&gt; {@link DerivedUnit}</li>

 * <li>{@link DerivationEventTypes#UNPUBLISHED_IMAGE()} -&gt; {@link MediaSpecimen}</li>

 * <li>{@link DerivationEventTypes#PUBLISHED_IMAGE()} -&gt; {@link MediaSpecimen}</li>

 * </ul>

 *

 * @author a.kohlbecker

 * @since Jun 22, 2017

 *

 */

public class SpecimenTypeDesignationDTO {

    SpecimenTypeDesignation std;

    /**

     * Creates an new new instance of SpecimenTypeDesignationDTO which is backed up

     * by an newly instantiated <code>SpecimenTypeDesignation.typeSpecimen.derivedFrom.type</code> object graph.

     */

    public SpecimenTypeDesignationDTO(){

        this(SpecimenTypeDesignation.NewInstance());

    }

    /**

     * Creates a new instance of SpecimenTypeDesignationDTO.

     *

     * The constructor assures that <code>SpecimenTypeDesignation.typeSpecimen.derivedFrom.type</code> are never null.

     * That is in case the supplied std parameter or if any of the above listed properties is null the missing instances

     * are created and added to the object graph.

     *

     * @param std

     */

    public SpecimenTypeDesignationDTO(SpecimenTypeDesignation std) {

        this.std = std;

        if(std.getTypeSpecimen() == null){

            DerivedUnit derivedUnit = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);

            std.setTypeSpecimen(derivedUnit);

        }

        if(std.getTypeSpecimen().getDerivedFrom() == null){

            DerivationEvent derivedFrom = DerivationEvent.NewInstance(DerivationEventType.GATHERING_IN_SITU());

            std.getTypeSpecimen().setDerivedFrom(derivedFrom);

        }

    }

    public DerivationEventType getDerivationEventType(){

        return std.getTypeSpecimen().getDerivedFrom().getType();

    }

    public void setDerivationEventType(DerivationEventType derivationEventType) throws DerivedUnitConversionException{

        std.getTypeSpecimen().getDerivedFrom().setType(derivationEventType);

        Class<? extends DerivedUnit> requiredSpecimenType = specimenTypeFor(derivationEventType);

        if(!requiredSpecimenType.equals(std.getTypeSpecimen())){

            DerivedUnit convertedSpecimen;

            if(requiredSpecimenType.equals(MediaSpecimen.class)){

                DerivedUnitConverter<MediaSpecimen> converter = new DerivedUnitConverter<MediaSpecimen> (std.getTypeSpecimen());

                convertedSpecimen = converter.convertTo((Class<MediaSpecimen>)requiredSpecimenType, specimenOrObservationTypeFor(derivationEventType));

            } else {

                DerivedUnitConverter<DerivedUnit> converter = new DerivedUnitConverter<DerivedUnit> (std.getTypeSpecimen());

                convertedSpecimen = converter.convertTo((Class<DerivedUnit>)requiredSpecimenType, specimenOrObservationTypeFor(derivationEventType));

            }

            std.setTypeSpecimen(convertedSpecimen);

        }

    }

    /**

     * See constructor doc.

     *

     * @param derivationEventType

     * @return

     *      either <code>DerivedUnit</code> or <code>MediaSpecimen</code> never null.

     *  <code>DerivedUnit</code> is the fall back return value.

     */

    private Class<?  extends DerivedUnit> specimenTypeFor(DerivationEventType derivationEventType) {

        UUID detUuid = derivationEventType.getUuid();

        if(detUuid.equals(DerivationEventType.GATHERING_IN_SITU().getUuid())) {

            return DerivedUnit.class;

        }

        if(detUuid.equals(DerivationEventTypes.CULTURE_METABOLIC_INACTIVE().getUuid())) {

            return DerivedUnit.class;

        }

        if(detUuid.equals(DerivationEventTypes.PUBLISHED_IMAGE().getUuid())) {

            return MediaSpecimen.class;

        }

        if(detUuid.equals(DerivationEventTypes.UNPUBLISHED_IMAGE().getUuid())) {

            return MediaSpecimen.class;

        }

        return DerivedUnit.class;

    }

    private SpecimenOrObservationType specimenOrObservationTypeFor(DerivationEventType derivationEventType) {

        UUID detUuid = derivationEventType.getUuid();

        if(detUuid.equals(DerivationEventType.GATHERING_IN_SITU().getUuid())) {

            return SpecimenOrObservationType.PreservedSpecimen;

        }

        if(detUuid.equals(DerivationEventTypes.CULTURE_METABOLIC_INACTIVE().getUuid())) {

            return SpecimenOrObservationType.LivingSpecimen;

        }

        if(detUuid.equals(DerivationEventTypes.PUBLISHED_IMAGE().getUuid())) {

            return SpecimenOrObservationType.StillImage;

        }

        if(detUuid.equals(DerivationEventTypes.UNPUBLISHED_IMAGE().getUuid())) {

            return SpecimenOrObservationType.StillImage;

        }

       return SpecimenOrObservationType.PreservedSpecimen;

    }

    public SpecimenTypeDesignationStatus getTypeStatus(){

        return HibernateProxyHelper.deproxy(std.getTypeStatus(), SpecimenTypeDesignationStatus.class);

    }

    public void setTypeStatus(SpecimenTypeDesignationStatus typeStatus){

        std.setTypeStatus(typeStatus);

    }

    public Collection getCollection(){

        return std.getTypeSpecimen().getCollection();

    }

    public void setCollection(Collection collection){

        std.getTypeSpecimen().setCollection(collection);

    }

    public String getAccessionNumber(){

        return std.getTypeSpecimen().getAccessionNumber();

    }

    public void setAccessionNumber(String accessionNumber){

        std.getTypeSpecimen().setAccessionNumber(accessionNumber);

    }

    public URI getMediaUri(){

        if(checkMediaSpecimen()){

            MediaRepresentationPart part = findMediaRepresentationPart();

            if(part != null){

                return part.getUri();

            }

        }

        return null;

    }

    public void setMediaUri(URI mediaUri){

        if(checkMediaSpecimen()){

            MediaRepresentationPart part = findOrMakeMediaRepresentationPart();

            part.setUri(mediaUri);

        }

    }

    public Reference getMediaSpecimenReference(){

        if(checkMediaSpecimen()){

            IdentifiableSource source = findMediaSpecimenIdentifieableSource();

            if(source != null){

                return source.getCitation();

            }

        }

        return null;

    }

    public void setMediaSpecimenReference(Reference reference){

        if(checkMediaSpecimen()){

            IdentifiableSource source = findOrMakeMediaSpecimenIdentifieableSource();

            source.setCitation(reference);

        }

    }

    public String getMediaSpecimenReferenceDetail(){

        if(checkMediaSpecimen()){

            IdentifiableSource source = findMediaSpecimenIdentifieableSource();

            if(source != null){

                return source.getCitationMicroReference();

            }

        }

        return null;

    }

    public void setMediaSpecimenReferenceDetail(String referenceDetail){

        if(checkMediaSpecimen()){

            IdentifiableSource source = findOrMakeMediaSpecimenIdentifieableSource();

            source.setCitationMicroReference(referenceDetail);

        }

    }

    /**

     * @return

     */

    private IdentifiableSource findMediaSpecimenIdentifieableSource() {

        IdentifiableSource source = null;

        Media media = findMediaSpecimen().getMediaSpecimen();

        if(media != null){

            // FIXME use marker type to tag the MediaSpecimenReference and make sure that there is always only one.

            if(!CollectionUtils.isEmpty(media.getSources())){

                source = media.getSources().iterator().next();

            }

        }

        return source;

    }

    /**

     *

     */

    private MediaRepresentationPart findMediaRepresentationPart() {

        Media media = findMediaSpecimen().getMediaSpecimen();

        if(media != null){

            if(!CollectionUtils.isEmpty(media.getRepresentations())){

                MediaRepresentation repr = media.getRepresentations().iterator().next();

                if(!CollectionUtils.isEmpty(repr.getParts())) {

                    MediaRepresentationPart part = repr.getParts().iterator().next();

                    return part;

                }

            }

        }

        return null;

    }

    private MediaRepresentationPart findOrMakeMediaRepresentationPart() {

        if(findMediaSpecimen().getMediaSpecimen() == null){

            findMediaSpecimen().setMediaSpecimen(Media.NewInstance());

        }

        Media media = findMediaSpecimen().getMediaSpecimen();

        if(CollectionUtils.isEmpty(media.getRepresentations())){

            media.addRepresentation(MediaRepresentation.NewInstance());

        }

        MediaRepresentation repr = media.getRepresentations().iterator().next();

        if(CollectionUtils.isEmpty(repr.getParts())) {

            repr.addRepresentationPart(MediaRepresentationPart.NewInstance(null, null));

        }

        MediaRepresentationPart part = repr.getParts().iterator().next();

        return part;

    }

    /**

     * @return

     */

    private IdentifiableSource findOrMakeMediaSpecimenIdentifieableSource() {

        IdentifiableSource source ;

        Media media = findMediaSpecimen().getMediaSpecimen();

        if(media == null){

            findMediaSpecimen().setMediaSpecimen(Media.NewInstance());

        }

        if(CollectionUtils.isEmpty(media.getSources())){

           source = IdentifiableSource.NewPrimaryMediaSourceInstance(null, null);

           media.addSource(source);

        } else {

            source = media.getSources().iterator().next();

        }

        return source;

    }

    /**

     * @return

     */

    public boolean checkMediaSpecimen() {

        return findMediaSpecimen() != null;

    }

    /**

     * @return

     */

    private MediaSpecimen findMediaSpecimen() {

        DerivedUnit sp = std.getTypeSpecimen();

        if(MediaSpecimen.class.isAssignableFrom(sp.getClass())){

            return (MediaSpecimen) sp;

        }

        return null;

    }

}

import java.util.ArrayList;

    List<SpecimenTypeDesignationDTO> specimenTypeDesignationsDTOs = new ArrayList<>();

        specimenTypeDesignations.forEach(std -> specimenTypeDesignationsDTOs.add(new SpecimenTypeDesignationDTO(std)));

    public List<SpecimenTypeDesignationDTO> getSpecimenTypeDesignationDTOs(){

        return specimenTypeDesignationsDTOs;

    }

/**

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

import com.vaadin.server.Sizeable.Unit;

import com.vaadin.ui.Component;

import com.vaadin.ui.ListSelect;

import com.vaadin.ui.TextField;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.vaadin.component.ToOneRelatedEntityCombobox;

/**

 * SpecimenTypeDesignationDTORow needs to be instantiated by a EditorInstantiator which can only be provided by the presenter

 *  {@link SpecimenTypeDesignationWorkingsetEditorPresenter#handleViewEntered()}

 *

 * @author a.kohlbecker

 * @since Jun 22, 2017

 *

 */

public class SpecimenTypeDesignationDTORow {

    /* CONVENTION!

     *

     * The fieldname must match the properties of the SpecimenTypeDesignationDTO

     */

    ListSelect derivationEventType = new ListSelect(); // "Kind of unit");

    ListSelect typeStatus = new ListSelect(); // "Kind of unit");

    ToOneRelatedEntityCombobox<eu.etaxonomy.cdm.model.occurrence.Collection> collection =

            new ToOneRelatedEntityCombobox<eu.etaxonomy.cdm.model.occurrence.Collection>(null, eu.etaxonomy.cdm.model.occurrence.Collection.class);

    TextField accessionNumber = new TextField(); // "Accession number");

    TextField mediaUri = new TextField(); // "Image URI");

    ToOneRelatedEntityCombobox<Reference> mediaSpecimenReference =

            new ToOneRelatedEntityCombobox<Reference>(null, Reference.class);

    TextField mediaSpecimenReferenceDetail = new TextField(); //"Image reference detail");

    public SpecimenTypeDesignationDTORow(){

        derivationEventType.setRows(1);

        typeStatus.setRows(1);

        accessionNumber.setWidth(100, Unit.PIXELS);

        collection.setWidth(150, Unit.PIXELS);

        mediaUri.setWidth(150, Unit.PIXELS);

        mediaSpecimenReference.setWidth(200, Unit.PIXELS);

        mediaSpecimenReferenceDetail.setWidth(200, Unit.PIXELS);

    }

    /**

     * @return

     */

    public Component[] components() {

        return new Component[]{

                derivationEventType, typeStatus,

                collection, accessionNumber,

                mediaUri, mediaSpecimenReference,

                mediaSpecimenReferenceDetail, mediaSpecimenReferenceDetail

                };

    }

}

import java.util.UUID;

import org.vaadin.viritin.fields.AbstractElementCollection;

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

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

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;

import eu.etaxonomy.cdm.vaadin.model.registration.DerivationEventTypes;

import eu.etaxonomy.cdm.vaadin.util.CdmTitleCacheCaptionGenerator;

    @SuppressWarnings("serial")

        getView().getTypeDesignationsCollectionField().setEditorInstantiator(new AbstractElementCollection.Instantiator<SpecimenTypeDesignationDTORow>() {

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

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

            @Override

            public SpecimenTypeDesignationDTORow create() {

                SpecimenTypeDesignationDTORow row = new SpecimenTypeDesignationDTORow();

                row.typeStatus.setContainerDataSource(selectFactory.buildBeanItemContainer(TermType.SpecimenTypeDesignationStatus));

                row.derivationEventType.setContainerDataSource(selectFactory.buildTermItemContainer(new UUID[]{

                    DerivationEventType.GATHERING_IN_SITU().getUuid(),

                    DerivationEventTypes.UNPUBLISHED_IMAGE().getUuid(),

                    DerivationEventTypes.PUBLISHED_IMAGE().getUuid(),

                    DerivationEventTypes.CULTURE_METABOLIC_INACTIVE().getUuid()

                }));

                row.collection.loadFrom(collectionPagingProvider, collectionPagingProvider, collectionPagingProvider.getPageSize());

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

                row.mediaSpecimenReference.loadFrom(referencePagingProvider, referencePagingProvider, collectionPagingProvider.getPageSize());

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

                getView().applyDefaultComponentStyle(row.components());

                return row;

            }

        });

import org.vaadin.viritin.fields.ElementCollectionField;

import com.vaadin.ui.Component;

import com.vaadin.ui.Panel;

import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationDTO;

    private ElementCollectionField<SpecimenTypeDesignationDTO> typeDesignationsCollectionField;

        grid.setRows(9);

        grid.setWidth("1200px");

        row++;

        // FIXME: can we use the Grid instaed?

        typeDesignationsCollectionField = new ElementCollectionField<>(

                SpecimenTypeDesignationDTO.class,

                SpecimenTypeDesignationDTORow.class

                );

        typeDesignationsCollectionField.withCaption("Types");

        typeDesignationsCollectionField.getLayout().setSpacing(false);

        typeDesignationsCollectionField.getLayout().setColumns(3);

        typeDesignationsCollectionField.setPropertyHeader("accessionNumber", "Access. num.");

        typeDesignationsCollectionField.setPropertyHeader("mediaSpecimenReference", "Image reference");

        typeDesignationsCollectionField.setPropertyHeader("mediaSpecimenReferenceDetail", "Reference detail");

        // typeDesignationsCollectionField.getLayout().setMargin(false);

        // typeDesignationsCollectionField.addStyleName("composite-field-wrapper");

        // addField(typeDesignationsCollectionField, "specimenTypeDesignationDTOs", 0, row, 2, row);

        Panel scrollPanel = new Panel(typeDesignationsCollectionField.getLayout());

        scrollPanel.setCaption("Types");

        scrollPanel.setWidth(800, Unit.PIXELS);

        bindField(typeDesignationsCollectionField, "specimenTypeDesignationDTOs");

        addComponent(scrollPanel, 0, row, 2, row);

    // ------- SpecimenTypeDesignationWorkingsetPopupEditorView methods ---- //

    @Override

    public ElementCollectionField<SpecimenTypeDesignationDTO> getTypeDesignationsCollectionField() {

        return typeDesignationsCollectionField;

    }

    @Override

    public void applyDefaultComponentStyle(Component ... components){

        for(int i = 0; i <components.length; i++){

            components[i].setStyleName(getDefaultComponentStyles());

        }

    }

import org.vaadin.viritin.fields.ElementCollectionField;

import com.vaadin.ui.Component;

import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationDTO;

    ElementCollectionField<SpecimenTypeDesignationDTO> getTypeDesignationsCollectionField();

    void applyDefaultComponentStyle(Component ... components);

  .composite-field-wrapper {

        @include composite-field-wrapper;

    }