public void validate(Object obj, Errors errors) { //use regular phone Phone phone = (Phone) obj; ValidationUtils.rejectIfEmptyOrWhitespace(errors, "phoneNumber", "phone.required", new Object[]{phone}); if (!errors.hasErrors()) { String phoneNumber = phone.getPhoneNumber(); String newString = phoneNumber.replaceAll("\\D", ""); if (newString.length() != 10) { errors.rejectValue("phoneNumber", "phone.ten_digits_required", null); } // Check for common false data. if (newString.equals("1234567890") || newString.equals("0123456789") || newString.matches("0{10}") || newString.matches("1{10}") || newString.matches("2{10}") || newString.matches("3{10}") || newString.matches("4{10}") || newString.matches("5{10}") || newString.matches("6{10}") || newString.matches("7{10}") || newString.matches("8{10}") || newString.matches("9{10}")) { errors.rejectValue("phoneNumber", "phone.invalid", null); } } } }
this.objectErrors = this.errors.getAllErrors(); this.objectErrors = this.errors.getFieldErrors(this.expression); this.objectErrors = this.errors.getFieldErrors(this.expression); this.value = this.errors.getFieldValue(this.expression); this.valueType = this.errors.getFieldType(this.expression); if (this.errors instanceof BindingResult) { this.bindingResult = (BindingResult) this.errors; this.objectErrors = this.errors.getGlobalErrors();
@Override public void reject(String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage) { this.source.reject(errorCode, errorArgs, defaultMessage); }
@Override public void addAllErrors(Errors errors) { if (!errors.getObjectName().equals(getObjectName())) { throw new IllegalArgumentException("Errors object needs to have same object name"); } this.errors.addAll(errors.getAllErrors()); }
/** * Reject the given field with the given error code, error arguments * and default message if the value is empty or just contains whitespace. * <p>An 'empty' value in this context means either {@code null}, * the empty string "", or consisting wholly of whitespace. * <p>The object whose field is being validated does not need to be passed * in because the {@link Errors} instance can resolve field values by itself * (it will usually hold an internal reference to the target object). * @param errors the {@code Errors} instance to register errors on * @param field the field name to check * @param errorCode the error code, interpretable as message key * @param errorArgs the error arguments, for argument binding via MessageFormat * (can be {@code null}) * @param defaultMessage fallback default message */ public static void rejectIfEmptyOrWhitespace( Errors errors, String field, String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage) { Assert.notNull(errors, "Errors object must not be null"); Object value = errors.getFieldValue(field); if (value == null ||!StringUtils.hasText(value.toString())) { errors.rejectValue(field, errorCode, errorArgs, defaultMessage); } }
logger.debug("Invoking validator [" + validator + "]"); if (!validator.supports(target.getClass())) { throw new IllegalArgumentException( "Validator [" + validator.getClass() + "] does not support [" + target.getClass() + "]"); validator.validate(target, errors); if (errors.hasErrors()) { logger.debug("Validator found " + errors.getErrorCount() + " errors");
/** * @see OrderValidator#validate(Object,Errors) */ @Test public void validate_shouldPassValidationIfAllFieldsAreCorrect() { Order order = new DrugOrder(); Encounter encounter = new Encounter(); order.setConcept(Context.getConceptService().getConcept(88)); order.setOrderer(Context.getProviderService().getProvider(1)); Patient patient = Context.getPatientService().getPatient(2); encounter.setPatient(patient); order.setPatient(patient); Calendar cal = Calendar.getInstance(); cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) - 1); order.setDateActivated(cal.getTime()); order.setAutoExpireDate(new Date()); order.setCareSetting(new CareSetting()); order.setEncounter(encounter); order.setUrgency(Order.Urgency.ROUTINE); order.setAction(Order.Action.NEW); order.setOrderType(Context.getOrderService().getOrderTypeByName("Drug order")); Errors errors = new BindException(order, "order"); new OrderValidator().validate(order, errors); Assert.assertFalse(errors.hasErrors()); }
/** * @see org.openmrs.validator.PersonValidator#validate(Object,Errors) */ @Test public void validate_shouldPassValidationIfFieldLengthsAreCorrect() { Person person = new Person(1); person.setBirthdate(new Date()); person.setGender("g"); person.setPersonVoided(true); person.setPersonVoidReason("voidReason"); Errors errors = new BindException(person, "person"); PersonValidator personValidator = new PersonValidator(); personValidator.validate(person, errors); Assert.assertFalse(errors.hasErrors()); }
Order order = new Order(); order.setOrderId(-5); order.setOrderDate(new Date(new Date().getTime() + 1000000000L)); order.setTotalLines(10); order.setLineItems(new ArrayList<>()); assertEquals(3, errors.getAllErrors().size()); assertEquals("error.order.id", errors.getFieldError("orderId").getCode()); assertEquals("error.order.date.future", errors.getFieldError("orderDate").getCode()); assertEquals("error.order.lines.badcount", errors.getFieldError("totalLines").getCode()); assertEquals(2, errors.getAllErrors().size()); assertEquals("error.order.id", errors.getFieldError("orderId").getCode()); assertEquals("error.order.lines.badcount", errors.getFieldError("totalLines").getCode()); assertEquals(0, errors.getAllErrors().size());
patientIdentifier1.setLocation(new Location(1)); patientIdentifier1.setIdentifier("012345678"); patientIdentifier1.setDateCreated(new Date()); patientIdentifier1.setIdentifierType(patientIdentifierType); patient.addIdentifier(patientIdentifier1); Errors errors = new BindException(patient, "patient"); validator.validate(patient, errors); Assert.assertFalse(errors.hasErrors());
protected void validateOrder(Order item, Errors errors) { if(item.getOrderId() < 0 || item.getOrderId() > 9999999999L) { errors.rejectValue("orderId", "error.order.id"); } if(new Date().compareTo(item.getOrderDate()) < 0) { errors.rejectValue("orderDate", "error.order.date.future"); } if(item.getLineItems() != null && item.getTotalLines() != item.getLineItems().size()) { errors.rejectValue("totalLines", "error.order.lines.badcount"); } } }
/** * Rejects a date if it is in the future. * * @param errors the error object * @param date the date to check * @param dateField the name of the field */ private void rejectIfFutureDate(Errors errors, Date date, String dateField) { if (OpenmrsUtil.compare(date, new Date()) > 0) { errors.rejectValue(dateField, "error.date.future"); } }
/** * @see ObsValidator#validate(java.lang.Object, org.springframework.validation.Errors) */ @Test public void validate_shouldNotValidateIfObsIsVoided() { Obs obs = new Obs(); obs.setPerson(Context.getPersonService().getPerson(2)); obs.setConcept(Context.getConceptService().getConcept(5089)); obs.setObsDatetime(new Date()); obs.setValueNumeric(null); Errors errors = new BindException(obs, "obs"); obsValidator.validate(obs, errors); assertTrue(errors.hasFieldErrors("valueNumeric")); obs.setVoided(true); errors = new BindException(obs, "obs"); obsValidator.validate(obs, errors); assertFalse(errors.hasErrors()); }
/** * @see EncounterValidator#validate(Object,Errors) */ @Test public void validate_shouldPassValidationIfFieldLengthsAreCorrect() { encounter.setEncounterType(new EncounterType()); encounter.setPatient(new Patient()); encounter.setEncounterDatetime(new Date()); encounter.setVoidReason("voidReason"); encounterValidator.validate(encounter, errors); Assert.assertFalse(errors.hasErrors()); }
private void validateStartDatetime(Visit visit, Visit otherVisit, Errors errors) { if (visit.getStartDatetime() != null && otherVisit.getStartDatetime() != null && visit.getStartDatetime().equals(otherVisit.getStartDatetime())) { errors.rejectValue("startDatetime", "Visit.startCannotBeTheSameAsOtherStartDateOfTheSamePatient", "This visit has the same start date and time as another visit of this patient."); } if (visit.getStartDatetime() != null && otherVisit.getStartDatetime() != null && otherVisit.getStopDatetime() != null && visit.getStartDatetime().after(otherVisit.getStartDatetime()) && visit.getStartDatetime().before(otherVisit.getStopDatetime())) { errors.rejectValue("startDatetime", "Visit.startDateCannotFallIntoAnotherVisitOfTheSamePatient", "This visit has a start date that falls into another visit of the same patient."); } }
private void validateVisitStartedBeforePatientBirthdate(Visit visit, Errors errors) { if (visit.getPatient() == null || visit.getPatient().getBirthdate() == null || visit.getStartDatetime() == null) { return; } if (visit.getStartDatetime().before(getPatientBirthdateAdjustedIfEstimated(visit.getPatient()))) { errors.rejectValue("startDatetime", "Visit.startDateCannotFallBeforeTheBirthDateOfTheSamePatient", "This visit has a start date that falls before the birthdate of the same patient."); } }
Errors errors = new EscapedErrors(new BindException(tb, "tb")); errors.rejectValue("name", "NAME_EMPTY &", null, "message: &"); errors.rejectValue("age", "AGE_NOT_SET <tag>", null, "message: <tag>"); errors.rejectValue("age", "AGE_NOT_32 <tag>", null, "message: <tag>"); errors.reject("GENERAL_ERROR \" '", null, "message: \" '"); assertTrue("Correct errors flag", errors.hasErrors()); assertTrue("Correct number of errors", errors.getErrorCount() == 4); assertTrue("Correct object name", "tb".equals(errors.getObjectName())); assertTrue("Correct global errors flag", errors.hasGlobalErrors()); assertTrue("Correct number of global errors", errors.getGlobalErrorCount() == 1); ObjectError globalError = errors.getGlobalError(); String defaultMessage = globalError.getDefaultMessage(); assertTrue("Global error message escaped", "message: " '".equals(defaultMessage)); assertTrue("Global error code not escaped", "GENERAL_ERROR \" '".equals(globalError.getCode())); ObjectError globalErrorInList = errors.getGlobalErrors().get(0); assertTrue("Same global error in list", defaultMessage.equals(globalErrorInList.getDefaultMessage())); ObjectError globalErrorInAllList = errors.getAllErrors().get(3); assertTrue("Same global error in list", defaultMessage.equals(globalErrorInAllList.getDefaultMessage())); assertTrue("Correct field errors flag", errors.hasFieldErrors()); assertTrue("Correct number of field errors", errors.getFieldErrorCount() == 3); assertTrue("Correct number of field errors in list", errors.getFieldErrors().size() == 3); FieldError fieldError = errors.getFieldError(); assertTrue("Field error code not escaped", "NAME_EMPTY &".equals(fieldError.getCode())); assertTrue("Field value escaped", "empty &".equals(errors.getFieldValue("name"))); FieldError fieldErrorInList = errors.getFieldErrors().get(0); assertTrue("Same field error in list", fieldError.getDefaultMessage().equals(fieldErrorInList.getDefaultMessage()));
errors.setNestedPath("spouse."); assertEquals("spouse.", errors.getNestedPath()); Validator spouseValidator = new SpouseValidator(); spouseValidator.validate(tb.getSpouse(), errors); errors.setNestedPath(""); assertTrue(errors.hasErrors()); assertEquals(6, errors.getErrorCount()); assertEquals(2, errors.getGlobalErrorCount()); assertEquals("NAME_TOUCHY_MISMATCH", errors.getGlobalError().getCode()); assertEquals("NAME_TOUCHY_MISMATCH", (errors.getGlobalErrors().get(0)).getCode()); assertEquals("NAME_TOUCHY_MISMATCH.tb", (errors.getGlobalErrors().get(0)).getCodes()[0]); assertEquals("NAME_TOUCHY_MISMATCH", (errors.getGlobalErrors().get(0)).getCodes()[1]); assertEquals("tb", (errors.getGlobalErrors().get(0)).getObjectName()); assertEquals("GENERAL_ERROR", (errors.getGlobalErrors().get(1)).getCode()); assertEquals("GENERAL_ERROR.tb", (errors.getGlobalErrors().get(1)).getCodes()[0]); assertEquals("GENERAL_ERROR", (errors.getGlobalErrors().get(1)).getCodes()[1]); assertEquals("msg", (errors.getGlobalErrors().get(1)).getDefaultMessage()); assertEquals("arg", (errors.getGlobalErrors().get(1)).getArguments()[0]); assertTrue(errors.hasFieldErrors()); assertEquals(4, errors.getFieldErrorCount()); assertEquals("TOO_YOUNG", errors.getFieldError().getCode()); assertEquals("TOO_YOUNG", (errors.getFieldErrors().get(0)).getCode()); assertEquals("age", (errors.getFieldErrors().get(0)).getField()); assertEquals("AGE_NOT_ODD", (errors.getFieldErrors().get(1)).getCode()); assertEquals("age", (errors.getFieldErrors().get(1)).getField()); assertEquals("NOT_ROD", (errors.getFieldErrors().get(2)).getCode());
@Test public void testDirectBindingToEmptyIndexedFieldWithRegisteredGenericEditor() { IndexedTestBean tb = new IndexedTestBean(); DataBinder binder = new DataBinder(tb, "tb"); binder.registerCustomEditor(TestBean.class, "map", new PropertyEditorSupport() { @Override public void setAsText(String text) throws IllegalArgumentException { DerivedTestBean tb = new DerivedTestBean(); tb.setName("array" + text); setValue(tb); } @Override public String getAsText() { return ((TestBean) getValue()).getName(); } }); Errors errors = binder.getBindingResult(); errors.rejectValue("map[key0]", "NOT_NULL", "should not be null"); assertEquals(1, errors.getFieldErrorCount("map[key0]")); assertEquals("NOT_NULL", errors.getFieldError("map[key0]").getCode()); assertEquals("NOT_NULL.tb.map[key0]", errors.getFieldError("map[key0]").getCodes()[0]); assertEquals("NOT_NULL.tb.map", errors.getFieldError("map[key0]").getCodes()[1]); assertEquals("NOT_NULL.map[key0]", errors.getFieldError("map[key0]").getCodes()[2]); assertEquals("NOT_NULL.map", errors.getFieldError("map[key0]").getCodes()[3]); // This next code is only generated because of the registered editor, using the // registered type of the editor as guess for the content type of the collection. assertEquals("NOT_NULL.org.springframework.tests.sample.beans.TestBean", errors.getFieldError("map[key0]").getCodes()[4]); assertEquals("NOT_NULL", errors.getFieldError("map[key0]").getCodes()[5]); }
/** * @see ProgramValidator#validate(Object,Errors) */ @Test public void validate_shouldPassValidationIfFieldLengthsAreCorrect() { Program prog = new Program(); prog.setName("Hypochondriasis program"); prog.setConcept(Context.getConceptService().getConcept(3)); Errors errors = new BindException(prog, "prog"); programValidator.validate(prog, errors); Assert.assertFalse(errors.hasErrors()); }