EDIT

            if(regDto.getTypifiedName() != null){

                addComponent(new Label(regDto.getTypifiedName().getLabel()));

            }

        addTypeDesignationButton.setDescription("Add a new type designation workingset");

        if(nameIdButton != null){

            nameIdButton.getButton().addStyleName(DEFAULT_BUTTON_STYLES);

        }

    public Integer getTypeDesignationWorkingsetId(){

        return getEntityId();

    }

import java.util.Arrays;

import java.util.Optional;

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

     * @param problems

     *    Problems detected in prior validation and processing passed to this method to be completed. Can be <code>null</code>.

    public void add(RegistrationDTO regDTO) throws RegistrationValidationException {

        validateAndAddDTOs(Arrays.asList(regDTO), null);

    }

    public Optional<RegistrationDTO> getRegistrationDTO(int registrationId) {

        return registrationDTOs.stream().filter(r -> r.getId() == registrationId).findFirst();

    }

    /**

     * @return the std

     */

    public SpecimenTypeDesignation asSpecimenTypeDesignation() {

        return std;

    }

    List<SpecimenTypeDesignation> specimenTypeDesignations = new ArrayList<>();

     *

     * @param owner

     * @param baseEntity

     * @param specimenTypeDesignations can be <code>null</code>

        if(specimenTypeDesignations != null){

            this.specimenTypeDesignations = specimenTypeDesignations;

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

        }

    protected List<SpecimenTypeDesignation> getSpecimenTypeDesignations() {

     * TypeDesignations which refer to the same FieldUnit (SpecimenTypeDesignation) or TaxonName

     * (NameTypeDesignation) form a working set. The <code>TypeDesignationWorkingSet</code> internally

     * works with EnityReferences to the actual TypeDesignations.

     *

     * The EntityReferences for TypeDesignations are grouped by the according TypeDesignationStatus.

     *

     * A workingset can be referenced by the <code>workingSetId</code>, this is a autoincrement

     * value which is created during the process of determining the workingsets in a collection of

     * TypeDesignations.

     *

     * TODO: consider using a concatenation of baseEntity.getClass() + baseEntity.getId() as workingset identifier

import java.util.Arrays;

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

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

    private Reference citation;

    private TaxonName typifiedName;

     * Loads an existing working set from the database. This process actually involves

     * loading the Registration specified by the <code>RegistrationAndWorkingsetId.registrationId</code> and in

     * a second step to find the workingset by the <code>registrationAndWorkingsetId.workingsetId</code>.

     * <p>

     * The <code>identifier</code> must be of the type {@link TypeDesignationWorkingsetEditorIdSet} whereas the field <code>egistrationId</code>

     * must be present, the field <code>workingsetId</code>,  however can be null. I this case a new workingset with a new {@link FieldUnit} as

     * base entity is being created.

     *

     * @param identifier a {@link TypeDesignationWorkingsetEditorIdSet}

        SpecimenTypeDesignationWorkingSetDTO workingSetDto;

            TypeDesignationWorkingsetEditorIdSet idset = (TypeDesignationWorkingsetEditorIdSet)identifier;

            Registration reg = getRepo().getRegistrationService().loadByIds(Arrays.asList(idset.registrationId), null).get(0);

            if(idset.workingsetId != null){

                RegistrationDTO regDTO = new RegistrationDTO(reg);

                // find the working set

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

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

                citation = (Reference) regDTO.getCitation();

            } else {

                // create a new workingset, for a new fieldunit which is the base for the workingset

                FieldUnit newfieldUnit = FieldUnit.NewInstance();

                workingSetDto = new SpecimenTypeDesignationWorkingSetDTO(reg, newfieldUnit, null);

                citation = getRepo().getReferenceService().find(idset.publicationId);

                typifiedName = getRepo().getNameService().find(idset.typifiedNameId);

            }

            workingSetDto = null;

        return workingSetDto;

        for(SpecimenTypeDesignationDTO stdDTO : dto.getSpecimenTypeDesignationDTOs()){

                SpecimenOrObservationBase<?> original = findEarliestOriginal(stdDTO.asSpecimenTypeDesignation().getTypeSpecimen());

        for(SpecimenTypeDesignationDTO stdDTO : dto.getSpecimenTypeDesignationDTOs()){

            SpecimenTypeDesignation std = stdDTO.asSpecimenTypeDesignation();

            if(reg.getTypeDesignations().isEmpty() || !reg.getTypeDesignations().stream().filter(td -> td.equals(std)).findFirst().isPresent()){

                std.setCitation(citation);

                typifiedName.addTypeDesignation(std, false);

/**

* 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 TypeDesignationWorkingsetEditorIdSet {

    Integer registrationId;

    Integer workingsetId;

    Integer publicationId;

    Integer typifiedNameId;

    /**

     * @param registrationId

     *            must be present

     * @param workingsetId

     *            can <code>null</code>. In this case the <code>publicationId</code>

     *            and and typifiedNameId must be set.

     *            <code>RegistrationAndWorkingsetId</code> refers to a not yet

     *            existing working set, which should be created by the code in

     *            case this makes sense.

     * @param publicationId

     *            Can <code>null</code> if the <code>workingsetId</code> is given.

     * @param typifiedNameId

     *            Can <code>null</code> if the <code>workingsetId</code> is given

     */

    protected TypeDesignationWorkingsetEditorIdSet(Integer registrationId, Integer workingsetId, Integer publicationId, Integer typifiedNameId) {

        this.registrationId = registrationId;

        this.workingsetId = workingsetId;

        this.publicationId = publicationId;

        this.typifiedNameId = typifiedNameId;

        if(workingsetId == null && publicationId == null|| workingsetId == null && typifiedNameId == null){

            throw new NullPointerException("When workingsetId is null, publicationId and typifiedNameId must be non null.");

        }

    }

    public TypeDesignationWorkingsetEditorIdSet(Integer registrationId, Integer workingsetId) {

        this(registrationId, workingsetId, null, null);

    }

    public TypeDesignationWorkingsetEditorIdSet(Integer registrationId, Integer publicationId, Integer typifiedNameId) {

        this(registrationId, null, publicationId, typifiedNameId);

    }

}

    @Deprecated

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

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

                typeDesignationManager = new TypeDesignationSetManager(reg.getTypeDesignations());

    /**

     * To create an initially empty DTO for which only the <code>typifiedName</code> and the <code>publication</code> are defined.

     * All TypeDesignations added to the <code>Registration</code> need to refer to the same <code>typifiedName</code> and must be

     * published in the same <code>publication</code>.

     *

     * @param reg

     * @param typifiedName

     */

    public RegistrationDTO(Registration reg, TaxonName typifiedName, Reference publication) {

        this.reg = reg;

        citation = publication;

        // create a TypeDesignationSetManager with only a reference to the typifiedName for validation

        typeDesignationManager = new TypeDesignationSetManager(typifiedName);

    }

import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;

import eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkflowEvent;

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

import eu.etaxonomy.cdm.vaadin.view.name.TypeDesignationWorkingsetEditorIdSet;

    private TaxonName newTaxonNameForRegistration = null;

    private RegistrationDTO newRegistrationDTOWithExistingName;

    /**

     * @param taxonNameId

     * @return

     */

    protected Registration createNewRegistrationForName(Integer taxonNameId) {

        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        // move into RegistrationWorkflowStateMachine

        long identifier = System.currentTimeMillis();

        Registration reg = Registration.NewInstance(

                "http://phycobank.org/" + identifier,

                "" + identifier,

                taxonNameId != null ? getRepo().getNameService().find(taxonNameId) : null,

                null);

        Authentication authentication = currentSecurityContext().getAuthentication();

        reg.setSubmitter((User)authentication.getPrincipal());

        EntityChangeEvent event = getRegistrationStore().saveBean(reg);

        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        return getRepo().getRegistrationService().find(event.getEntityId());

    }

    /**

     *

     */

    protected void refreshView() {

        getConversationHolder().getSession().clear();

        presentWorkingSet(workingset.getCitationId());

    }

        CdmFilterablePagingProvider<TaxonName> pagingProvider = new CdmFilterablePagingProvider<TaxonName>(

                getRepo().getNameService(), this);

        CdmTitleCacheCaptionGenerator<TaxonName> titleCacheGenrator = new CdmTitleCacheCaptionGenerator<TaxonName>();

        getView().getAddExistingNameCombobox().setCaptionGenerator(titleCacheGenrator);

        getView().getAddExistingNameCombobox().loadFrom(pagingProvider, pagingProvider, pagingProvider.getPageSize());

     * Loads the WorkingSet from the data base and passes it to the view.

     *

        getView().setHeaderText("Registrations for " + workingset.getCitation());

    /**

     * Creates a new <code>Registration</code> for a new name that has just been edited

     * using the <code>TaxonNamePopupEditor</code>. The new name was previously created

     * in this presenter as <code>newTaxonNameForRegistration</code> (see {@link #onTaxonNameEditorActionAdd(TaxonNameEditorAction)})

     * and is either filled with data (<code>Reason.SAVE</code>) or it is still empty

     * (<code>Reason.CANCEL</code>).

     *

     *

     * @param event

     * @throws RegistrationValidationException

     */

                int taxonNameId = newTaxonNameForRegistration.getId();

                Registration reg = createNewRegistrationForName(taxonNameId);

    }

    /**

     * Creates a new Registration for an exiting (previously published name).

     *

     * @param event

     * @throws RegistrationValidationException

     */

    @EventListener(condition = "#event.action == T(eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkflowEvent.Action).start")

    public void onRegistrationWorkflowEventActionStart(RegistrationWorkflowEvent event) throws RegistrationValidationException {

        getView().getAddExistingNameCombobox().commit();

        TaxonName typifiedName = getView().getAddExistingNameCombobox().getValue();

        if(typifiedName != null){

            Registration newRegistrationWithExistingName = createNewRegistrationForName(null);

            Reference citation = getRepo().getReferenceService().find(workingset.getCitationId());

            newRegistrationDTOWithExistingName = new RegistrationDTO(newRegistrationWithExistingName, typifiedName, citation);

            workingset.add(newRegistrationDTOWithExistingName);

            // tell the view to update the workingset

            getView().setWorkingset(workingset);

            getView().getAddExistingNameRegistrationButton().setEnabled(false);

            getView().getAddExistingNameRegistrationButton().setDescription("You first need to add a type designation to the previously created registration.");

        } else {

            logger.error("Seletced name is NULL");

        }

                popup.loadInEditor(new TypeDesignationWorkingsetEditorIdSet(event.getRegistrationId(), event.getEntityId()));

    public void onAddNewTypeDesignationWorkingset(TypeDesignationWorkingsetEditorAction event) {

            TypeDesignationWorkingsetEditorIdSet identifierSet;

            Integer typifiedNameId;

            if(newRegistrationDTOWithExistingName != null){

                typifiedNameId = newRegistrationDTOWithExistingName.getTypifiedName().getId();

            } else {

                typifiedNameId = workingset.getRegistrationDTO(event.getRegistrationId())

                        .get()

                        .getTypifiedName()

                        .getId();

            }

            identifierSet = new TypeDesignationWorkingsetEditorIdSet(

                    event.getRegistrationId(),

                    getView().getCitationID(),

                    typifiedNameId

                    );

            popup.loadInEditor(identifierSet

                 );

        } else {

            // TypeDesignationWorkingSetType.NAME_TYPE_DESIGNATION_WORKINGSET

            // FIXME implement NameTypeDesignationWorkingsetPopupEditor

    /**

     * Performs final actions after a TypeDesignationEditor which has been

     * opened to add a TypeDesignation to a Registration object which was

     * created for an previously published name. Prior adding a typedesignation,

     * the according Registration object is dangling, that has no association to

     * any entity denoting an nomenclatural act which has a reference to a

     * publication. This means that the registration object is not in the

     * working set.

     *

     *

     * @param event

     * @throws RegistrationValidationException

     */

    @EventListener

    public void onDoneWithTypeDesignationEditor(DoneWithPopupEvent event) throws RegistrationValidationException{

        if(event.getPopup() instanceof SpecimenTypeDesignationWorkingsetPopupEditor){

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

                 refreshView();

            } else if(event.getReason().equals(Reason.CANCEL)){

                // clean up

                if(newRegistrationDTOWithExistingName != null){

                    getRegistrationStore().deleteBean(newRegistrationDTOWithExistingName.registration());

                }

            }

            // set newRegistrationDTOWithExistingName NULL in any case

            newRegistrationDTOWithExistingName = null;

        }

    }

import org.vaadin.viritin.fields.LazyComboBox;

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

import eu.etaxonomy.cdm.vaadin.event.TypeDesignationWorkingsetEditorAction;

    Button getAddNewNameRegistrationButton();

    /**

     * @return

     */

    Button getAddExistingNameRegistrationButton();

    public LazyComboBox<TaxonName> getAddExistingNameCombobox();

    /**

     * selecting a type will cause a {@link TypeDesignationWorkingsetEditorAction} to be emitted.

     * On Cancel .. TODO

     * @param registrationEntityId

     */

    void chooseNewTypeRegistrationWorkingset(Integer registrationEntityId);

import org.vaadin.viritin.fields.LazyComboBox;

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

import eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkflowEvent;

    private LazyComboBox<TaxonName> existingNameCombobox;

    // private Button addExistingNameRegistrationButton;

    private Button addExistingNameButton;

        Label addRegistrationLabel_1 = new Label("Add a new registration for a");

        Label addRegistrationLabel_2 = new Label("or an");

        addNewNameRegistrationButton.addClickListener(

                e -> eventBus.publishEvent(new TaxonNameEditorAction(Action.ADD, addNewNameRegistrationButton))

                );

        addExistingNameButton = new Button("existing name:");

        addExistingNameButton.setDescription("A name which was previously published in a earlier publication.");

        addExistingNameButton.setEnabled(false);

        addExistingNameButton.addClickListener(

                e -> eventBus.publishEvent(new RegistrationWorkflowEvent(citationID, RegistrationWorkflowEvent.Action.start))

                );

        existingNameCombobox = new LazyComboBox<TaxonName>(TaxonName.class);

        existingNameCombobox.addValueChangeListener(

                e -> addExistingNameButton.setEnabled(e.getProperty().getValue() != null)

                );

        HorizontalLayout buttonContainer = new HorizontalLayout(addRegistrationLabel_1, addNewNameRegistrationButton, addRegistrationLabel_2, addExistingNameButton, existingNameCombobox);

        buttonContainer.setComponentAlignment(addRegistrationLabel_1, Alignment.MIDDLE_LEFT);

        buttonContainer.setComponentAlignment(addRegistrationLabel_2, Alignment.MIDDLE_LEFT);

            if(editButtonGroup.getNameButton() != null){

            }

            for(TypeDesignationWorkingSetButton workingsetButton : editButtonGroup.getTypeDesignationButtons()){

                workingsetButton.getButton().addClickListener(e -> {

                    Integer typeDesignationWorkingsetId = workingsetButton.getId();

                    TypeDesignationWorkingSetType workingsetType = workingsetButton.getType();

                    Integer registrationEntityID = dto.getId();

                    getEventBus().publishEvent(new TypeDesignationWorkingsetEditorAction(

                            AbstractEditorAction.Action.EDIT,

                            typeDesignationWorkingsetId,

                            workingsetType,

                            registrationEntityID,

                            null, //e.getButton(), the listener method expects this to be null

                            this

                            )

                });

            editButtonGroup.getAddTypeDesignationButton().addClickListener(

                    e -> chooseNewTypeRegistrationWorkingset(dto.getId())

                    );

    @Override

    public void chooseNewTypeRegistrationWorkingset(Integer registrationEntityId) {

                e -> addNewTypeDesignationWorkingset(TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET, registrationEntityId, typeDesignationTypeCooser));

                e -> addNewTypeDesignationWorkingset(TypeDesignationWorkingSetType.NAME_TYPE_DESIGNATION_WORKINGSET, registrationEntityId, typeDesignationTypeCooser));

    protected void addNewTypeDesignationWorkingset(TypeDesignationWorkingSetType newWorkingsetType, Integer registrationEntityId, Window typeDesignationTypeCooser) {

        return addExistingNameButton;

    }

    @Override

    public LazyComboBox<TaxonName> getAddExistingNameCombobox() {

        return existingNameCombobox;