EDIT

    public SpecimenTypeDesignationWorkingSetDTO<Registration> create(UUID registrationUuid, UUID publicationUuid, UUID typifiedNameUuid) {

        FieldUnit newfieldUnit = FieldUnit.NewInstance();

        Registration reg = repo.getRegistrationService().load(registrationUuid, RegistrationWorkingSetService.REGISTRATION_DTO_INIT_STRATEGY);

        TaxonName typifiedName = repo.getNameService().load(typifiedNameUuid, TAXON_NAME_INIT_STRATEGY);

        Reference citation = repo.getReferenceService().load(publicationUuid, Arrays.asList("$"));

        SpecimenTypeDesignationWorkingSetDTO<Registration> workingSetDto = new SpecimenTypeDesignationWorkingSetDTO<Registration>(reg, newfieldUnit, citation, typifiedName);

        if(dto.getOwner() instanceof Registration){

            Registration regPremerge = (Registration) dto.getOwner();

            // find the newly created type designations

            Set<SpecimenTypeDesignation> newTypeDesignations = findNewTypeDesignations((SpecimenTypeDesignationWorkingSetDTO<Registration>) dto);

                addComponent(nameLabel);

            }

        }

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

            for(TypedEntityReference<TypeDesignationBase<?>> baseEntityRef : regDto.getOrderdTypeDesignationWorkingSets().keySet()) {

                TypeDesignationWorkingSet typeDesignationWorkingSet = regDto.getOrderdTypeDesignationWorkingSets().get(baseEntityRef);

        addComponent(addTypeDesignationButton);

        //TODO make responsive and use specificIdentifier in case the space gets too narrow

        iterator().forEachRemaining(c -> addStyledComponent(c));

        addDefaultStyles();

    private TypedEntityReference<IdentifiableEntity<?>> baseEntityRef;

    /**

     *

     * @param baseEntityRef

     * @param workingSetType

     * @param registrationId

     * @param source

     * @param sourceView

     */

            TypeDesignationWorkingSetType workingSetType,

            UUID registrationUuid, UUID typifiedNameUuid,

            Button source, Field<TypeDesignationWorkingSet> target, AbstractView sourceView, Stack<EditorActionContext> context) {

        this.baseEntityRef = baseEntityRef;

        this.registrationUuid = registrationUuid;

        this.typifiedNameUuid = typifiedNameUuid;

    }

    /**

     *

     * @param workingSetType

     * @param registrationUuid

     * @param source

     * @param sourceView

     */

            UUID registrationUuid, UUID typifiedNameUuid,

            Button source, Field<TypeDesignationWorkingSet> target, AbstractView sourceView) {

        this.workingSetType = workingSetType;

        this.registrationUuid = registrationUuid;

        this.typifiedNameUuid = typifiedNameUuid;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.transaction.TransactionStatus;

import org.vaadin.spring.events.EventScope;

import org.vaadin.spring.events.annotation.EventBusListenerMethod;

import com.vaadin.ui.AbstractField;

import com.vaadin.ui.Button;

import com.vaadin.ui.Label;

import com.vaadin.ui.UI;

import com.vaadin.ui.VerticalLayout;

import com.vaadin.ui.Window;

import eu.etaxonomy.cdm.api.service.dto.RegistrationDTO;

import eu.etaxonomy.cdm.api.service.dto.RegistrationWorkingSet;

import eu.etaxonomy.cdm.api.service.exception.RegistrationValidationException;

import eu.etaxonomy.cdm.api.service.name.TypeDesignationSetManager.TypeDesignationWorkingSetType;

import eu.etaxonomy.cdm.api.service.registration.IRegistrationWorkingSetService;

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

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

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

import eu.etaxonomy.cdm.persistence.hibernate.permission.CRUD;

import eu.etaxonomy.cdm.ref.EntityReference;

import eu.etaxonomy.cdm.ref.TypedEntityReference;

import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;

    @Autowired

    private IRegistrationWorkingSetService regWorkingSetService;

    @Autowired

    private IRegistrationMessageService messageService;

    private TaxonName newTaxonNameForRegistration = null;

    /**

     * If both checks are successful the method returns <code>true</code>.

     */

    public boolean canCreateNameRegistrationFor(TaxonName name) {

    }

    /**

        // @formatter:on

    }

    /**

     * @param doReload TODO

     *

    private void saveRegistrationStatusChange(UUID uuid, Object value) {

        Registration reg = getRepo().getRegistrationService().load(uuid);

        if(value != null && value instanceof RegistrationStatus){

            if(!Objects.equals(value, reg.getStatus())){

                reg.setStatus((RegistrationStatus)value);

                if(newTaxonNameForRegistration != null){

                    UUID taxonNameUuid = newTaxonNameForRegistration.getUuid();

                    getRepo().getSession().refresh(newTaxonNameForRegistration);

                    // reload workingset into current session

                    loadWorkingSet(workingset.getCitationUuid());

                    workingset.add(reg);

    /**

     *

     * @param event

     * @throws RegistrationValidationException

        getView().getAddExistingNameCombobox().commit(); // update the chosen value in the datasource

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

        if(typifiedName != null){

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

            // here we completely ignore the ExistingNameRegistrationType since the user should not have the choice

            // to create a typification only registration in the working (publication) set which contains

                // the citation which is the base for workingset contains the protologe of the name and the name has not

                // been registered before:

                // create a registration for the name and the first typifications

            } else {

                if(!checkWokingsetContainsProtologe(typifiedName)){

                    }

                }

            }

            // tell the view to update the workingset

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

                getView().getAddExistingNameCombobox().setEnabled(false);

                getView().getAddNewNameRegistrationButton().setEnabled(false);

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

                // propagate readonly state from source button to popup

                popup.setReadOnly(event.getSource().isReadOnly());

            }

        }

    }

            popup.setParentEditorActionContext(event.getContext());

            TypeDesignationWorkingsetEditorIdSet identifierSet;

            UUID typifiedNameUuid;

            } else {

                RegistrationDTO registrationDTO = workingset.getRegistrationDTO(event.getRegistrationUuid()).get();

                EntityReference typifiedNameRef = registrationDTO.getTypifiedNameRef();

            popup.setParentEditorActionContext(event.getContext());

            popup.withDeleteButton(true);

            popup.grantToCurrentUser(EnumSet.of(CRUD.UPDATE, CRUD.DELETE));

            popup.setBeanInstantiator(new BeanInstantiator<NameTypeDesignation>() {

                @Override

                    TaxonName typifiedName = getRepo().getNameService().load(event.getTypifiedNameUuid(), Arrays.asList(new String[]{"typeDesignations", "homotypicalGroup"}));

                    NameTypeDesignation nameTypeDesignation  = NameTypeDesignation.NewInstance();

                    nameTypeDesignation.getTypifiedNames().add(typifiedName);

                    return nameTypeDesignation;

                }

    public void onDoneWithTypeDesignationEditor(DoneWithPopupEvent event) throws RegistrationValidationException{

        if(event.getPopup() instanceof SpecimenTypeDesignationWorkingsetPopupEditor){

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

                refreshView(true);

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

                // noting to do

            }

        } else if(event.getPopup() instanceof NameTypeDesignationPopupEditor){

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

                refreshView(true);

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

                // noting to do

            }

        }

        // ignore other editors

    }

                Stack<EditorActionContext>context = ((AbstractPopupEditor)event.getSourceView()).getEditorActionContext();

                EditorActionContext rootContext = context.get(0);

                if(rootContext.getParentView().equals(getView())){

                    TypedEntityReference<Registration> regReference = (TypedEntityReference<Registration>)rootContext.getParentEntity();

                    Registration registration = getRepo().getRegistrationService().load(regReference.getUuid(), REGISTRATION_INIT_STRATEGY);

                    registration.getBlockedBy().add(blockingRegistration);

                EntityReference typifiedNameRef = typifiedNamesMap.get(registrationEntityUuid);

                TypeDesignationWorkingSetType workingsetType = workingsetButton.getType();

                getViewEventBus().publish(this, new TypeDesignationWorkingsetEditorAction(

                        baseEntityRef,

                        workingsetType,

                        registrationEntityUuid,

        UI.getCurrent().removeWindow(typeDesignationTypeCooser);

        EntityReference typifiedNameRef = typifiedNamesMap.get(registrationEntityUuid);

        getViewEventBus().publish(this, new TypeDesignationWorkingsetEditorAction(

                newWorkingsetType,

                registrationEntityUuid,

                typifiedNameRef.getUuid(),