Summary Table

Categories Total Count
PII 0
URL 0
DNS 0
EKL 0
IP 0
PORT 0
VsID 0
CF 0
AI 0
VPD 0
PL 0
Other 0

File Content

/*
* SeocRestExceptionHandler.java
* Copyright (c) 2017 Veterans Affairs.
*/
package gov.va.oneconsult.seoc.api.exceptions;

import static org.springframework.http.HttpStatus.BAD_REQUEST;
import javax.validation.ConstraintViolationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

/**
* @author AbleVets
*/

@Order(Ordered.HIGHEST_PRECEDENCE)
@ControllerAdvice
public class SeocRestExceptionHandler extends ResponseEntityExceptionHandler
{

public static final Logger logger = LoggerFactory.getLogger(SeocRestExceptionHandler.class);

/**
* {@inheritDoc} Handle MissingServletRequestParameterException. Triggered when
* a 'required' request parameter is missing.
*/
@Override
protected ResponseEntity<Object> handleMissingServletRequestParameter(
MissingServletRequestParameterException ex, HttpHeaders headers, HttpStatus status,
WebRequest request)
{

String error = ex.getParameterName() + " parameter is missing";
return buildResponseEntity(new ApiError(BAD_REQUEST, error, ex));
}

/**
* {@inheritDoc} Handle HttpMediaTypeNotSupportedException. This one triggers
* when JSON is invalid as well.
*/
@Override
protected ResponseEntity<Object> handleHttpMediaTypeNotSupported(
HttpMediaTypeNotSupportedException ex, HttpHeaders headers, HttpStatus status,
WebRequest request)
{

StringBuilder builder = new StringBuilder();
builder.append(ex.getContentType());
builder.append(" media type is not supported. Supported media types are ");
ex.getSupportedMediaTypes().forEach(t -> builder.append(t).append(", "));
return buildResponseEntity(new ApiError(HttpStatus.UNSUPPORTED_MEDIA_TYPE,
builder.substring(0, builder.length() - 2), ex));
}

/**
* {@inheritDoc} Handle MethodArgumentNotValidException. Triggered when an
* object fails @Valid validation.s
*/
@Override
protected ResponseEntity<Object> handleMethodArgumentNotValid(
MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status,
WebRequest request)
{

ApiError apiError = new ApiError(BAD_REQUEST);
apiError.setMessage("Validation error");
apiError.addValidationErrors(ex.getBindingResult().getFieldErrors());
apiError.addValidationError(ex.getBindingResult().getGlobalErrors());
return buildResponseEntity(apiError);
}

/**
* Handles javax.validation.ConstraintViolationException. Thrown
* when @Validated fails.
*/
@ExceptionHandler(javax.validation.ConstraintViolationException.class)
protected ResponseEntity<Object> handleConstraintViolation(
javax.validation.ConstraintViolationException ex)
{

ApiError apiError = new ApiError(BAD_REQUEST);
apiError.setMessage("Validation error");
apiError.addValidationErrors(ex.getConstraintViolations());
return buildResponseEntity(apiError);
}

/**
* {@inheritDoc} Handle HttpMessageNotReadableException. Happens when request
* JSON is malformed.
*/
@Override
protected ResponseEntity<Object> handleHttpMessageNotReadable(
HttpMessageNotReadableException ex, HttpHeaders headers, HttpStatus status,
WebRequest request)
{

ServletWebRequest servletWebRequest = (ServletWebRequest) request;
logger.info("{} to {}", servletWebRequest.getHttpMethod(),
servletWebRequest.getRequest().getServletPath());
String error = "Malformed JSON request";
return buildResponseEntity(new ApiError(HttpStatus.BAD_REQUEST, error, ex));
}

/**
* {@inheritDoc} Handle HttpMessageNotWritableException.
*/
@Override
protected ResponseEntity<Object> handleHttpMessageNotWritable(
HttpMessageNotWritableException ex, HttpHeaders headers, HttpStatus status,
WebRequest request)
{

String error = "Error writing JSON output";
return buildResponseEntity(new ApiError(HttpStatus.INTERNAL_SERVER_ERROR, error, ex));
}

/**
* Handle DataIntegrityViolationException, inspects the cause for
* different DB causes.
*/
@ExceptionHandler(DataIntegrityViolationException.class)
protected ResponseEntity<Object> handleDataIntegrityViolation(
DataIntegrityViolationException ex, WebRequest request)
{

if (ex.getCause() instanceof ConstraintViolationException)
{
return buildResponseEntity(
new ApiError(HttpStatus.CONFLICT, "Database error", ex.getCause()));
}
return buildResponseEntity(new ApiError(HttpStatus.INTERNAL_SERVER_ERROR, ex));
}

/**
* Handle Exception, generic Exception.class
*/
@ExceptionHandler(MethodArgumentTypeMismatchException.class)
protected ResponseEntity<Object> handleMethodArgumentTypeMismatch(
MethodArgumentTypeMismatchException ex, WebRequest request)
{

ApiError apiError = new ApiError(BAD_REQUEST);
apiError.setMessage(String.format(
"The parameter '%s' of value '%s' could not be converted to type '%s'",
ex.getName(), ex.getValue(), ex.getRequiredType().getSimpleName()));
//apiError.setDebugMessage(ex.getMessage());
return buildResponseEntity(apiError);
}

/**
* Handle Exception, CodeRequiredNotValidException.class
*/
@ExceptionHandler(CodeRequiredNotValidException.class)
protected ResponseEntity<Object> handleCodeRequiredNotValid(CodeRequiredNotValidException ex,
WebRequest request)
{

ApiError apiError = new ApiError(BAD_REQUEST);
//apiError.setMessage(ex.getMessage());
apiError.setDebugMessage("Correct CodeRequired value.");
return buildResponseEntity(apiError);
}

/**
* Handle Exception, InvalidSeocRequestException.class
*/
@ExceptionHandler(InvalidSeocRequestException.class)
protected ResponseEntity<Object> handleCodeRequiredNotValid(InvalidSeocRequestException ex,
WebRequest request)
{

ApiError apiError = new ApiError(BAD_REQUEST);
//apiError.setMessage(ex.getMessage());
apiError.setDebugMessage("Correct values in the request.");
return buildResponseEntity(apiError);
}

/**
* Handle Exception, SeocConstraintViolationException.class
*/
@ExceptionHandler(SeocEffectiveDateNotValidException.class)
protected ResponseEntity<Object> handleEffectiveDateNotValid(SeocEffectiveDateNotValidException ex,
WebRequest request)
{

ApiError apiError = new ApiError(BAD_REQUEST);
//apiError.setMessage(ex.getMessage());
apiError.setDebugMessage("effectiveDate must be in the future.");
return buildResponseEntity(apiError);
}

/**
* Handle Exception, SeocConstraintViolationException.class
*/
@ExceptionHandler(SeocConstraintViolationException.class)
protected ResponseEntity<Object> handleActivationNotValid(SeocConstraintViolationException ex,
WebRequest request)
{

ApiError apiError = new ApiError(BAD_REQUEST);
//apiError.setMessage(ex.getMessage());
apiError.setDebugMessage("Resolve the validation errors.");
apiError.addSeocValidationErrors(ex.getConstraintViolations());
return buildResponseEntity(apiError);
}

/**
* Handle Exception BusinessException.class
*/
@ExceptionHandler(BusinessException.class)
protected ResponseEntity<Object> handleBusinessException(BusinessException ex,
WebRequest request)
{

ApiError apiError = new ApiError(BAD_REQUEST);
//apiError.setMessage(ex.getMessage());
apiError.setDebugMessage("Check input data and retry.");
return buildResponseEntity(apiError);
}

/**
* Description: Builds Response Entity after preparing the ApiError to be sent
* in the response
*
* @param apiError
* @return
*/
private ResponseEntity<Object> buildResponseEntity(ApiError apiError)
{

return new ResponseEntity<Object>(apiError, apiError.getStatus());
}

}