public static BaseResponse createResponse(HttpStatus status, BindingResult result) {
BaseResponse response = new BaseResponse();
if (result.hasErrors()) {
response.setError(true);
response.setHttpErrorCode(status.value());
/* create an array of total error count */
ArrayList<ErrorDTO> errors = new ArrayList<ErrorDTO>(result.getErrorCount());
/* append all field errors */
for (FieldError err : result.getFieldErrors()) {
System.out.println(
"I got field error for: "
+ err.getField()
+ ", message: "
+ err.getDefaultMessage()
+ ", code: "
+ err.getCode());
ErrorDTO dto = new ErrorDTO(err.getField(), err.getCode(), err.getDefaultMessage());
errors.add(dto);
}
/* append global errors now */
for (ObjectError err : result.getGlobalErrors()) {
System.out.println(
"I got global error for: "
+ err.getObjectName()
+ ", message: "
+ err.getDefaultMessage()
+ ", code: "
+ err.getCode());
ErrorDTO dto = new ErrorDTO(err.getObjectName(), err.getCode(), err.getDefaultMessage());
errors.add(dto);
}
response.setErrors(errors);
}
return response;
}
/**
* AJAX Called once user is submitting upload form
*
* @param model
* @param file - Uploaded file
* @param comment - Comment for uploaded file
* @return
*/
@RequestMapping(method = RequestMethod.POST)
public @ResponseBody JsonResponse uploadAction(
@Valid @ModelAttribute(value = "image") Image image,
@RequestParam(value = "captcha_challenge", required = true) String challenge,
@RequestParam(value = "captcha_response", required = true) String response,
BindingResult result,
HttpServletRequest paramHttpServletRequest) {
JsonResponse jsonResponse = new JsonResponse();
String remoteAddr = paramHttpServletRequest.getRemoteAddr();
ReCaptchaResponse reCaptchaResponse = recaptcha.checkAnswer(remoteAddr, challenge, response);
if (!reCaptchaResponse.isValid()) {
jsonResponse.setCaptchaError(
context.getMessage("error.bad.captcha", null, Locale.getDefault()));
return jsonResponse;
}
prepareImage(image);
(new ImageValidator()).validate(image, result);
if (!result.hasErrors()) {
try {
image.setBytes(image.getFile().getBytes());
image.setContentType(image.getFile().getContentType());
image = imageService.saveImage(image);
jsonResponse.setResponse(paramHttpServletRequest.getRequestURL() + image.getId());
} catch (Exception e) {
log.error(e.getMessage());
}
} else {
for (ObjectError error : result.getAllErrors()) {
jsonResponse.appendError(context.getMessage(error.getCode(), null, Locale.getDefault()));
}
}
return jsonResponse;
}
/**
* Helper method to extract unique error messages from a bind exception and format them
*
* @param errors the bind exception
* @return the messages
*/
protected Set<String> uniqueErrorMessages(BindException errors) {
Set<String> messages = new LinkedHashSet<String>();
for (Object objerr : errors.getAllErrors()) {
ObjectError error = (ObjectError) objerr;
String message = Context.getMessageSourceService().getMessage(error.getCode());
if (error instanceof FieldError) {
message = ((FieldError) error).getField() + ": " + message;
}
messages.add(message);
}
return messages;
}
protected boolean isTypeMismatchError(final ObjectError error) {
return error.getCode().equals(TYPE_MISMATCH_ERROR_CODE);
}
/**
* Validates the given Patient.
*
* @param obj The patient to validate.
* @param errors The patient to validate.
* @see org.springframework.validation.Validator#validate(java.lang.Object,
* org.springframework.validation.Errors)
* @should pass if the minimum required fields are provided and are valid
* @should fail validation if gender is blank
* @should fail validation if birthdate is blank
* @should fail validation if birthdate makes patient 120 years old or older
* @should fail validation if birthdate is a future date
* @should fail validation if causeOfDeath is blank when patient is dead
* @should fail if all name fields are empty or white space characters
* @should fail if no identifiers are added
* @should fail if all identifiers have been voided
* @should fail if any name has more than 50 characters
* @should fail validation if deathdate is a future date
* @should fail if the deathdate is before the birthdate incase the patient is dead
* @should reject a duplicate name
* @should reject a duplicate address
*/
public void validate(Object obj, Errors errors) {
if (log.isDebugEnabled()) {
log.debug(
this.getClass().getName() + ": Validating patient data from the short patient form....");
}
ShortPatientModel shortPatientModel = (ShortPatientModel) obj;
PersonName personName = shortPatientModel.getPersonName();
// TODO We should be able to let developers and implementations to specify which person name
// fields should be used to determine uniqueness
// check if this name has a unique givenName, middleName and familyName combination
for (PersonName possibleDuplicate : shortPatientModel.getPatient().getNames()) {
// don't compare the name to itself
if (OpenmrsUtil.nullSafeEquals(possibleDuplicate.getId(), personName.getId())) {
continue;
}
if (OpenmrsUtil.nullSafeEqualsIgnoreCase(
possibleDuplicate.getGivenName(), personName.getGivenName())
&& OpenmrsUtil.nullSafeEqualsIgnoreCase(
possibleDuplicate.getMiddleName(), personName.getMiddleName())
&& OpenmrsUtil.nullSafeEqualsIgnoreCase(
possibleDuplicate.getFamilyName(), personName.getFamilyName())) {
errors.reject(
"Patient.duplicateName",
new Object[] {personName.getFullName()},
personName.getFullName() + " is a duplicate name for the same patient");
}
}
Errors nameErrors = new BindException(personName, "personName");
new PersonNameValidator().validatePersonName(personName, nameErrors, false, true);
if (nameErrors.hasErrors()) {
// pick all the personName errors and bind them to the formObject
Iterator<ObjectError> it = nameErrors.getAllErrors().iterator();
Set<String> errorCodesWithNoArguments = new HashSet<String>();
while (it.hasNext()) {
ObjectError error = it.next();
// don't show similar error message multiple times in the view
// unless they take in arguments which will make them atleast different
if (error.getCode() != null
&& (!errorCodesWithNoArguments.contains(error.getCode())
|| (error.getArguments() != null && error.getArguments().length > 0))) {
errors.reject(error.getCode(), error.getArguments(), "");
if (error.getArguments() == null || error.getArguments().length == 0) {
errorCodesWithNoArguments.add(error.getCode());
}
}
}
// drop the collection
errorCodesWithNoArguments = null;
}
// TODO We should be able to let developers and implementations to specify which
// person address fields should be used to determine uniqueness
// check if this address is unique
PersonAddress personAddress = shortPatientModel.getPersonAddress();
for (PersonAddress possibleDuplicate : shortPatientModel.getPatient().getAddresses()) {
// don't compare the address to itself
if (OpenmrsUtil.nullSafeEquals(possibleDuplicate.getId(), personAddress.getId())) {
continue;
}
if (!possibleDuplicate.isBlank()
&& !personAddress.isBlank()
&& possibleDuplicate.toString().equalsIgnoreCase(personAddress.toString())) {
errors.reject(
"Patient.duplicateAddress",
new Object[] {personAddress.toString()},
personAddress.toString() + " is a duplicate address for the same patient");
}
}
if (CollectionUtils.isEmpty(shortPatientModel.getIdentifiers())) {
errors.reject("PatientIdentifier.error.insufficientIdentifiers");
} else {
boolean nonVoidedIdentifierFound = false;
for (PatientIdentifier pId : shortPatientModel.getIdentifiers()) {
// no need to validate unsaved identifiers that have been removed
if (pId.getPatientIdentifierId() == null && pId.isVoided()) {
continue;
}
if (!pId.isVoided()) {
nonVoidedIdentifierFound = true;
}
new PatientIdentifierValidator().validate(pId, errors);
}
// if all the names are voided
if (!nonVoidedIdentifierFound) {
errors.reject("PatientIdentifier.error.insufficientIdentifiers");
}
}
// Make sure they chose a gender
if (StringUtils.isBlank(shortPatientModel.getPatient().getGender())) {
errors.rejectValue("patient.gender", "Person.gender.required");
}
// check patients birthdate against future dates and really old dates
if (shortPatientModel.getPatient().getBirthdate() != null) {
if (shortPatientModel.getPatient().getBirthdate().after(new Date())) {
errors.rejectValue("patient.birthdate", "error.date.future");
} else {
Calendar c = Calendar.getInstance();
c.setTime(new Date());
c.add(Calendar.YEAR, -120); // patient cannot be older than 120
// years old
if (shortPatientModel.getPatient().getBirthdate().before(c.getTime())) {
errors.rejectValue("patient.birthdate", "error.date.nonsensical");
}
}
} else {
errors.rejectValue(
"patient.birthdate",
"error.required",
new Object[] {Context.getMessageSourceService().getMessage("Person.birthdate")},
"");
}
// validate the personAddress
if (shortPatientModel.getPersonAddress() != null) {
try {
errors.pushNestedPath("personAddress");
ValidationUtils.invokeValidator(
new PersonAddressValidator(), shortPatientModel.getPersonAddress(), errors);
} finally {
errors.popNestedPath();
}
}
if (shortPatientModel.getPatient().getDead()) {
if (shortPatientModel.getPatient().getCauseOfDeath() == null) {
errors.rejectValue("patient.causeOfDeath", "Person.dead.causeOfDeathNull");
}
if (shortPatientModel.getPatient().getDeathDate() != null) {
if (shortPatientModel.getPatient().getDeathDate().after(new Date())) {
errors.rejectValue("patient.deathDate", "error.date.future");
}
// death date has to be after birthdate if both are specified
if (shortPatientModel.getPatient().getBirthdate() != null
&& shortPatientModel
.getPatient()
.getDeathDate()
.before(shortPatientModel.getPatient().getBirthdate())) {
errors.rejectValue("patient.deathDate", "error.deathdate.before.birthdate");
}
}
}
}
/**
* @should void the old person address and replace it with a new one when it is edited
* @should void the old person address and replace it with a new one when it is edited
* @should not void the existing address if there are no changes
*/
public String post(
UiSessionContext sessionContext,
PageModel model,
@RequestParam("patientId") @BindParams Patient patient,
@BindParams PersonAddress address,
@SpringBean("patientService") PatientService patientService,
@RequestParam("appId") AppDescriptor app,
@RequestParam("returnUrl") String returnUrl,
@SpringBean("adminService") AdministrationService administrationService,
HttpServletRequest request,
@SpringBean("messageSourceService") MessageSourceService messageSourceService,
Session session,
@SpringBean("patientValidator") PatientValidator patientValidator,
UiUtils ui)
throws Exception {
sessionContext.requireAuthentication();
if (patient.getPersonAddress() != null && address != null) {
PersonAddress currentAddress = patient.getPersonAddress();
if (!currentAddress.equalsContent(address)) {
// void the old address and replace it with the new one
patient.addAddress(address);
currentAddress.setVoided(true);
}
}
NavigableFormStructure formStructure = RegisterPatientFormBuilder.buildFormStructure(app);
BindingResult errors = new BeanPropertyBindingResult(patient, "patient");
patientValidator.validate(patient, errors);
RegistrationAppUiUtils.validateLatitudeAndLongitudeIfNecessary(address, errors);
if (formStructure != null) {
RegisterPatientFormBuilder.resolvePersonAttributeFields(
formStructure, patient, request.getParameterMap());
}
if (!errors.hasErrors()) {
try {
// The person address changes get saved along as with the call to save patient
patientService.savePatient(patient);
InfoErrorMessageUtil.flashInfoMessage(
request.getSession(),
ui.message("registrationapp.editContactInfoMessage.success", patient.getPersonName()));
return "redirect:" + returnUrl;
} catch (Exception e) {
log.warn("Error occurred while saving patient's contact info", e);
session.setAttribute(
UiCommonsConstants.SESSION_ATTRIBUTE_ERROR_MESSAGE, "registrationapp.save.fail");
}
} else {
model.addAttribute("errors", errors);
StringBuffer errorMessage =
new StringBuffer(messageSourceService.getMessage("error.failed.validation"));
errorMessage.append("<ul>");
for (ObjectError error : errors.getAllErrors()) {
errorMessage.append("<li>");
errorMessage.append(
messageSourceService.getMessage(
error.getCode(), error.getArguments(), error.getDefaultMessage(), null));
errorMessage.append("</li>");
}
errorMessage.append("</ul>");
session.setAttribute(
UiCommonsConstants.SESSION_ATTRIBUTE_ERROR_MESSAGE, errorMessage.toString());
}
addModelAttributes(model, patient, formStructure, administrationService, returnUrl);
// redisplay the form
return null;
}
