/ - Diff - EDIT - EDIT Project Management

     /**
     * Copyright (C) 2019 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.data.validator;
     import com.vaadin.data.Validator;
     import eu.etaxonomy.cdm.model.name.TaxonName;
     import eu.etaxonomy.cdm.vaadin.model.name.NameRelationshipDTO;
     /**
      * Validates a {@link TaxonName} for existence of the nomenclatural reference.
+     *
      * Compatible with fields operating on {@link TaxonName}, {@link NameRelationshipDTO},
+     *
      * @author a.kohlbecker
      * @since Mar 27, 2019
+     *
      */
     public class NomenclaturalReferenceExistsValidator implements Validator {
         private static final long serialVersionUID = -7750232876262922982L;
         private String userHint = "";
         public NomenclaturalReferenceExistsValidator(String userHint){
             this.userHint = userHint;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void validate(Object value) throws InvalidValueException {
             if(value != null){
                 if(value instanceof TaxonName){
                     TaxonName name = (TaxonName)value;
                     validateName(name);
+                }
                 if(value instanceof NameRelationshipDTO){
                     NameRelationshipDTO nameRelDto = (NameRelationshipDTO)value;
                     validateName(nameRelDto.getOtherName());
+                }
+            }
+        }
         /**
          * @param name
          */
         public void validateName(TaxonName name) {
             if(name.getNomenclaturalReference() == null) {
                 throw new InvalidValueException("The taxon name must have a nomenclatural reference. " + userHint);
+            }
+        }
+    }

                         if(event.isCreateOrModifiedType()){
                             getCache().load(otherName);
                             if(event.isCreatedType()){
                                 // TODO use reloadWith((TaxonName) event.getEntity()); also in this case?
                                 otherNameField.setValue(otherName);
                             } else {
                                 otherNameField.reload();
                                 otherNameField.reloadWith(otherName);
+                            }
                         } else
-...
                         if(event.isCreateOrModifiedType()){
                             getCache().load(event.getEntity());
                             if(event.isCreatedType()){
                                 // TODO use reloadWith((TaxonName) event.getEntity()); also in this case?
                                 basionymSourceField .setValue((TaxonName) event.getEntity());
                             } else {
                                 basionymSourceField.reload();
                                 basionymSourceField.reloadWith((TaxonName) event.getEntity());
+                            }
                             getView().getBasionymAuthorshipField().discard(); //refresh from the datasource
                             getView().getExBasionymAuthorshipField().discard(); //refresh from the datasource
-...
                         if(event.isCreateOrModifiedType()){
                             getCache().load(event.getEntity());
                             if(event.isCreatedType()){
                                 // TODO use reloadWith((TaxonName) event.getEntity()); also in this case?
                                 replacedSynonyms .setValue((TaxonName) event.getEntity());
                             } else {
                                 replacedSynonyms.reload();
                                 replacedSynonyms.reloadWith((TaxonName) event.getEntity());
+                            }
                             getView().getExCombinationAuthorshipField().discard(); //refresh from the datasource
                             getView().updateAuthorshipFields();

     import eu.etaxonomy.cdm.vaadin.component.TextFieldNFix;
     import eu.etaxonomy.cdm.vaadin.component.common.FilterableAnnotationsField;
     import eu.etaxonomy.cdm.vaadin.component.common.TeamOrPersonField;
     import eu.etaxonomy.cdm.vaadin.data.validator.NomenclaturalReferenceExistsValidator;
     import eu.etaxonomy.cdm.vaadin.event.ReferenceEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorActionStrRep;
-...
                 nomReferenceCombobox.setDescription("Selection limited to nomenclatural reference and parts of it.");
+            }
             if(isModeEnabled(TaxonNamePopupEditorMode.REQUIRE_NOMENCLATURALREFERENCE)) {
                 if(combinationAuthorshipField.getValue() == null){
                     nomReferenceCombobox.setRequired(true);
                     nomReferenceCombobox.setImmediate(true);
                 } else {
                     combinationAuthorshipField.addValueChangeListener(e -> {
                         if(e.getProperty().getValue() == null){
                             nomReferenceCombobox.setRequired(true);
                             nomReferenceCombobox.setImmediate(true);
+                        }
                     });
+                }
                 nomReferenceCombobox.setRequired(true);
                 nomReferenceCombobox.setImmediate(true);
                 String userHint = "Please use the 'Edit' function to fix the problem in the related name.";
                 validationField.getRelatedNameComboBox().getSelect().addValidator(new NomenclaturalReferenceExistsValidator(userHint));
                 orthographicVariantField.getRelatedNameComboBox().getSelect().addValidator(new NomenclaturalReferenceExistsValidator(userHint));
                 basionymsComboboxSelect.addFieldValidator(new NomenclaturalReferenceExistsValidator(userHint));
                 replacedSynonymsComboboxSelect.addFieldValidator(new NomenclaturalReferenceExistsValidator(userHint));
+            }
+        }

         NOMENCLATURALREFERENCE_SECTION_EDITING_ONLY,
         /**
          * setting the nomenclatural reference is required with the exception
          * that existing data is considered complete if the combination
          * authors are set.
          * setting the nomenclatural reference is required. This also accounts for names realted to the name
          * being edites in the TaxonNamePopupEditor (basionyms, validation, replaced synonmys, ...).
          */
         REQUIRE_NOMENCLATURALREFERENCE,

src/main/java/eu/etaxonomy/vaadin/component/CompositeCustomField.java
267	267	triggerNestedButtonStateUpdaters();
268	268	}
269	269
	270
	271
