/ - Diff - EDIT - EDIT Project Management

src/main/java/eu/etaxonomy/cdm/vaadin/event/ToOneRelatedEntityReloader.java
87	87	onSettingReloadedEntity = false;
88	88	}
89	89	} else {
90		throw new RuntimeException("The cache must not be null. See loadBeanById() in AbstractCdmEditorPresenter");
	90	throw new RuntimeException("The cache must not be null. See loadBeanById() in CdmEditorPresenterBase");
91	91	}
92	92	}
93	93

src/main/java/eu/etaxonomy/cdm/vaadin/event/TypeDesignationWorkingsetEditorAction.java
78	78	this.context.push(new EditorActionContext(new TypedEntityReference<Registration>(Registration.class, registrationUuid), sourceView));
79	79	}
80	80
81
82
83		/**
84		*
85		* @return
86		*/
87	81	public TypeDesignationWorkingSetType getWorkingSetType() {
88	82	return workingSetType;
89	83	}
90	84
91		/**
92		* @return the registrationUuid
93		*/
94	85	public UUID getRegistrationUuid() {
95	86	return registrationUuid;
96	87	}
...	...
99	90	return getEntityUuid();
100	91	}
101	92
102		/**
103		* @return the baseEntityRef
104		*/
105	93	public TypedEntityReference<IdentifiableEntity<?>> getBaseEntityRef() {
106	94	return baseEntityRef;
107	95	}
108	96
109		/**
110		* @return the typifiedNameUuid
111		*/
112	97	public UUID getTypifiedNameUuid() {
113	98	return typifiedNameUuid;
114	99	}
115	100
116
117	101	}

     */
     package eu.etaxonomy.cdm.vaadin.view.name;
     import java.util.Optional;
     import com.vaadin.ui.NativeSelect;
     import eu.etaxonomy.cdm.model.name.TaxonName;
     import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;
     import eu.etaxonomy.cdm.model.reference.Reference;
     import eu.etaxonomy.cdm.vaadin.view.AnnotationsEditor;
     import eu.etaxonomy.vaadin.component.ToManyRelatedEntitiesComboboxSelect;
-...
         boolean isShowTypeFlags();
         /**
          * possible values:
+         *
          * <ul>
          * <li>NULL: undecided, should be treated like <code>false</code>. This can happen in cases when the typified name is missing the nomref</li>
          * <li>false: the typification is published in an nomenclatural act in which no new name or new combination is being published.
          * The available {@link TypeDesignationStatusBase} should be limited to those with
          * <code>{@link TypeDesignationStatusBase#hasDesignationSource() hasDesignationSource} == true</code></li>
          * <li>true: only status with <code>{@link TypeDesignationStatusBase#hasDesignationSource() hasDesignationSource} == true</li>
          * </ul>
          */
         public void setInTypedesignationOnlyAct(Optional<Boolean> isInTypedesignationOnlyAct);
         /**
          * possible values:
+         *
          * <ul>
          * <li>NULL: undecided, should be treated like <code>false</code>. This can happen in cases when the typified name is missing the nomref</li>
          * <li>false: the typification is published in an nomenclatural act in which no new name or new combination is being published.
          * The available {@link TypeDesignationStatusBase} should be limited to those with
          * <code>{@link TypeDesignationStatusBase#hasDesignationSource() hasDesignationSource} == true</code></li>
          * <li>true: only status with <code>{@link TypeDesignationStatusBase#hasDesignationSource() hasDesignationSource} == true</li>
          * </ul>
          */
         public Optional<Boolean> isInTypedesignationOnlyAct();
+    }

     */
     package eu.etaxonomy.cdm.vaadin.view.name;
     import java.util.Optional;
     import org.springframework.context.annotation.Scope;
     import com.vaadin.spring.annotation.SpringComponent;
