com.vaadin.data.Validator.InvalidValueException Java Examples

public boolean isValid(TextField field, String newValue) {
    boolean valid = true;

    if (StringUtils.isBlank(newValue)) {
        if (field.isRequired()) {
            valid = false;
        }
    } else {
        for (Validator v : field.getValidators()) {
            try {
                v.validate(newValue);
            } catch (InvalidValueException e) {
                valid = false;
                logger.warn(e.getMessage());
                answerField.setComponentError(new UserError(e.getMessage()));
            }
        }
    }
    if (valid) {
        answerField.setComponentError(null);
    }
    return valid;
}
 

protected void initializeButton() {
	self.buttonSave.addClickListener(new ClickListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void buttonClick(ClickEvent event) {
			try {
				//
				// Commit
				//
				self.textFieldColumn.commit();
				//
				// If we get here, the value is valid.
				// Mark ourselves as saved and close the window
				//
				self.isSaved = true;
				self.close();
			} catch (SourceException | InvalidValueException e) {
				//
				// Vaadin will display error
				//
			}
		}
	});
}
 

@Override
public void commit() throws SourceException, InvalidValueException {
	if (this.mainLayout.getComponentCount() == 0) {
		return;
	}
	Component c = this.mainLayout.getComponent(0);
	if (c instanceof SQLPIPConfigurationComponent) {
		((SQLPIPConfigurationComponent)c).commit();
	} else if (c instanceof LDAPPIPConfigurationComponent) {
		((LDAPPIPConfigurationComponent)c).commit();
	} else if (c instanceof CSVPIPConfigurationComponent) {
		((CSVPIPConfigurationComponent)c).commit();
	} else if (c instanceof HyperCSVPIPConfigurationComponent) {
		((HyperCSVPIPConfigurationComponent)c).commit();
	} else if (c instanceof CustomPIPConfigurationComponent) {
		((CustomPIPConfigurationComponent)c).commit();
	}
	super.commit();
}
 

@Override
public void validate() throws InvalidValueException {
	if (this.mainLayout.getComponentCount() == 0) {
		return;
	}
	Component c = this.mainLayout.getComponent(0);
	if (c instanceof SQLPIPConfigurationComponent) {
		((SQLPIPConfigurationComponent)c).validate();
	} else if (c instanceof LDAPPIPConfigurationComponent) {
		((LDAPPIPConfigurationComponent)c).validate();
	} else if (c instanceof CSVPIPConfigurationComponent) {
		((CSVPIPConfigurationComponent)c).validate();
	} else if (c instanceof HyperCSVPIPConfigurationComponent) {
		((HyperCSVPIPConfigurationComponent)c).validate();
	} else if (c instanceof CustomPIPConfigurationComponent) {
		((CustomPIPConfigurationComponent)c).validate();
	}
	super.validate();
}
 

protected void doSave() {
	try {
		//
		// Commit changes
		//
		self.tableFunctions.commit();
		//
		// We are saved
		//
		self.isSaved = true;
		//
		// Close the window
		//
		self.close();
	} catch (SourceException | InvalidValueException e) {
		//
		// Nothing to do, Vaadin highlights
		//
	}
}
 

protected void doSave() {
	try {
		//
		// Commit changes
		//
		self.tableFunctions.commit();
		//
		// We are saved
		//
		self.isSaved = true;
		//
		// Close the window
		//
		self.close();
	} catch (SourceException | InvalidValueException e) {
		return;
	}
}
 

protected void initializeButton() {
	this.buttonSave.setClickShortcut(KeyCode.ENTER);
	this.buttonSave.addClickListener(new ClickListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void buttonClick(ClickEvent event) {
			try {
				//
				// Commit it
				//
				self.textFieldID.commit();
				//
				// Save it
				//
				self.variable.setVariableId(self.textFieldID.getValue());
				self.isSaved = true;
				//
				// Close window
				//
				self.close();
			} catch (SourceException | InvalidValueException e) {
			}
		}			
	});
}
 

