public IActionResult Ajax(HttpStatusCodes statusCode,
object data = null,
string msg = null)
{
var ajaxResult = new AjaxResult()
{
Status = statusCode == HttpStatusCodes.Ok,
Code = statusCode,
Msg = msg,
Data = data
};
switch (statusCode)
{
case HttpStatusCodes.Ok:
return(Ok(ajaxResult));
case HttpStatusCodes.Unauthorized:
return(Unauthorized(ajaxResult));
case HttpStatusCodes.NotFound:
return(NotFound(ajaxResult));
case HttpStatusCodes.BadRequest:
return(BadRequest(ajaxResult));
default:
return(Ok(ajaxResult));
}
}
public AjaxResult(bool status,
HttpStatusCodes statusCode,
string msg)
{
Status = status;
Code = statusCode;
Msg = msg;
}
public void TestHttpStatusCodes_GetCodeNumber_BrokenCodes()
{
Assert.AreEqual(-1, HttpStatusCodes.GetCodeNumber("40"));
Assert.AreEqual(-1, HttpStatusCodes.GetCodeNumber("Not Found"));
Assert.AreEqual(-1, HttpStatusCodes.GetCodeNumber("5000 Something"));
Assert.AreEqual(-1, HttpStatusCodes.GetCodeNumber(""));
Assert.AreEqual(-1, HttpStatusCodes.GetCodeNumber(null));
}
private void ProcessRequest(object state)
{
var context = (IHttpListenerContext)state;
_Logger.Log(LogLevel.Informational, context.Request.HttpMethod + " " + context.Request.RemoteEndPoint + ": " + context.Request.Url);
try
{
try
{
string method = context.Request.HttpMethod;
IWebDAVMethodHandler methodHandler;
if (!_MethodHandlers.TryGetValue(method, out methodHandler))
{
throw new HttpMethodNotAllowedException(string.Format(CultureInfo.InvariantCulture, "%s ({0})", context.Request.HttpMethod));
}
context.Response.AppendHeader("DAV", "1,2,1#extend");
methodHandler.ProcessRequest(this, context, Store, _Logger);
}
catch (HttpException)
{
throw;
}
catch (FileNotFoundException ex)
{
throw new HttpNotFoundException(innerException: ex);
}
catch (DirectoryNotFoundException ex)
{
throw new HttpNotFoundException(innerException: ex);
}
catch (NotImplementedException ex)
{
throw new HttpNotImplementedException(innerException: ex);
}
catch (Exception ex)
{
throw new HttpInternalServerException(innerException: ex);
}
}
catch (HttpException ex)
{
context.Response.StatusCode = ex.StatusCode;
context.Response.StatusDescription = HttpStatusCodes.GetName(ex.StatusCode);
if (ex.Message != context.Response.StatusDescription)
{
byte[] buffer = Encoding.UTF8.GetBytes(ex.Message);
context.Response.ContentEncoding = Encoding.UTF8;
context.Response.ContentLength64 = buffer.Length;
context.Response.OutputStream.Write(buffer, 0, buffer.Length);
}
context.Response.Close();
}
finally
{
_Logger.Log(LogLevel.Informational, context.Response.StatusCode + " " + context.Response.StatusDescription + ": " + context.Request.HttpMethod + " " + context.Request.RemoteEndPoint + ": " + context.Request.Url);
}
}
public async Task ProcessRequest_With503Fallback_Returns503()
{
var handler = new FallbackResponseHandler(FallbackResponse.Http503ServiceUnavailable);
var context = new MockHttpContext();
await handler.ProcessRequest(context);
Assert.AreEqual(503, context.Response.StatusCode);
Assert.AreEqual(HttpStatusCodes.GetStatusDescription(503), context.Response.StatusDescription);
}
public async Task ProcessRequest_With404Fallback_Returns404()
{
var handler = new FallbackResponseHandler(FallbackResponse.Http404NotFound);
var context = new MockHttpContext();
await handler.ProcessRequest(context);
Assert.AreEqual(404, context.Response.StatusCode);
Assert.AreEqual(HttpStatusCodes.GetStatusDescription(404), context.Response.StatusDescription);
}
/// <summary>
/// Processes an incoming HTTP request.
/// </summary>
/// <param name="context">The <see cref="IStumpsHttpContext" /> representing both the incoming request and the response.</param>
/// <returns>
/// A member of the <see cref="ProcessHandlerResult" /> enumeration.
/// </returns>
/// <exception cref="ArgumentNullException"><paramref name="context"/> is <c>null</c>.</exception>
public async Task <ProcessHandlerResult> ProcessRequest(IStumpsHttpContext context)
{
context = context ?? throw new ArgumentNullException(nameof(context));
var remoteUrl = BuildRemoteUrlFromContext(context);
// Create a new HTTP web request
var remoteWebRequest = (HttpWebRequest)WebRequest.Create(remoteUrl);
remoteWebRequest.AllowAutoRedirect = false;
// Populate the headers for the new HTTP request from the incoming HTTP request
PopulateRemoteHeadersFromContext(context, remoteWebRequest);
// Populate the HTTP body for the request
var webResponseResult = await PopulateRemoteBodyFromContext(context, remoteWebRequest);
var continueProcess = webResponseResult.Success;
// Execute the remote web request
if (continueProcess)
{
await ExecuteRemoteWebRequest(remoteWebRequest, webResponseResult);
}
if (!continueProcess)
{
// Return a response to the client that the service is unavailable at this time.
context.Response.StatusCode = HttpStatusCodes.HttpServiceUnavailable;
context.Response.StatusDescription =
HttpStatusCodes.GetStatusDescription(HttpStatusCodes.HttpServiceUnavailable);
}
else if (webResponseResult.Response != null)
{
// Write the headers and the body of the response from the remote HTTP request
// to the incoming HTTP context.
WriteContextHeadersFromResponse(context, webResponseResult.Response);
await WriteContextBodyFromRemoteResponse(context, webResponseResult.Response);
context.Response.StatusCode = (int)webResponseResult.Response.StatusCode;
context.Response.StatusDescription = webResponseResult.Response.StatusDescription;
var disposable = webResponseResult.Response as IDisposable;
disposable.Dispose();
}
if (context.Response is StumpsHttpResponse stumpsResponse)
{
stumpsResponse.Origin = HttpResponseOrigin.RemoteServer;
}
this.ContextProcessed?.Invoke(this, new StumpsContextEventArgs(context));
return(await Task.FromResult <ProcessHandlerResult>(ProcessHandlerResult.Continue));
}
private static string GetMessage(int statusCode, string message)
{
string format = "%s";
if (!StringEx.IsNullOrWhiteSpace(message))
{
format = message;
}
return(format.Replace("%s", HttpStatusCodes.GetName(statusCode)));
}
/// <summary>
/// Sends a simple response with a specified HTTP status code but no content.
/// </summary>
/// <param name="context">
/// The <see cref="IHttpListenerContext"/> to send the response through.
/// </param>
/// <param name="statusCode">
/// The HTTP status code for the response.
/// </param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="context"/> is <c>null</c>.</para>
/// </exception>
public static void SendSimpleResponse(this IHttpListenerContext context, int statusCode = HttpStatusCodes.Successful.OK)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
context.Response.StatusCode = statusCode;
context.Response.StatusDescription = HttpStatusCodes.GetName(statusCode);
context.Response.Close();
}
public static WebException Create(int code, string message = null, string url = null)
{
if (string.IsNullOrEmpty(message) && HttpStatusCodes.TryGetValue(code, out string httpMessage))
{
message = code.ToString() + " " + httpMessage;
}
if (!string.IsNullOrEmpty(url))
{
message += " (" + url + ")";
}
return(new(code, message));
}
public async Task <HttpResponse> ExecuteApiCallAsync(HttpRequestPriority priority, HttpRequest request, int timeout = 0, params HttpStatusCode[] ignoreErrorCodes)
{
var response = await _client.ExecuteAsStringResponseAsync(priority, request, timeout).ConfigureAwait(false);
if (response.IsSuccessful || ignoreErrorCodes.Contains(response.StatusCode))
{
return(response);
}
if (HttpStatusCodes.IsErrorStatus(response.StatusCode))
{
throw new HttpException("Error status code received", response);
}
return(response);
}
/// <summary>
/// Initializes a new instance of the <see cref="FallbackResponseHandler"/> class.
/// </summary>
/// <param name="response">The default response.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="response"/> is <c>null</c>.</exception>
public FallbackResponseHandler(FallbackResponse response)
{
if (!Enum.IsDefined(typeof(FallbackResponse), response))
{
throw new ArgumentOutOfRangeException(nameof(response));
}
// Fallback to 503 Service Unavailable when undefined
response = response == FallbackResponse.Undefined ? FallbackResponse.Http503ServiceUnavailable : response;
_statusCode = (int)response;
_statusCodeDescription = HttpStatusCodes.GetStatusDescription(_statusCode);
_origin = response == FallbackResponse.Http404NotFound
? HttpResponseOrigin.NotFoundResponse
: HttpResponseOrigin.ServiceUnavailable;
}
private bool ValidateResponse(HttpResponse response, bool shouldCheckIfForbidden = false, params HttpStatusCode[] ignoreErrorCodes)
{
if (response.IsSuccessful || ignoreErrorCodes.Contains(response.StatusCode))
{
return(true);
}
if (shouldCheckIfForbidden && !IsSessionValid(response))
{
return(false);
}
if (HttpStatusCodes.IsErrorStatus(response.StatusCode))
{
throw new HttpException("Error status code recieved", response);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpException"/> class.
/// </summary>
/// <param name="statusCode">
/// The HTTP status code that this <see cref="HttpException"/> maps to.
/// </param>
/// <param name="message">
/// The exception message stating the reason for the exception being thrown.
/// </param>
/// <param name="innerException">
/// The <see cref="Exception"/> that is the cause for this exception;
/// or <c>null</c> if no inner exception is specified.
/// </param>
public HttpException(int statusCode, string message = null, Exception innerException = null)
: base(GetMessage(statusCode, message), innerException)
{
StatusCode = statusCode;
StatusDescription = HttpStatusCodes.GetName(statusCode);
}
public void TestHttpStatusCodes_GetCodeNumber()
{
Assert.AreEqual(404, HttpDotNet.HttpStatusCodes.GetCodeNumber("404 Not Found"));
Assert.AreEqual(404, HttpStatusCodes.GetCodeNumber("404 Something Else"));
Assert.AreEqual(404, HttpStatusCodes.GetCodeNumber("404"));
}
public void GetDescription_ForSampleCodes_ReturnsCorrectDescription(int id, string expected)
{
string output = HttpStatusCodes.GetName(id);
Assert.That(output, Is.EqualTo(expected));
}
public void returns_expected_status_code_when_initialized(HttpStatusCodes expected)
{
var sut = new ResourceResponse(expected, "dummy-body");
Assert.Equal(expected, sut.StatusCode);
}
public HttpException(HttpStatusCodes code, string errMsg, Exception inner)
: base(errMsg, inner)
{
_code = code;
}
public HttpException(HttpStatusCodes code, string errMsg) : base(errMsg) {
_code = code;
}
public static string GetStatusCode(HttpStatusCodes code)
{
switch (code)
{
//-------------------------------------------------------------------------------------------1XX
#region StatusCodes 1XX
case (HttpStatusCodes.Continue):
return("100 Continue");
case (HttpStatusCodes.SwitchingProtocols):
return("101 Switching Protocols");
case (HttpStatusCodes.Processing):
return("102 Processing");
#endregion
//-------------------------------------------------------------------------------------------2XX
#region StatusCodes 2XX
case (HttpStatusCodes.OK):
return("200 OK");
case (HttpStatusCodes.Created):
return("201 Created");
case (HttpStatusCodes.Accepted):
return("202 Accepted");
case (HttpStatusCodes.NonAuthoritativeInformation):
return("203 Non-Authoritative Information");
case (HttpStatusCodes.NoContent):
return("204 No Content");
case (HttpStatusCodes.ResetContent):
return("205 Reset Content");
case (HttpStatusCodes.PartialContent):
return("206 Partial Content");
case (HttpStatusCodes.MultiStatus):
return("207 Multi Status");
case (HttpStatusCodes.AlreadyReported):
return("208 Already Reported");
case (HttpStatusCodes.IMUsed):
return("226 IM Used");
#endregion
//-------------------------------------------------------------------------------------------3XX
#region StatusCodes 3XX
case (HttpStatusCodes.MultipleChoices):
return("300 Multiple Choices");
case (HttpStatusCodes.MovedPermanently):
return("301 Moved Permanently");
case (HttpStatusCodes.Found):
return("302 Found");
case (HttpStatusCodes.SeeOther):
return("303 See Other");
case (HttpStatusCodes.NotModified):
return("304 Not Modified");
case (HttpStatusCodes.UseProxy):
return("305 Use Proxy");
case (HttpStatusCodes.SwitchProxy):
return("306 Switch Proxy");
case (HttpStatusCodes.TemporaryRedirect):
return("307 Temporary Redirect");
case (HttpStatusCodes.PermanentRedirect):
return("308 Permanent Redirect");
#endregion
//-------------------------------------------------------------------------------------------4XX
#region StatusCodes 4XX
case (HttpStatusCodes.BadRequest):
return("400 Bad Request");
case (HttpStatusCodes.Unauthorized):
return("401 Unauthorized");
case (HttpStatusCodes.PaymentRequired):
return("402 Payment Required");
case (HttpStatusCodes.Forbidden):
return("403 Forbidden");
case (HttpStatusCodes.NotFound):
return("404 Not Found");
case (HttpStatusCodes.MethodNotAllowed):
return("405 Method Not Allowed");
case (HttpStatusCodes.NotAcceptable):
return("406 Not Acceptable");
case (HttpStatusCodes.ProxyAuthenticationRequired):
return("407 Proxy Authentication Required");
case (HttpStatusCodes.RequestTimeout):
return("408 Request Timeout");
case (HttpStatusCodes.Conflict):
return("409 Conflict");
case (HttpStatusCodes.Gone):
return("410 Gone");
case (HttpStatusCodes.LengthRequired):
return("411 Length Required");
case (HttpStatusCodes.PreconditionFailed):
return("412 Precondition Failed");
case (HttpStatusCodes.PayloadTooLarge):
return("413 Payload Too Large");
case (HttpStatusCodes.URITooLong):
return("414 URI Too Long");
case (HttpStatusCodes.UnsupportedMediaType):
return("415 Unsupported Media Type");
case (HttpStatusCodes.RangeNotSatisfiable):
return("416 Range Not Satisfiable");
case (HttpStatusCodes.ExpectationFailed):
return("417 Expectation Failed");
case (HttpStatusCodes.ImATeapot):
return("418 ImATeapot");
case (HttpStatusCodes.MisdirectedRequest):
return("421 Misdirected Request");
case (HttpStatusCodes.UnprocessableEntity):
return("422 Unprocessable Entity");
case (HttpStatusCodes.Locked):
return("423 Locked");
case (HttpStatusCodes.FailedDependency):
return("424 Failed Dependency");
case (HttpStatusCodes.UpgradeRequired):
return("426 Upgrade Required");
case (HttpStatusCodes.PreconditionRequired):
return("428 Precondition Required");
case (HttpStatusCodes.TooManyRequests):
return("429 Too Many Requests");
case (HttpStatusCodes.RequestHeaderFieldsTooLarge):
return("431 Request Header Fields Too Large");
case (HttpStatusCodes.UnavailableForLegalReasons):
return("451 Unavailable For Legal Reasons");
#endregion
//-------------------------------------------------------------------------------------------5XX
#region StatusCodes 5XX
case (HttpStatusCodes.InternalServerError):
return("500 Internal Server Error");
case (HttpStatusCodes.NotImplemented):
return("501 Not Implemented");
case (HttpStatusCodes.BadGateway):
return("502 Bad Gateway");
case (HttpStatusCodes.ServiceUnavailable):
return("503 Service Unavailable");
case (HttpStatusCodes.GatewayTimeout):
return("504 Gateway Timeout");
case (HttpStatusCodes.HTTPVersionNotSupported):
return("505 HTTP Version Not Supported");
case (HttpStatusCodes.VariantAlsoNegotiates):
return("506 Variant Also Negotiates");
case (HttpStatusCodes.InsufficientStorage):
return("507 Insufficient Storage");
case (HttpStatusCodes.LoopDetected):
return("508 Loop Detected");
case (HttpStatusCodes.NotExtended):
return("510 Not Extended");
case (HttpStatusCodes.NetworkAuthenticationRequired):
return("511 Network Authentication Required");
#endregion
default:
return("500 Internal Server Error");
}
}
