public static object CreateErrorResponse(object request, Exception ex, ResponseStatus responseStatus)
{
var responseDto = CreateResponseDto(request, responseStatus);
var httpError = ex as IHttpError;
if (httpError != null)
{
if (responseDto != null)
httpError.Response = responseDto;
return httpError;
}
var errorCode = ex.GetType().Name;
var errorMsg = ex.Message;
if (responseStatus != null)
{
errorCode = responseStatus.ErrorCode ?? errorCode;
errorMsg = responseStatus.Message ?? errorMsg;
}
return new HttpError(responseDto, ex.ToStatusCode(), errorCode, errorMsg);
}
/// <summary>
/// Creates the error response from the values provided.
///
/// If the errorCode is empty it will use the first validation error code,
/// if there is none it will throw an error.
/// </summary>
/// <param name="errorCode">The error code.</param>
/// <param name="errorMessage">The error message.</param>
/// <param name="validationErrors">The validation errors.</param>
/// <returns></returns>
public static ResponseStatus CreateResponseStatus(string errorCode, string errorMessage, IEnumerable<ValidationErrorField> validationErrors)
{
var to = new ResponseStatus {
ErrorCode = errorCode,
Message = errorMessage,
Errors = new List<ResponseError>(),
};
if (validationErrors != null)
{
foreach (var validationError in validationErrors)
{
var error = new ResponseError {
ErrorCode = validationError.ErrorCode,
FieldName = validationError.FieldName,
Message = validationError.ErrorMessage,
};
to.Errors.Add(error);
if (string.IsNullOrEmpty(to.ErrorCode))
{
to.ErrorCode = validationError.ErrorCode;
}
if (string.IsNullOrEmpty(to.Message))
{
to.Message = validationError.ErrorMessage;
}
}
}
if (string.IsNullOrEmpty(errorCode))
{
if (string.IsNullOrEmpty(to.ErrorCode))
{
throw new ArgumentException("Cannot create a valid error response with a en empty errorCode and an empty validationError list");
}
}
return to;
}
/// <summary>
/// Create an instance of the service response dto type and inject it with the supplied responseStatus
/// </summary>
/// <param name="request"></param>
/// <param name="responseStatus"></param>
/// <returns></returns>
public static object CreateResponseDto(object request, ResponseStatus responseStatus)
{
// Predict the Response message type name
var responseDtoType = WebRequestUtils.GetErrorResponseDtoType(request);
var responseDto = responseDtoType.CreateInstance();
if (responseDto == null)
return null;
// For faster serialization of exceptions, services should implement IHasResponseStatus
var hasResponseStatus = responseDto as IHasResponseStatus;
if (hasResponseStatus != null)
{
hasResponseStatus.ResponseStatus = responseStatus;
}
else
{
var responseStatusProperty = responseDtoType.GetProperty(ResponseStatusPropertyName);
if (responseStatusProperty != null)
{
// Set the ResponseStatus
ReflectionUtils.SetProperty(responseDto, responseStatusProperty, responseStatus);
}
}
// Return an Error DTO with the exception populated
return responseDto;
}
public ServiceResponseException(ResponseStatus responseStatus)
: base(GetErrorMessage(responseStatus.ErrorCode, responseStatus.Message))
{
this.ErrorCode = responseStatus.ErrorCode;
}