protected void initializeButtons() {
	this.buttonSave.setClickShortcut(KeyCode.ENTER);
	this.buttonSave.setEnabled(false);
	this.buttonSave.addClickListener(new ClickListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void buttonClick(ClickEvent event) {
			try {
				//
				// Make sure the text is valid
				//
				self.textFieldSubdomain.validate();
				//
				// Parse our the subdomain parts
				//
				self.subdomain = self.textFieldSubdomain.getValue();
				self.saved = true;
				//
				// Close it up
				//
				self.close();
			} catch (InvalidValueException e) {
				logger.error(e);
			}
		}
		
	});
}
 

@SuppressWarnings("serial")
private Validator getMaxValueValidator() {
	return new Validator() {

		@Override
		public void validate(Object value) throws InvalidValueException {
			String v = (String) value;

			// empty is ok
			if (v.isEmpty()) {
				return;
			}

			// integer
			ParameterType t = (ParameterType) type.getValue();
			if (t == ParameterType.INTEGER) {
				// must be integer
				int maxValueInt = getInt(v);

				// if min value exists, must be equal or greater
				isGreaterOrEqualToMinValueInt(maxValueInt);

				// TODO check default after max change
			} 

			
			// DECIMAL
			else if (t == ParameterType.DECIMAL) {
				double maxValueDouble = getDouble(v);
				isGreaterOrEqualToMinValueDouble(maxValueDouble);
			}
		}
	};
}
 

private void initializeTestPanel() {
	this.textFieldTestValue.setNullRepresentation("");
	
	this.buttonTest.addClickListener(new ClickListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void buttonClick(ClickEvent event) {
			String testValue = self.textFieldTestValue.getValue();
			if (testValue == null || testValue.length() == 0) {
				return;
			}
			String regExp = self.textFieldExpression.getValue();
			if (regExp == null || regExp.length() == 0) {
				return;
			}
			//
			// Create a validator
			//
			Validator validator = new RegexpValidator(regExp, true, "Regular Expression does NOT match.");
			//
			// Add it
			//
			self.textFieldTestValue.addValidator(validator);
			//
			// Validate
			//
			try {
				self.textFieldTestValue.validate();
				AdminNotification.info("Success! Regular Expression Matches");
			} catch (InvalidValueException e) {
				AdminNotification.warn("Failed, Regular Expression does NOT match");
			}
			//
			// Remove the validator
			//
			self.textFieldTestValue.removeValidator(validator);
		}
	});
}
 

public void validate() throws InvalidValueException {
	if (logger.isDebugEnabled()) {
		logger.debug("validate");
	}
	this.textFieldFile.validate();
	this.textFieldDelimiter.validate();
	this.textFieldQuote.validate();
	this.textFieldSkip.validate();
}
 

public void commit() throws SourceException, InvalidValueException {
	if (logger.isDebugEnabled()) {
		logger.debug("commit");
	}
	this.textFieldFile.commit();
	this.textFieldDelimiter.commit();
	this.textFieldQuote.commit();
	
	if (this.textFieldSkip.getValue() == null || this.textFieldSkip.getValue().isEmpty()) {
		this.entity.getEntity().removePipconfigParam((PIPConfigParam) this.textFieldSkip.getData());
		this.textFieldSkip.setData(null);
	}
	this.textFieldSkip.commit();
}
 

public void validate() throws InvalidValueException {
	if (logger.isDebugEnabled()) {
		logger.debug("validate");
	}
	this.comboBoxConnectionType.validate();
	this.textFieldDataSource.validate();
	this.textFieldConnectionURL.validate();
	this.comboBoxSQLDriver.validate();
	this.textFieldPassword.validate();
	this.textFieldUser.validate();
}
 

