/// <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>Initializes a new instance of the NServiceKit.WebHost.Endpoints.Tests.IntegrationTests.ErrorResponse class.</summary>
///
/// <param name="result">The result.</param>
public ErrorResponse(Error result)
{
Result = result;
ResponseStatus = new ResponseStatus();
}
/// <summary>Initializes a new instance of the NServiceKit.WebHost.Endpoints.Tests.IntegrationTests.ErrorCollectionResponse class.</summary>
///
/// <param name="result">The result.</param>
public ErrorCollectionResponse(IList<Error> result)
{
Result = new Collection<Error>(result);
ResponseStatus = new ResponseStatus();
}
/// <summary>Initializes a new instance of the NServiceKit.ServiceInterface.ServiceResponseException class.</summary>
///
/// <param name="responseStatus">The response status.</param>
public ServiceResponseException(ResponseStatus responseStatus)
: base(GetErrorMessage(responseStatus.ErrorCode, responseStatus.Message))
{
this.ErrorCode = responseStatus.ErrorCode;
}
/// <summary>Logs error in redis if exists.</summary>
///
/// <param name="redisManager"> Manager for redis.</param>
/// <param name="operationName"> Name of the operation.</param>
/// <param name="responseStatus">.</param>
public static void LogErrorInRedisIfExists(
IRedisClientsManager redisManager, string operationName, ResponseStatus responseStatus)
{
//If Redis is configured, maintain rolling service error logs in Redis (an in-memory datastore)
if (redisManager == null) return;
try
{
//Get a thread-safe redis client from the client manager pool
using (var client = redisManager.GetClient())
{
//Get a client with a native interface for storing 'ResponseStatus' objects
var redis = client.GetTypedClient<ResponseStatus>();
//Store the errors in predictable Redis-named lists i.e.
//'urn:ServiceErrors:{ServiceName}' and 'urn:ServiceErrors:All'
var redisSeriviceErrorList = redis.Lists[UrnId.Create(UrnServiceErrorType, operationName)];
var redisCombinedErrorList = redis.Lists[UrnId.Create(UrnServiceErrorType, CombinedServiceLogId)];
//Append the error at the start of the service-specific and combined error logs.
redisSeriviceErrorList.Prepend(responseStatus);
redisCombinedErrorList.Prepend(responseStatus);
//Clip old error logs from the managed logs
const int rollingErrorCount = 1000;
redisSeriviceErrorList.Trim(0, rollingErrorCount);
redisCombinedErrorList.Trim(0, rollingErrorCount);
}
}
catch (Exception suppressRedisException)
{
Log.Error("Could not append exception to redis service error logs", suppressRedisException);
}
}
/// <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;
}
/// <summary>Creates error response.</summary>
///
/// <param name="request"> .</param>
/// <param name="ex"> .</param>
/// <param name="responseStatus">.</param>
///
/// <returns>The new error response.</returns>
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);
}
