public override IActionResult CreateResponse(ErrorResponseContext context)
{
switch (context.ErrorCode)
{
case "UnsupportedApiVersion":
context = new ErrorResponseContext(
context.Request,
context.StatusCode,
context.ErrorCode,
"My custom error message.",
context.MessageDetail);
break;
case "AmbiguousApiVersion":
context = new ErrorResponseContext(
context.Request,
context.StatusCode,
context.ErrorCode,
"My custom error message.",
context.MessageDetail);
break;
}
return(base.CreateResponse(context));
}
private HttpResponseMessage CreateBadRequestForUnspecifiedApiVersionOrInvalidApiVersion(bool versionNeutral)
{
var requestedVersion = request.ApiVersionProperties().RawApiVersion;
var parsedVersion = default(ApiVersion);
var message = default(string);
var context = default(ErrorResponseContext);
if (IsNullOrEmpty(requestedVersion))
{
if (versionNeutral)
{
return(null);
}
message = SR.ApiVersionUnspecified;
TraceWriter.Info(request, ControllerSelectorCategory, message);
context = new ErrorResponseContext(request, "ApiVersionUnspecified", message, messageDetail: null);
return(Options.ErrorResponses.BadRequest(context));
}
else if (TryParse(requestedVersion, out parsedVersion))
{
return(null);
}
message = SR.VersionedResourceNotSupported.FormatDefault(request.RequestUri, requestedVersion);
var messageDetail = SR.VersionedControllerNameNotFound.FormatDefault(request.RequestUri, requestedVersion);
context = new ErrorResponseContext(request, "InvalidApiVersion", message, messageDetail);
TraceWriter.Info(request, ControllerSelectorCategory, message);
return(Options.ErrorResponses.BadRequest(context));
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
return(new ObjectResult(Envelope.Error(context.Message))
{
StatusCode = context.StatusCode
});
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
var statusCode = (HttpStatusCode)int.Parse(context.ErrorCode);
return(new ErrorResponseMessageActionResult(
new ErrorResponseMessage(new[] { new UserErrorMessage(statusCode, context.Message) }), HttpStatusCode.BadRequest));
}
public override IActionResult CreateResponse(ErrorResponseContext context)
{
string message = string.Empty;
switch (context.ErrorCode)
{
case "ApiVersionUnspecified":
message = "An API version is required, but was not specified.";
break;
case "UnsupportedApiVersion":
message = "The specified API version is not supported.";
break;
case "InvalidApiVersion":
message = "An API version was specified, but it is invalid.";
break;
case "AmbiguousApiVersion":
message = "An API version was specified multiple times with different values.";
break;
default:
message = context.ErrorCode;
break;
}
throw new HttpException(System.Net.HttpStatusCode.BadRequest, message, context.MessageDetail);
}
// note: in Web API the response type is HttpResponseMessage
public override System.Net.Http.HttpResponseMessage CreateResponse(ErrorResponseContext context)
{
switch (context.ErrorCode)
{
case "UnsupportedApiVersion":
context = new ErrorResponseContext(
context.Request,
context.StatusCode,
context.ErrorCode,
"My custom error message.",
context.MessageDetail);
break;
default:
context = new ErrorResponseContext(
context.Request,
context.StatusCode,
context.ErrorCode,
"My custom error message. default",
context.MessageDetail);
break;
}
return(base.CreateResponse(context));
}
public override IActionResult CreateResponse(ErrorResponseContext context)
{
return(new ObjectResult(CreateErrorContent(context))
{
StatusCode = (int)HttpStatusCode.Gone
});
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
return(new JsonResult(new ApiResult
{
Code = (int)DefaultStatusCode.Fail,
Message = "Unsupported Api Version",
}));
}
public override IActionResult CreateResponse(ErrorResponseContext context)
{
if (context.ErrorCode == UnsupportedApiVersionError)
{
throw new ApiException(StatusCodes.Status400BadRequest, "Versão da API não suportada");
}
throw new ApiException(StatusCodes.Status400BadRequest, "Erro no versionamento da API");
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
return(new ObjectResult(new MessageModel {
Message = "Not Up-to-date api"
})
{
StatusCode = (int)HttpStatusCode.MethodNotAllowed
});
}
public override IActionResult CreateResponse(ErrorResponseContext context)
{
if (context.StatusCode != (int)HttpStatusCode.OK)
{
throw new ApiVersionException(context.Message, context.MessageDetail, context.ErrorCode, (HttpStatusCode)context.StatusCode);
}
return(base.CreateResponse(context));
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
HttpException exception = GenerateHttpExceptionMessage(context.StatusCode);
return(new ObjectResult(exception)
{
StatusCode = context.StatusCode
});
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
var errorResponse = new ErrorResponse()
{
Code = context.ErrorCode, Message = context.Message
};
return(new ObjectResult(errorResponse)
{
StatusCode = context.StatusCode
});
}
/// <summary>
/// Generate error response related to API versioning
/// </summary>
/// <param name="context">Contextual information used when generating HTTP error responses related to API versioning</param>
public IActionResult CreateResponse(ErrorResponseContext context)
{
return(new ObjectResult(new ErrorResponse
{
StatusCode = context.StatusCode,
StatusMessage = context.ErrorCode,
Description = context.Message
})
{
StatusCode = context.StatusCode
});
}
private HttpResponseMessage CreateBadRequestForUnsupportedApiVersion(ApiVersion requestedVersion)
{
Contract.Requires(requestedVersion != null);
Contract.Ensures(Contract.Result <HttpResponseMessage>() != null);
var message = SR.VersionedResourceNotSupported.FormatDefault(request.RequestUri, requestedVersion);
var messageDetail = SR.VersionedControllerNameNotFound.FormatDefault(request.RequestUri, requestedVersion);
var context = new ErrorResponseContext(request, "UnsupportedApiVersion", message, messageDetail);
TraceWriter.Info(request, ControllerSelectorCategory, message);
return(Options.ErrorResponses.BadRequest(context));
}
public override IActionResult CreateResponse(ErrorResponseContext context)
{
var problem = new AuthProblemDetailBase
{
Code = StatusCodes.Status400BadRequest,
Message = Constants.DefaultUnsupportedApiVersionMessage
};
return(new ObjectResult(problem)
{
StatusCode = StatusCodes.Status400BadRequest
});
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
const string type = "https://tools.ietf.org/html/rfc4918#section-11.2";
var instance = $"{context.Request.Scheme}://{context.Request.Host}{context.Request.PathBase}{context.Request.Path}";
var details = new Collection <ErrorDetailsResponse>
{
new ErrorDetailsResponse(context.ErrorCode, context.Message)
};
var errorResponse = new ErrorResponse(type, instance, HttpStatusCode.UnprocessableEntity,
RequestErrorCodeEnumeration.ValidationFailed.DisplayName, "Validation failed.", details);
return(new UnprocessableEntityObjectResult(errorResponse));
}
public ApiVersionProblemDetails(ErrorResponseContext context) : base(context.StatusCode)
{
var errorCode = context.ErrorCode.ToLowerInvariant();
ProblemTypeUri = $"urn:apiversion:{errorCode}";
Detail = NullIfEmpty(context.Message);
InnerError = NewInnerError(context, c => new { Message = c.MessageDetail });
Title = _errorCodeTitles.ContainsKey(errorCode)
? _errorCodeTitles[errorCode]
: DefaultErrorCodeTitle;
ProblemInstanceUri = context.Request.HttpContext.GetProblemInstanceUri();
}
/// <inheritdoc />
/// <summary>
/// Creates and returns a new error response given the provided context.
/// </summary>
public override IActionResult CreateResponse(ErrorResponseContext context)
{
var resultModel = new ResultModel
{
IsSuccess = false,
Errors = new[] { new ErrorModel($"API_{context.ErrorCode}", context.Message) },
Result = new object()
};
return(new ContentResult
{
Content = JsonConvert.SerializeObject(resultModel),
ContentType = "application/json"
});
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
var details = new ProblemDetails
{
Type = $"https://httpstatuses.com/{context.StatusCode}",
Title = context.ErrorCode,
Detail = context.Message,
Status = context.StatusCode,
};
return(new ObjectResult(details)
{
StatusCode = context.StatusCode
});
}
static void EnsureRequestHasValidApiVersion(HttpRequestMessage request)
{
Contract.Requires(request != null);
try
{
var apiVersion = request.GetRequestedApiVersion();
}
catch (AmbiguousApiVersionException ex)
{
var options = request.GetApiVersioningOptions();
var context = new ErrorResponseContext(request, "AmbiguousApiVersion", ex.Message, messageDetail: null);
throw new HttpResponseException(options.ErrorResponses.BadRequest(context));
}
}
internal HttpResponseMessage CreateMethodNotAllowedResponse(bool versionNeutral, IEnumerable <HttpMethod> allowedMethods)
{
Contract.Requires(allowedMethods != null);
var response = CreateBadRequestForUnspecifiedApiVersionOrInvalidApiVersion(versionNeutral);
if (response != null)
{
return(response);
}
var requestedMethod = request.Method;
var version = request.GetRequestedApiVersion()?.ToString() ?? "(null)";
var message = default(string);
var messageDetail = default(string);
if (versionNeutral)
{
message = SR.VersionedResourceNotSupported.FormatDefault(request.RequestUri, version);
messageDetail = SR.VersionedControllerNameNotFound.FormatDefault(request.RequestUri, version);
}
else
{
message = SR.VersionedMethodNotSupported.FormatDefault(version, requestedMethod);
messageDetail = SR.VersionedActionNameNotFound.FormatDefault(request.RequestUri, requestedMethod, version);
}
TraceWriter.Info(request, ControllerSelectorCategory, message);
var context = new ErrorResponseContext(request, "UnsupportedApiVersion", message, messageDetail);
response = Options.ErrorResponses.MethodNotAllowed(context);
if (response.Content == null)
{
response.Content = new StringContent(Empty);
response.Content.Headers.ContentType = null;
}
var headers = response.Content.Headers;
if (headers.Allow.Count == 0)
{
headers.Allow.AddRange(allowedMethods.Select(m => m.Method));
}
return(response);
}
public override IActionResult CreateResponse(ErrorResponseContext context)
{
switch (context.ErrorCode)
{
case "UnsupportedApiVersion":
return(new ObjectResult(new ReturnResult()
{
Status = (int)ReturnResultStatus.VersionError,
Message = "无该版本"
}));
case "AmbiguousApiVersion":
return(new ObjectResult(new ReturnResult()
{
Status = (int)ReturnResultStatus.VersionError,
Message = "头部版本与参数版本不一致"
}));
}
return(base.CreateResponse(context));
}
public IActionResult CreateResponse(ErrorResponseContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var detail = new ValidationProblemDetails(
new Dictionary <string, string[]>
{
{ context.ErrorCode, new[] { context.Message } },
});
telemetry?.TrackTrace(
"BadVersion",
new Dictionary <string, string>
{
{ "Response.Body", JsonSerializer.Serialize(detail) },
});
return(new BadRequestObjectResult(detail));
}
protected override IDictionary <string, object> CreateErrorContent(ErrorResponseContext context)
{
Contract.Ensures(Contract.Result <IDictionary <string, object> >() != null);
var comparer = StringComparer.OrdinalIgnoreCase;
var error = new Dictionary <string, object>(comparer);
var root = new Dictionary <string, object>(comparer)
{
["error"] = error
};
if (!IsNullOrEmpty(context.ErrorCode))
{
error["code"] = context.ErrorCode;
}
if (!IsNullOrEmpty(context.Message))
{
error["message"] = context.Message;
}
if (!IsNullOrEmpty(context.MessageDetail))
{
var environment = (IHostingEnvironment)context.Request.HttpContext.RequestServices.GetService(typeof(IHostingEnvironment));
if (environment?.IsDevelopment() == true)
{
error["innerError"] = new Dictionary <string, object>(comparer)
{
["message"] = context.MessageDetail
};
}
}
return(root);
}
public override IActionResult CreateResponse(ErrorResponseContext context) => ErrorResult(new InvalidRequestException(context.Message));
public IActionResult CreateResponse(ErrorResponseContext context)
{
return(new BadRequestObjectResult(new BadRequestVersionMessage()));
}
private static TError NewInnerError <TError>(ErrorResponseContext context, Func <ErrorResponseContext, TError> create)
{
if (string.IsNullOrEmpty(context.MessageDetail))
{
return(default);
/// <summary> /// Creates the default error content using the given context. /// </summary> /// <param name="context">The <see cref="ErrorResponseContext">error context</see> used to create the error content.</param> /// <returns>An <see cref="object"/> representing the error content.</returns> protected virtual object CreateErrorContent(ErrorResponseContext context) => new ApiVersionProblemDetails(context);
/// <summary>
/// Creates and returns a new error response given the provided context.
/// </summary>
/// <param name="context">The <see cref="ErrorResponseContext">error context</see> used to generate the response.</param>
/// <returns>The generated <see cref="IActionResult">response</see>.</returns>
public virtual IActionResult CreateResponse(ErrorResponseContext context)
=> new ObjectResult(CreateErrorContent(context))
{
StatusCode = context.StatusCode
};