public void commit()  throws SourceException, InvalidValueException {
	if (logger.isDebugEnabled()) {
		logger.debug("commit");
	}
	this.comboBoxConnectionType.commit();
	
	Object id = this.comboBoxConnectionType.getValue();
	if (id == null) {
		logger.warn("Can't reset combo hasn't selected anything.");
		return;
	}
	if (id.toString().equals(SQL_TYPE_JDBC)) {
		this.textFieldConnectionURL.commit();
		this.comboBoxSQLDriver.commit();
		this.textFieldPassword.commit();
		this.textFieldUser.commit();
		
		this.textFieldDataSource.setData(null);
		this.entity.getEntity().getPipconfigParams().remove(SQL_DATASOURCE);

	} else if (id.toString().equals(SQL_TYPE_JNDI)) {

		this.textFieldDataSource.commit();

		this.textFieldConnectionURL.setData(null);
		this.comboBoxSQLDriver.setData(null);
		this.textFieldPassword.setData(null);
		this.textFieldUser.setData(null);
		/* ???
		this.entity.getEntity().getPipconfigParams().remove(SQL_TYPE);
		this.entity.getEntity().getPipconfigParams().remove(SQL_DRIVER);
		this.entity.getEntity().getPipconfigParams().remove(SQL_URL);
		this.entity.getEntity().getPipconfigParams().remove(SQL_USER);
		this.entity.getEntity().getPipconfigParams().remove(SQL_PASSWORD);
		*/
	}
}
 

public void validate() throws InvalidValueException {
	if (logger.isDebugEnabled()) {
		logger.debug("validate");
	}
	this.comboBoxAuthentication.validate();
	this.textFieldFactory.validate();
	this.textFieldProviderURL.validate();
	this.textFieldPrincipal.validate();
	this.textFieldCredentials.validate();
	this.textFieldScope.validate();
}
 

public void commit() throws SourceException, InvalidValueException {
	if (logger.isDebugEnabled()) {
		logger.debug("commit");
	}
	this.comboBoxAuthentication.commit();
	this.textFieldFactory.commit();
	this.textFieldProviderURL.commit();
	this.textFieldPrincipal.commit();
	this.textFieldCredentials.commit();
	this.textFieldScope.commit();
}
 

public void validate() throws InvalidValueException {
	if (logger.isDebugEnabled()) {
		logger.debug("validate");
	}
	this.textFieldSource.validate();
	this.textFieldTarget.validate();
	this.textFieldDefinition.validate();
}
 

public void commit() throws SourceException, InvalidValueException {
	if (logger.isDebugEnabled()) {
		logger.debug("commit");
	}
	this.textFieldSource.commit();
	this.textFieldTarget.commit();
	this.textFieldDefinition.commit();
}
 

/**
 * @throws InvalidValueException if min value exists and i is smaller than min value
 * @param i
 */
private void isGreaterOrEqualToMinValueDouble(double d) {
	if (!minValue.getValue().isEmpty()) {
		try {
			double minValueDouble = Double.parseDouble(minValue.getValue());
			if (d < minValueDouble) {
				throw new InvalidValueException("Smaller than minimum value");
			}
		} catch (NumberFormatException e) {
			// ignore rubbish min value
		}
	}
}
 

/**
 * @throws InvalidValueException if max value exists and i is greater than max value
 * @param i
 */
private void isSmallerOrEqualToMaxValueInt(int i) {
	if (!maxValue.getValue().isEmpty()) {
		try {
			int maxValueInt = Integer.parseInt(maxValue.getValue());
			if (i > maxValueInt) {
				throw new InvalidValueException("Greater than maximum value");
			}
		} catch (NumberFormatException e) {
			// ignore rubbish max value
		}
	}
}
 

@Override
public void validate() throws InvalidValueException {
	if (this.mainLayout.getComponentCount() == 0) {
		return;
	}
	Component c = this.mainLayout.getComponent(0);
	if (c instanceof PIPSQLResolverEditorWindow) {
		((PIPSQLResolverEditorWindow)c).validate();
	}
	super.validate();
}
 

@Override
public void commit() throws SourceException, InvalidValueException {
	if (this.mainLayout.getComponentCount() == 0) {
		return;
	}
	Component c = this.mainLayout.getComponent(0);
	if (c instanceof PIPSQLResolverEditorWindow) {
		((PIPSQLResolverEditorWindow)c).commit();
	}
	super.commit();
}
 

/**
 * @throws InvalidValueException if min value exists and i is smaller than min value
 * @param i
 */
