EDIT

import org.springframework.transaction.TransactionStatus;

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

     * Checks

     * <ol>

     * <li>if there is NOT any registration for this name created in the current registration system</li>

     * <li>Checks if the name belongs to the current workingset</li>

     * </ol>

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

     */

    public boolean canCreateNameRegistrationFor(TaxonName name) {

        return !getRepo().getRegistrationService().checkRegistrationExistsFor(name) && checkWokingsetContainsProtologe(name);

    }

    /**

     * @param name

     * @return

     */

    public boolean checkWokingsetContainsProtologe(TaxonName name) {

        Reference nomRef = name.getNomenclaturalReference();

        UUID citationUuid = workingset.getCitationUuid();

        // @formatter:off

        return nomRef != null && (

                // nomref matches

                nomRef.getUuid().equals(citationUuid) ||

                // nomref.inreference matches

                (nomRef.getType() != null && nomRef.getType() == ReferenceType.Section && nomRef.getInReference() != null && nomRef.getInReference().getUuid().equals(citationUuid))

                );

        // @formatter:on

    }

                        // TODO move into a service class --------------

                        TransactionStatus txStatus = getRepo().startTransaction();

                        try {

                            UUID taxonNameUuid = newNameForRegistrationPopupEditor.getBean().getUuid();

                            if(newNameForRegistrationPopupEditor.getBean().cdmEntity().isPersited()){

                                getRepo().getSession().refresh(newNameForRegistrationPopupEditor.getBean().cdmEntity());

                            }

                            Registration reg = getRepo().getRegistrationService().createRegistrationForName(taxonNameUuid);

                            if(!newNameBlockingRegistrations.isEmpty()){

                                for(Registration blockingReg : newNameBlockingRegistrations){

                                    blockingReg = getRepo().getRegistrationService().load(blockingReg.getUuid());

                                    reg.getBlockedBy().add(blockingReg);

                                }

                                getRepo().getRegistrationService().saveOrUpdate(reg);

                                newNameBlockingRegistrations.clear();

                            }

                           getRepo().commitTransaction(txStatus);

                        } catch (Exception e){

                            getRepo().getTransactionManager().rollback(txStatus);

                            throw e;

                        }

                        // --------------------------------------------------

                        // reload workingset into current session

                // TODO move into a service class --------------

                TransactionStatus txStatus = getRepo().startTransaction(true);

                try {

                    Reference citation = getRepo().getReferenceService().load(workingset.getCitationUuid(), Arrays.asList("authorship.$", "inReference.authorship.$"));

                    // 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 protologe. This is known from the nomenclatural reference.

                    if(canCreateNameRegistrationFor(typifiedName)){

                        // 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

                        Registration newRegistrationWithExistingName = getRepo().getRegistrationService().createRegistrationForName(typifiedName.getUuid());

                        workingset.add(new RegistrationDTO(newRegistrationWithExistingName, typifiedName, citation));

                        doReloadWorkingSet = true;

                    } else {

                        if(!checkWokingsetContainsProtologe(typifiedName)){

                            // create a typification only registration

                            Registration typificationOnlyRegistration = getRepo().getRegistrationService().newRegistration();

                            if(!getRepo().getRegistrationService().checkRegistrationExistsFor(typifiedName)){

                                // oops, yet no registration for this name, so we create it as blocking registration:

                                Registration blockingNameRegistration = getRepo().getRegistrationService().createRegistrationForName(typifiedName.getUuid());

                                typificationOnlyRegistration.getBlockedBy().add(blockingNameRegistration);

                            }

                            RegistrationDTO regDTO = new RegistrationDTO(typificationOnlyRegistration, typifiedName, citation);

                            workingset.add(regDTO);

                        }

                    }

                    getRepo().commitTransaction(txStatus);

                } catch (Exception e){

                    getRepo().getTransactionManager().rollback(txStatus);

                    throw e;

                }

                // --------------------------------------------------

                // tell the view to update the workingset

                    // TODO move into a service class --------------

                    TransactionStatus txStatus = getRepo().startTransaction();

                    try {

                        UUID regUUID = nameTypeDesignationPopupEditorRegistrationUUIDMap.get(event.getPopup());

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

                        Registration registration = findRegistrationInContext(context);

                        getRepo().getRegistrationService().addTypeDesignation(registration, typeDesignationUuid);

                        getRepo().getRegistrationService().saveOrUpdate(registration);

                        nameTypeDesignationPopupEditorRegistrationUUIDMap.remove(event.getPopup());

                        getRepo().commitTransaction(txStatus);

                    } catch (Exception e){

                        getRepo().getTransactionManager().rollback(txStatus);

                        throw e;

                    }

                    // TODO move into a service class --------------

                        // TODO move into a service class --------------

                        TransactionStatus txStatus = getRepo().startTransaction();

                        try {

                            // create a blocking registration, the new Registration will be persisted

                            UUID taxonNameUUID = event.getEntityUuid();

                            if(context.get(1).getParentView() instanceof TaxonNamePopupEditor && !((TaxonNamePopupEditor)context.get(1).getParentView()).getBean().cdmEntity().isPersited()){

                                // Oha!! The event came from a popup editor and the

                                // first popup in the context is a TaxonNameEditor with un-persisted name

                                // This is a name for a new registration which has not yet been created.

                                // It is necessary to store blocking registrations in the newNameBlockingRegistrations

                                newNameBlockingRegistrations.add(blockingRegistration);

                                logger.debug("Blocking registration created and memorized");

                            } else {

                                // some new name somehow related to an existing registration

                                Registration registration = findRegistrationInContext(context);

                                registration.getBlockedBy().add(blockingRegistration);

                                if(registration.isPersited()){

                                    getRepo().getRegistrationService().saveOrUpdate(registration);

                                    logger.debug("Blocking registration created, added to registion and persited");

                                }

                            }

                            getRepo().commitTransaction(txStatus);

                        } catch (Exception e){

                            getRepo().getTransactionManager().rollback(txStatus);

                            throw e;

                        // TODO move into a service class --------------

        if(registration.isPersited()){

             registration = getRepo().getRegistrationService().load(registration.getUuid());

             if(registration == null){

                 throw new NullPointerException("Registration not found for " + regReference + " which has been hold in the rootContext");

             }

         } else {

             logger.trace("Registration is not yet persisted.");

         }