-...
     public class NameTypeDesignationPopupEditor extends AbstractCdmPopupEditor<NameTypeDesignation, NameTypeDesignationPresenter>
         implements NameTypeDesignationEditorView {
         private static final String TYPE_STATUS_OR_FLAG_MUST_BE_SET = "Either \"Type status\" must be set or any of the \"Conserved type\", \"Rejected type\" or \"Not designated\" flags must be set.";
         private static final String TYPE_STATUS_MUST_BE_SET = "\"Type status\" must be set.";
         private static final long serialVersionUID = 8233876984579344340L;
         private static final int GRID_COLS = 4;
-...
         private boolean showTypeFlags = true;
         Optional<Boolean> inTypedesignationOnlyAct = Optional.empty();
         private FilterableAnnotationsField annotationsListField;
-...
             typeStatusSelect.setNullSelectionAllowed(false);
             typeStatusSelect.setWidth(100, Unit.PERCENTAGE);
             typeStatusSelect.setRequired(true);
             typeStatusSelect.setRequiredError("Either \"Type status\" must be set or any of the \"Conserved type\", \"Rejected type\" or \"Not designated\" flags must be set.");
             typeStatusSelect.setRequiredError(TYPE_STATUS_OR_FLAG_MUST_BE_SET);
             addField(typeStatusSelect, "typeStatus", 0, row, 1, row);
             grid.setComponentAlignment(typeStatusSelect, Alignment.TOP_RIGHT);
             typeStatusSelect.addValueChangeListener(e -> {
-...
             boolean hasDesignationSource = typeStatusSelect.getValue() != null && ((NameTypeDesignationStatus)typeStatusSelect.getValue()).hasDesignationSource();
             designationReferenceDetailField.setVisible(hasDesignationSource);
             designationReferenceCombobox.setVisible(hasDesignationSource);
             designationReferenceCombobox.setRequired(hasDesignationSource);
             // NOTE: For better usability we only hide these fields here,
             // NameTypeDesignationPresenter.preSaveBean(NameTypeDesignation bean) will empty them in needed
             boolean typeStatusRequired = !(conservedTypeField.getValue().booleanValue() || rejectedTypeField.getValue().booleanValue() || notDesignatedField.getValue().booleanValue());
             typeStatusSelect.setRequired(typeStatusRequired);
             boolean isInTypedesignationOnlyAct = !isInTypedesignationOnlyAct().isPresent() || isInTypedesignationOnlyAct().get();
             boolean typeStatusRequired = !(conservedTypeField.getValue().booleanValue()
                     || rejectedTypeField.getValue().booleanValue()
                     || notDesignatedField.getValue().booleanValue());
             // need to check for isInTypedesignationOnlyAct also, otherwise the reference field will not show up
             // and the type designation might not be associated with the registration
             // TODO discuss with Henning
             typeStatusSelect.setRequired(typeStatusRequired || isInTypedesignationOnlyAct);
             if(typeStatusRequired && isInTypedesignationOnlyAct) {
                 designationReferenceCombobox.setRequiredError(TYPE_STATUS_MUST_BE_SET);
             } else {
                 designationReferenceCombobox.setRequiredError(TYPE_STATUS_OR_FLAG_MUST_BE_SET);
+            }
+        }
         /**
          * @return the typeNameField
          */
         @Override
         public ToOneRelatedEntityCombobox<TaxonName> getTypeNameField() {
             return typeNameField;
+        }
         /**
          * @return the typifiedNamesComboboxSelect
          */
         @Override
         public ToManyRelatedEntitiesComboboxSelect<TaxonName> getTypifiedNamesComboboxSelect() {
             return typifiedNamesComboboxSelect;
+        }
         /**
          * @return the typeStatusSelect
          */
         @Override
         public NativeSelect getTypeStatusSelect() {
             return typeStatusSelect;
+        }
         /**
          * @return the citationCombobox
          */
         @Override
         public ToOneRelatedEntityCombobox<Reference> getDesignationReferenceCombobox() {
             return designationReferenceCombobox;
+        }
         /**
          * @return the showTypeFlags
          */
         @Override
         public boolean isShowTypeFlags() {
             return showTypeFlags;
+        }
         /**
          * @param showTypeFlags the showTypeFlags to set
          */
         @Override
         public void setShowTypeFlags(boolean showTypeFlags) {
             this.showTypeFlags = showTypeFlags;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public AnnotationType[] getEditableAnotationTypes() {
             return editableAnotationTypes;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void setEditableAnotationTypes(AnnotationType... editableAnotationTypes) {
             this.editableAnotationTypes = editableAnotationTypes;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public FilterableAnnotationsField getAnnotationsField() {
             return annotationsListField;
+        }
         @Override
         public void setInTypedesignationOnlyAct(Optional<Boolean> isInTypedesignationOnlyAct) {
             this.inTypedesignationOnlyAct = isInTypedesignationOnlyAct;
+        }
         @Override
         public Optional<Boolean> isInTypedesignationOnlyAct() {
             return inTypedesignationOnlyAct;
+        }
+    }

     import eu.etaxonomy.cdm.api.service.DeleteResult;
     import eu.etaxonomy.cdm.api.service.IService;
     import eu.etaxonomy.cdm.api.service.dto.RegistrationDTO;
     import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet;
     import eu.etaxonomy.cdm.api.service.registration.IRegistrationWorkingSetService;
     import eu.etaxonomy.cdm.api.service.registration.RegistrationWorkingSetService;
     import eu.etaxonomy.cdm.format.reference.ReferenceEllypsisFormatter;
     import eu.etaxonomy.cdm.format.reference.ReferenceEllypsisFormatter.LabelType;
     import eu.etaxonomy.cdm.model.common.Annotation;
-...
     import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
     import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
     import eu.etaxonomy.cdm.model.name.TaxonName;
     import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;
     import eu.etaxonomy.cdm.model.permission.CRUD;
     import eu.etaxonomy.cdm.model.reference.Reference;
     import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
-...
         @Autowired
         private IRegistrationWorkingSetService registrationWorkingSetService;
         HashSet<TaxonName> typifiedNamesAsLoaded;
         private TaxonName typifiedNameInContext;
-...
          */
         private DescriptionElementSource publishedUnit;
         /**
          * possible values:
+         *
          * <ul>
          * <li>NULL: undecided, should be treaded like <code>false</code></li>
          * <li>false: the typification is published in an nomenclatural act in which no new name or new combination is being published.
          * The available {@link TypeDesignationStatusBase} should be limited to those with
          * <code>{@link TypeDesignationStatusBase#hasDesignationSource() hasDesignationSource} == true</code></li>
          * <li>true: only status with <code>{@link TypeDesignationStatusBase#hasDesignationSource() hasDesignationSource} == true</li>
          * </ul>
          */
         private Optional<Boolean> isInTypedesignationOnlyAct = Optional.empty();
         protected static BeanInstantiator<NameTypeDesignation> defaultBeanInstantiator = new BeanInstantiator<NameTypeDesignation>() {
             @Override
-...
            return defaultBeanInstantiator;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         protected NameTypeDesignation loadBeanById(Object identifier) {
             NameTypeDesignation bean;
             NameTypeDesignationWorkingsetIds idset = (NameTypeDesignationWorkingsetIds)identifier;
             RegistrationDTO regDTO = registrationWorkingSetService.loadDtoByUuid(idset.registrationUuid);
             typifiedNameInContext = regDTO.typifiedName();
             // find the working set
             if(idset.baseEntityRef != null) {
                 TypeDesignationWorkingSet typeDesignationWorkingSet = regDTO.getTypeDesignationWorkingSet(idset.baseEntityRef);
                 if(!typeDesignationWorkingSet.getBaseEntityReference().getType().equals(NameTypeDesignation.class)){
                     throw new RuntimeException("TypeDesignationWorkingsetEditorIdSet references not a NameTypeDesignation");
                 } else {
                     // TypeDesignationWorkingSet for NameTyped only contain one item!!!
                     UUID nameTypeDesignationUuid = typeDesignationWorkingSet.getTypeDesignations().get(0).getUuid();
                     bean = super.loadBeanById(nameTypeDesignationUuid);
             if(idset.isForNewTypeDesignation()) {
                 Reference reference = getRepo().getReferenceService().load(idset.getPublishedUnitUuid());
                 try {
                     setPublishedUnit(DescriptionElementSource.NewPrimarySourceInstance(reference, null));
                 } catch(Exception e) {
                     throw new RuntimeException("Refernce of invalid type passed via NameTypeDesignationWorkingsetIds as publishedUnitUuid ", e);
+                }
                 EntityInitStrategy initstrategy = RegistrationWorkingSetService.NAME_INIT_STRATEGY
                         .clone()
                         .extend("typeDesignations", RegistrationWorkingSetService.TYPEDESIGNATION_INIT_STRATEGY, true);
                 typifiedNameInContext = getRepo().getNameService().load(idset.getTypifiedNameUuid(), initstrategy.getPropertyPaths());
                 bean = super.loadBeanById(null);
             } else {
                bean = super.loadBeanById(null);
                 bean = super.loadBeanById(idset.getBaseEntityRef().getUuid());
                 // TODO prevent from errors due to inconsistent data, two options:
                 // 1. handle error condition here
                 // 2. always set typifiedNameUuid in NameTypeDesignationWorkingsetIds
                 typifiedNameInContext = bean.getTypifiedNames().iterator().next();
                 try {
                     setPublishedUnit(bean.getTypifiedNames().iterator().next().getNomenclaturalSource());
                 } catch (Exception e) {
                     // FIXME report error state instead
                     logger.error("Error on finding published unit in " + bean, e);
+                }
+            }
             isInTypedesignationOnlyAct = Optional.of(Boolean.valueOf(regDTO.getNameRef() == null));
             try {
                 setPublishedUnit(bean.getTypifiedNames().iterator().next().getNomenclaturalSource());
             } catch (Exception e) {
                 // FIXME report error state instead
                 logger.error("Error on finding published unit in " + bean, e);
             Reference typifiedNameNomRef = typifiedNameInContext.getNomenclaturalReference();
             while(typifiedNameNomRef.getType().equals(ReferenceType.Section)
                     || typifiedNameNomRef.getInReference() == null) {
                 typifiedNameNomRef = typifiedNameNomRef.getInReference();
+            }
             getView().setInTypedesignationOnlyAct(Optional.of(typifiedNameNomRef != null && !typifiedNameNomRef.equals(getPublishedUnit().getCitation())));
             if (getPublishedUnit() != null) {
                 // reduce available references to those which are sections of
-...
                 referencePagingProvider.getCriteria()
                         .add(Restrictions.or(
                                 Restrictions.and(
                                         Restrictions.eq("inReference", publishedUnit.getCitation()),
                                         Restrictions.eq("inReference", getPublishedUnit().getCitation()),
                                         Restrictions.eq("type", ReferenceType.Section)),
                                 Restrictions.idEq(publishedUnit.getCitation().getId()))
                              );
-...
                     @Override
                     public Reference createNewBean() {
                         Reference newRef = ReferenceFactory.newSection();
                         newRef.setInReference(publishedUnit.getCitation());
                         newRef.setInReference(getPublishedUnit().getCitation());
                         return newRef;
+                    }
                 };
-...
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         protected NameTypeDesignation loadCdmEntity(UUID uuid) {
             EntityInitStrategy initStrategy = new EntityInitStrategy(Arrays.asList(new String []{
-...
         protected BeanItemContainer<NameTypeDesignationStatus> provideTypeStatusTermItemContainer() {
             Optional<Boolean> isInTypedesignationOnlyAct = getView().isInTypedesignationOnlyAct();
             BeanItemContainer<NameTypeDesignationStatus> container = cdmBeanItemContainerFactory.buildBeanItemContainer(NameTypeDesignationStatus.class);
             List<NameTypeDesignationStatus> filteredItems = container.getItemIds().stream().filter(tsb ->
                         !isInTypedesignationOnlyAct.isPresent()

      */
     public class NameTypeDesignationWorkingsetIds extends TypeDesignationWorkingsetIds<NameTypeDesignation> {
         public NameTypeDesignationWorkingsetIds(UUID registrationUuid, TypedEntityReference<NameTypeDesignation> baseEntityRef) {
             super(registrationUuid, baseEntityRef, null);
         public static NameTypeDesignationWorkingsetIds forNewTypeDesignation(UUID publishedUnitUuid, UUID typifiedNameUuid) {
             return new NameTypeDesignationWorkingsetIds(publishedUnitUuid, typifiedNameUuid);
+        }
         public NameTypeDesignationWorkingsetIds(UUID registrationUuid, UUID typifiedNameUuid) {
             super(registrationUuid, null, typifiedNameUuid);
         public static Object forExistingTypeDesignation(UUID publishedUnitUuid, TypedEntityReference<NameTypeDesignation> baseEntityRef) {
             return new NameTypeDesignationWorkingsetIds(publishedUnitUuid, baseEntityRef);
+        }
         private NameTypeDesignationWorkingsetIds(UUID publishedUnitUuid, TypedEntityReference<NameTypeDesignation> baseEntityRef) {
             super(null, baseEntityRef, null);
             this.publishedUnitUuid = publishedUnitUuid;
+        }
         private NameTypeDesignationWorkingsetIds(UUID publishedUnitUuid, UUID typifiedNameUuid) {
             super(null, null, typifiedNameUuid);
             this.publishedUnitUuid = publishedUnitUuid;
+        }
         /**
          * @return
          */
         public boolean isForNewTypeDesignation() {
             return getBaseEntityRef() == null;
+        }
+    }

         protected UUID registrationUuid;
         protected TypedEntityReference<BASE_T> baseEntityRef;
         protected UUID typifiedNameUuid;
         /**
          * The UUID of the article, book, book section in which the type designation is being published.
          * Never a section. This information is only relevant for type designation to be initially created.
          */
         protected UUID publishedUnitUuid;
         public TypeDesignationWorkingsetIds(UUID registrationUuid, TypedEntityReference<BASE_T> baseEntityRef, UUID typifiedNameUuid) {
             this.registrationUuid = registrationUuid;
-...
             return baseEntityRef;
+        }
         public UUID getPublishedUnitUuid() {
             return publishedUnitUuid;
+        }
+    }

         private List<Registration> newNameBlockingRegistrations = new ArrayList<>();
         /**
          * TODO is this still needed? The regitration UUID should be accessible in the popup editor context,
          * TODO is this still needed? The registration UUID should be accessible in the popup editor context,
          * see findRegistrationInContext()
          */
         private Map<NameTypeDesignationPopupEditor, UUID> nameTypeDesignationPopupEditorRegistrationUUIDMap = new HashMap<>();
-...
                 return;
+            }
             RegistrationDTO registrationDTO = workingset.getRegistrationDTO(event.getRegistrationUuid()).get();
             if(event.getWorkingSetType() == TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET ){
                 SpecimenTypeDesignationWorkingsetPopupEditor popup = openPopupEditor(SpecimenTypeDesignationWorkingsetPopupEditor.class, event);
                 popup.setParentEditorActionContext(event.getContext(), event.getTarget());
-...
                 NameTypeDesignationPopupEditor popup = openPopupEditor(NameTypeDesignationPopupEditor.class, event);
                 popup.setParentEditorActionContext(event.getContext(), event.getTarget());
                 popup.withDeleteButton(true);
                 popup.loadInEditor(new NameTypeDesignationWorkingsetIds(
                         event.getRegistrationUuid(),
                 popup.loadInEditor(NameTypeDesignationWorkingsetIds.forExistingTypeDesignation(
                         registrationDTO.getCitationUuid(),
                         event.getBaseEntityRef().castTo(NameTypeDesignation.class))
                         );
                 popup.getTypifiedNamesComboboxSelect().setEnabled(false);
-...
                 return;
+            }
             RegistrationDTO registrationDTO = workingset.getRegistrationDTO(event.getRegistrationUuid()).get();
             if(event.getWorkingSetType() == TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET){
                 SpecimenTypeDesignationWorkingsetPopupEditor popup = openPopupEditor(SpecimenTypeDesignationWorkingsetPopupEditor.class, event);
                 popup.setParentEditorActionContext(event.getContext(), event.getTarget());
                 UUID typifiedNameUuid;
                 RegistrationDTO registrationDTO = workingset.getRegistrationDTO(event.getRegistrationUuid()).get();
                 TypedEntityReference<TaxonName> typifiedNameRef;
                 if(registrationDTO.getTypifiedNameRef() != null){
                     // case for registrations without name, in which case the typifiedName is only defined via the typedesignations
-...
+                    }
                 });
                 popup.withDeleteButton(false);
                 popup.loadInEditor(new NameTypeDesignationWorkingsetIds(
                         event.getRegistrationUuid(),
                 popup.loadInEditor(NameTypeDesignationWorkingsetIds.forNewTypeDesignation(
                         registrationDTO.getCitationUuid(),
                         event.getTypifiedNameUuid()
+                        )
                     );

         /**
          * Load the bean to be edited in the editor freshly from the persistent storage.
          * Ore create an new empty instance in case the supplied <code>identifier</code> is <code>null</code>.
          * Or create an new empty instance in case the supplied <code>identifier</code> is <code>null</code>.
+         *
          * @param identifier
          * @return

             return context;
+        }
         /**
          * Attempts to find an item in the context of editor actions for this editor,
          * having a parentView matching the <code>viewType</code> by {@link Class#isAssignableFrom(Class)}.
          */
         @SuppressWarnings("unchecked")
         public <VIEW extends AbstractView> Optional<VIEW> findViewInEditorActionContext(Class<VIEW> viewType) {
             Stack<EditorActionContext> ctxt = getEditorActionContext();
             for(int i = ctxt.size(); i > 0; --i) {
                 if(viewType.isAssignableFrom(ctxt.get(i).getParentView().getClass())){
                     return Optional.of((VIEW) ctxt.get(i).getParentView());
+                }
+            }
             return Optional.empty();
+        }
         /**
          * Set the context of editor actions parent to this editor
+         *

                     guaranteePerEntityCRUDPermissions(cdmEntitiy);
+                }
+            }
             DTO dto = initializeCache(cdmEntitiy);
             return dto;
+        }
         /**
          * @param cdmEntitiy the CDM entity to initialize the cache with.
          */
         protected final DTO initializeCache(CDM cdmEntitiy) {
             cache = new CdmTransientEntityAndUuidCacher(this);
             // need to use load but put see #7214
             cdmEntitiy = cache.load(cdmEntitiy);
             addRootEntity(cdmEntitiy);
             DTO dto = createDTODecorator(cdmEntitiy);
             return dto;
+        }

Project

General

Profile

EDIT

Revision bd6037c5

Added by Andreas Kohlbecker about 3 years ago

Project

General

Profile

EDIT

Revision bd6037c5

Added by Andreas Kohlbecker about 3 years ago

Related issues