270	272	/**
271	273	*
272	274	*/

             relatedNameComboBox = new ToOneRelatedEntityCombobox<TaxonName>(this.nameFieldCaption, TaxonName.class);
             citatonComboBox = new ToOneRelatedEntityCombobox<Reference>("Reference", Reference.class);
             setValidationVisible(false);
+        }
         /**

             discard(); // reload from property data source
+        }
         /**
          * Calls {@link #reload()} but checks is the <code>bean</code> passed as
          * parameter has a different caption than the bean which is currently selected.
+         *
          * Differences in the captions can occur for the same entity when the entity
          * has been modified through a popup edior.
+         *
          * @param bean
          */
         public void reloadWith(T bean){
             boolean reapplyBean = getCaption(bean).equals(getCaption(getValue()));
             reload();
             if(reapplyBean){
                 setValue(bean);
+            }
+        }
         /**
          * This method allows updating the value even if the equals check done

     import org.apache.log4j.Logger;
     import com.vaadin.data.Property;
     import com.vaadin.data.Validator;
     import com.vaadin.data.Validator.InvalidValueException;
     import com.vaadin.data.fieldgroup.FieldGroup;
     import com.vaadin.server.FontAwesome;
-...
         private boolean creatingFields;
         private List<Validator> fieldValidators = new ArrayList<>();
         public  ToManyRelatedEntitiesListSelect(Class<V> itemType, Class<F> fieldType, String caption){
             this.fieldType = fieldType;
             this.itemType = itemType;
-...
             return row;
+        }
         /**
+         *
          * @return an unmodifiable List of the data Fields
          */
         protected List<F> fields() {
             Integer row = null;
             List<F> fields = new ArrayList<>();
             for(int r = 0; r < grid.getRows(); r++){
                 fields.add((F) grid.getComponent(GRID_X_FIELD, r));
+            }
             return fields;
+        }
         /**
          * @param field
          * @return
-...
         protected int addNewRow(int row, V val) {
             try {
                 F field = newFieldInstance(val);
                 for(Validator validator : fieldValidators) {
                     field.addValidator(validator);
+                }
                 ButtonGroup buttonGroup = new ButtonGroup(field);
                 updateEditOrCreateButton(buttonGroup, val);
                 field.addValueChangeListener(e -> {
-...
             return field;
+        }
         /**
          * Adds the validator to the list of validators which
          * are applied to new fields and adds the validator to
          * existing fields
+         *
          * @param validator
          */
         public void addFieldValidator(Validator validator){
             fieldValidators.add(validator);
             for(F field : fields()) {
                 field.addValidator(validator);
+            }
+        }
         /**
          * removes the validator from the list of validators which
          * are applied to new fields and removes the validator from
          * existing fields
+         *
          * @param validator
          */
         public void removeFieldValidator(Validator validator){
             fieldValidators.remove(validator);
             for(F field : fields()) {
                 field.removeValidator(validator);
+            }
+        }
         /**
          * @return a unmodifialble List of the fieldValidators
          */
         public List<Validator> getFieldValidators() {
             return Collections.unmodifiableList(fieldValidators);
+        }
         /**
          * Handle the data binding of the sub fields. Sub-fields can either be composite editor fields
          * or 'simple' fields, usually select fields.

             this.type = type;
             setCaption(caption);
             lazySelect = new ReloadableLazyComboBox<V>(type);
             lazySelect.setValidationVisible(false); // validation is to be shown for the ToOneRelatedEntityCombobox
             lazySelect.setRequiredError("Must be given");
             setRequiredError("Must be given");
             addStyledComponents(lazySelect, addButton, editButton);
-...
                 lazySelect.commit();
             } catch (InvalidValueException ex){
                 UserError componentError = new UserError(ex.getHtmlMessage(), ContentMode.HTML, ErrorLevel.ERROR);
                 setComponentError(componentError);
                 lazySelect.setComponentError(componentError);
+            }
+        }

Project

General

Profile

EDIT

Revision 6062e4a0

Added by Andreas Kohlbecker about 5 years ago

Project

General

Profile

EDIT

Revision 6062e4a0

Added by Andreas Kohlbecker about 5 years ago

Related issues