private void isGreaterOrEqualToMinValueInt(int i) {
	if (!minValue.getValue().isEmpty()) {
		try {
			int minValueInt = Integer.parseInt(minValue.getValue());
			if (i < minValueInt) {
				throw new InvalidValueException("Smaller than minimum value");
			}
		} catch (NumberFormatException e) {
			// ignore rubbish min value
		}
	}
}
 

@SuppressWarnings("serial")
private Validator getMinValueValidator() {
	return new Validator() {

		@Override
		public void validate(Object value) throws InvalidValueException {
			String v = (String) value;

			// empty is ok
			if (v.isEmpty()) {
				return;
			}

			// integer
			ParameterType t = (ParameterType) type.getValue();
			if (t == ParameterType.INTEGER) {
				// must be integer
				int minValueInt = getInt(v);

				// if min value exists, must be equal or greater
				isSmallerOrEqualToMaxValueInt(minValueInt);
			} 

			
			// DECIMAL
			else if (t == ParameterType.DECIMAL) {
				double minValueDouble = getDouble(v);
				isSmallerOrEqualToMaxValueDouble(minValueDouble);
			}
		}
	};
}
 

/**
 * @throws InvalidValueException if max value exists and i is greater than max value
 * @param i
 */
private void isSmallerOrEqualToMaxValueDouble(double d) {
	if (!maxValue.getValue().isEmpty()) {
		try {
			double maxValueDouble = Double.parseDouble(maxValue.getValue());
			if (d > maxValueDouble) {
				throw new InvalidValueException("Greater than maximum value");
			}
		} catch (NumberFormatException e) {
			// ignore rubbish max value
		}
	}
}
 

@Override
public void validate(final Date value) throws InvalidValueException {
    super.validate(value);

    if (value != null && maximumDuration != null && compareTimeOfDates(value, maximumDuration) > 0) {
        throw new InvalidValueException("value is greater than the allowed maximum value");
    }

    if (value != null && minimumDuration != null && compareTimeOfDates(minimumDuration, value) > 0) {
        throw new InvalidValueException("value is smaller than the allowed minimum value");
    }
}
 

@Override
public void onValidationError(Map<Field<?>, InvalidValueException> validationErrors) {
	super.onValidationError(validationErrors);
	StringBuilder sb = new StringBuilder();
	for(Field<?> field: validationErrors.keySet()) {
		if(sb.length()!= 0) {
			sb.append(", ");
		}
		sb.append(field.getCaption());		
	}
	Notification.show("Fehler in folgenden Feldern:", sb.toString(), Notification.Type.ERROR_MESSAGE);
}
 

@Override
public void onValidationError(Map<Field<?>, InvalidValueException> validationErrors) {
	super.onValidationError(validationErrors);
	StringBuilder sb = new StringBuilder();
	for(Field<?> field: validationErrors.keySet()) {
		if(sb.length()!= 0) {
			sb.append(", ");
		}
		sb.append(field.getCaption());		
	}
	Notification.show("Fehler in folgenden Feldern:", sb.toString(), Notification.Type.ERROR_MESSAGE);
}
 

/**
 * {@inheritDoc}
 */
public void commit() throws SourceException, InvalidValueException {
	if (!save()) {
		// lost changes?
		discard();
		throw new SourceException(this);
	}
}
 

protected void initializeButtons() {
	this.buttonSave.setClickShortcut(KeyCode.ENTER);
	this.buttonSave.addClickListener(new ClickListener() {
		private static final long serialVersionUID = 1L;

		@Override
		public void buttonClick(ClickEvent event) {
			try {
				//
				// Commit everything??
				//
				self.textFieldIssuer.commit();
				self.checkBoxMustBePresent.commit();
				self.currentComponent.commit();
				//
				// Save to the attribute
				//
				String issuer = self.textFieldIssuer.getValue();
				if (issuer == null || issuer.length() == 0) {
					self.attribute.setIssuer(null);
				} else {
					self.attribute.setIssuer(issuer);
				}
				self.attribute.setMustBePresent(self.checkBoxMustBePresent.getValue());
				//
				// Mark as saved
				//
				self.isSaved = true;
				//
				// Close the window
				//
				self.close();
			} catch (SourceException | InvalidValueException e) {
				
			}
		}
	});
}