private async Task <T> GetRequestBodyAsync <T>(HttpRequest request)
{
T objRequestBody = default(T);
// IMPORTANT: Ensure the requestBody can be read multiple times.
HttpRequestRewindExtensions.EnableBuffering(request);
// IMPORTANT: Leave the body open so the next middleware can read it.
using (
StreamReader reader = new StreamReader(
request.Body,
Encoding.UTF8,
detectEncodingFromByteOrderMarks: false,
leaveOpen: true
)
)
{
string strRequestBody = await reader.ReadToEndAsync();
objRequestBody = Newtonsoft.Json.JsonConvert.DeserializeObject <T>(strRequestBody);
// IMPORTANT: Reset the request body stream position so the next middleware can read it
request.Body.Position = 0;
}
return(objRequestBody);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected string ReadBody()
{
var body = string.Empty;
try
{
var request = _context
.HttpContext
.Request;
// IMPORTANT: Ensure the requestBody can be read multiple times.
HttpRequestRewindExtensions.EnableBuffering(request);
// Leave the body open so the next middleware can read it.
using var reader = new StreamReader(
request.Body,
encoding: Encoding.UTF8,
detectEncodingFromByteOrderMarks: false,
bufferSize: -1,
leaveOpen: true);
body = reader.ReadToEnd();
// Do some processing with body…
// Reset the request body stream position so the next middleware can read it
request.Body.Position = 0;
}
catch { }
return(body);
}
private async Task <string> FormatRequest(HttpRequest request)
{
Stream body = null;
body = request.Body;
HttpRequestRewindExtensions.EnableBuffering(request);
//This line allows us to set the reader for the request back at the beginning of its stream.
//request.EnableRewind();
//We now need to read the request stream. First, we create a new byte[] with the same length as the request stream...
var buffer = new byte[Convert.ToInt32(request.ContentLength)];
request.Body.Seek(0, SeekOrigin.Begin);
//...Then we copy the entire request stream into the new buffer.
await request.Body.ReadAsync(buffer, 0, buffer.Length);
//We convert the byte[] into a string using UTF8 encoding...
var bodyAsText = Encoding.UTF8.GetString(buffer);
//..and finally, assign the read body back to the request body, which is allowed because of EnableRewind()
request.Body = body;
return($"{request.Scheme} {request.Host}{request.Path} {request.QueryString} {bodyAsText}");
}
private async Task <string> ReadRequestBody(HttpRequest request)
{
HttpRequestRewindExtensions.EnableBuffering(request);
var buffer = new byte[Convert.ToInt32(request.ContentLength)];
await request.Body.ReadAsync(buffer, 0, buffer.Length);
var bodyAsText = Encoding.UTF8.GetString(buffer);
request.Body.Seek(0, SeekOrigin.Begin);
return(bodyAsText);
}
private async Task <TRequestBody> ReadBody(HttpRequest request)
{
HttpRequestRewindExtensions.EnableBuffering(request);
using (StreamReader reader = new StreamReader(request.Body, Encoding.UTF8, leaveOpen: true))
{
var content = await reader.ReadToEndAsync();
request.Body.Position = 0;
return(JsonConvert.DeserializeObject <TRequestBody>(content));
}
}
/// <summary>
///
/// </summary>
/// <param name="httpContext"></param>
/// <returns></returns>
public async Task Invoke(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
// Push the user name into the log context so that it is included in all log entries
LogContext.PushProperty("UserName", httpContext.User.Identity.Name);
// Getting the request body is a little tricky because it's a stream
// So, we need to read the stream and then rewind it back to the beginning
string requestBody = "";
HttpRequestRewindExtensions.EnableBuffering(httpContext.Request);
Stream body = httpContext.Request.Body;
byte[] buffer = new byte[Convert.ToInt32(httpContext.Request.ContentLength)];
await httpContext.Request.Body.ReadAsync(buffer, 0, buffer.Length);
requestBody = Encoding.UTF8.GetString(buffer);
body.Seek(0, SeekOrigin.Begin);
httpContext.Request.Body = body;
Log.ForContext("RequestHeaders", httpContext.Request.Headers.ToDictionary(h => h.Key, h => h.Value.ToString()), destructureObjects: true)
.ForContext("RequestBody", requestBody)
.Debug("Request information {RequestMethod} {RequestPath} information", httpContext.Request.Method, httpContext.Request.Path);
Log.Debug(string.Format("Request Body: {0} ", requestBody));
// The reponse body is also a stream so we need to:
// - hold a reference to the original response body stream
// - re-point the response body to a new memory stream
// - read the response body after the request is handled into our memory stream
// - copy the response in the memory stream out to the original response stream
using (var responseBodyMemoryStream = new MemoryStream())
{
var originalResponseBodyReference = httpContext.Response.Body;
httpContext.Response.Body = responseBodyMemoryStream;
await _next(httpContext);
httpContext.Response.Body.Seek(0, SeekOrigin.Begin);
var responseBody = await new StreamReader(httpContext.Response.Body).ReadToEndAsync();
httpContext.Response.Body.Seek(0, SeekOrigin.Begin);
Log.ForContext("RequestBody", requestBody)
.ForContext("ResponseBody", responseBody)
.Debug("Response information {RequestMethod} {RequestPath} {statusCode}", httpContext.Request.Method, httpContext.Request.Path, httpContext.Response.StatusCode);
await responseBodyMemoryStream.CopyToAsync(originalResponseBodyReference);
}
}
public async Task Invoke(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
string requestBody = "";
HttpRequestRewindExtensions.EnableBuffering(httpContext.Request);
Stream body = httpContext.Request.Body;
byte[] buffer = new byte[Convert.ToInt32(httpContext.Request.ContentLength)];
await httpContext.Request.Body.ReadAsync(buffer, 0, buffer.Length);
requestBody = Encoding.UTF8.GetString(buffer);
body.Seek(0, SeekOrigin.Begin);
httpContext.Request.Body = body;
try
{
await _next(httpContext);
if (httpContext.Response.StatusCode == (int)System.Net.HttpStatusCode.InternalServerError)
{
Log.ForContext("RequestHeaders", httpContext.Request.Headers.ToDictionary(h => h.Key, h => h.Value.ToString()), destructureObjects: true)
.ForContext("RequestBody", requestBody)
.Error("Request information {RequestMethod} {RequestPath} {StatusCode}", httpContext.Request.Method, httpContext.Request.Path, httpContext.Response.StatusCode);
}
else
{
Log.ForContext("RequestHeaders", httpContext.Request.Headers.ToDictionary(h => h.Key, h => h.Value.ToString()), destructureObjects: true)
.ForContext("RequestBody", requestBody)
.Debug("Request information {RequestMethod} {RequestPath} {StatusCode}", httpContext.Request.Method, httpContext.Request.Path, httpContext.Response.StatusCode);
}
}
catch (Exception exception)
{
Guid errorId = Guid.NewGuid();
Log.ForContext("Type", "Error")
.ForContext("Exception", exception, destructureObjects: true)
.Error(exception, exception.Message + ". {@errorId}", errorId);
var result = JsonConvert.SerializeObject(new { error = "Sorry, an unexpected error has occurred", errorId = errorId });
httpContext.Response.ContentType = "application/json";
httpContext.Response.StatusCode = 500;
await httpContext.Response.WriteAsync(result);
}
}
/// <summary>
/// Capture JSON request dari HTTP context
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private async Task <string> FormatRequest(HttpRequest request)
{
HttpRequestRewindExtensions.EnableBuffering(request);
var body = request.Body;
byte[] buffer = new byte[Convert.ToInt32(request.ContentLength)];
await request.Body.ReadAsync(buffer, 0, buffer.Length);
string requestBody = Encoding.UTF8.GetString(buffer);
requestBody = RemoveLFCR(requestBody);
body.Seek(0, SeekOrigin.Begin);
request.Body = body;
return(requestBody);
}
private async Task <string> ReadRequestBody(HttpRequest request)
{
HttpRequestRewindExtensions.EnableBuffering(request);
// hiddenString = number.Substring(number.Length - 4).PadLeft(number.Length, '*');
var body = request.Body;
var buffer = new byte[Convert.ToInt32(request.ContentLength)];
await request.Body.ReadAsync(buffer, 0, buffer.Length);
string requestBody = Encoding.UTF8.GetString(buffer);
body.Seek(0, SeekOrigin.Begin);
request.Body = body;
return($"{requestBody}");
}
public async Task <string> GetRequestBodyAsync(HttpRequest request)
{
string strRequestBody = "";
// IMPORTANT: Ensure the requestBody can be read multiple times.
HttpRequestRewindExtensions.EnableBuffering(request);
// IMPORTANT: Leave the body open so the next middleware can read it.
using (StreamReader reader = new StreamReader(request.Body, Encoding.UTF8, detectEncodingFromByteOrderMarks: false, leaveOpen: true))
{
strRequestBody = await reader.ReadToEndAsync();
// IMPORTANT: Reset the request body stream position so the next middleware can read it
request.Body.Position = 0;
}
return(strRequestBody);
}
public async Task <ActionResult> SaveReplay(long game_id)
{
// Allows using several time the stream in ASP.Net Core
HttpRequestRewindExtensions.EnableBuffering(Request);
// Arguments: Stream, Encoding, detect encoding, buffer size
// AND, the most important: keep stream opened
int size = (int)Request.ContentLength;
var b = new byte[size];
size = await Request.Body.ReadAsync(b, 0, size);
// Rewind, so the core is not lost when it looks the body for the request
Request.Body.Position = 0;
await System.IO.File.WriteAllBytesAsync("replays/" + game_id + ".zip", b);
return(Ok());
}
/// <summary>
/// Returns Request Body string from Body stream
/// </summary>
/// <param name="request"></param>
/// <returns>string</returns>
public static string GetBodyString(this HttpRequest request)
{
HttpRequestRewindExtensions.EnableBuffering(request);
var bodyString = string.Empty;
using (var memoryReader = new MemoryStream())
using (var reader = new StreamReader(memoryReader))
{
request.Body.Position = 0;
request.Body.CopyToAsync(memoryReader);
memoryReader.Position = 0;
memoryReader.Seek(0, SeekOrigin.Begin);
bodyString = reader.ReadToEndAsync().GetAwaiter().GetResult();
request.Body.Position = 0;
}
return(bodyString);
}
/// <summary>
/// Is valid request.
/// </summary>
/// <typeparam name="TModel">The request model</typeparam>
/// <param name="httpRequest">The http request</param>
/// <param name="condition">the valid condition</param>
/// <returns>true/false based on the evaluation of the condition</returns>
internal async static Task <bool> IsValid <TModel>(this HttpRequest httpRequest, Func <TModel, bool> condition)
{
// Allows using several time the stream in ASP.Net Core
HttpRequestRewindExtensions.EnableBuffering(httpRequest);
using (MemoryStream m = new MemoryStream())
{
await httpRequest.Body.CopyToAsync(m);
var bodyString = Encoding.UTF8.GetString(m.ToArray());
httpRequest.Body.Position = 0;
var model = JsonConvert.DeserializeObject <TModel>(bodyString);
return(condition(model));
}
}
//TODO: evaluate if using OrderCloudIntegrationException for errors works as expected
protected override async Task <AuthenticateResult> HandleAuthenticateAsync()
{
Require.DoesNotExist(Options.HashKey, async() => await Task.FromResult(AuthenticateResult.Fail(AUTH_FAIL_MSG)));
Require.DoesNotExist(Context.Request.Headers.ContainsKey(OC_HASH), async() => await Task.FromResult(AuthenticateResult.Fail(AUTH_FAIL_MSG)));
Require.DoesNotExist(Context.Request.Headers[OC_HASH].FirstOrDefault(), async() => await Task.FromResult(AuthenticateResult.Fail(AUTH_FAIL_MSG)));
var hash_header = Context.Request.Headers[OC_HASH].FirstOrDefault();
// alternative to Context.Request.EnableRewind() which is no longer available
// allows us to set Request Body position back to 0
HttpRequestRewindExtensions.EnableBuffering(Context.Request);
try
{
Require.ThatHashMatches(hash_header, Options.HashKey, Context.Request.Body, async() => await Task.FromResult(AuthenticateResult.Fail(HASH_MATCH_FAIL)));
var ticket = new AuthenticationTicket(new ClaimsPrincipal(new ClaimsIdentity(AUTH_SCHEME)), AUTH_SCHEME);
return(await Task.FromResult(AuthenticateResult.Success(ticket)));
}
finally
{
Context.Request.Body.Position = 0;
}
}
public async Task Invoke(HttpContext context)
{
HttpRequestRewindExtensions.EnableBuffering(context.Request);
var buffer = new byte[Convert.ToInt32(context.Request.ContentLength)];
await context.Request.Body.ReadAsync(buffer, 0, buffer.Length);
var requestBody = Encoding.UTF8.GetString(buffer);
context.Request.Body.Seek(0, SeekOrigin.Begin);
var builder = new StringBuilder(Environment.NewLine);
foreach (var header in context.Request.Headers)
{
builder.AppendLine($"{header.Key}:{header.Value}");
}
builder.AppendLine($"Request body:{requestBody}");
_logger.LogInformation(builder.ToString( ));
await _next(context);
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (encoding == null)
{
throw new ArgumentNullException("encoding");
}
var request = context.HttpContext.Request;
if (!request.Body.CanSeek)
{
HttpRequestRewindExtensions.EnableBuffering(request);
await StreamHelperExtensions.DrainAsync(request.Body, CancellationToken.None);
request.Body.Seek(0L, SeekOrigin.Begin);
}
using (TextReader textReader = context.ReaderFactory(request.Body, encoding))
{
var modelType = context.ModelType;
if (modelType.IsArray)
{
var itemType = modelType.GetElementType();
var arr = new ArrayList();
while (true)
{
var line = textReader.ReadLine();
if (string.IsNullOrEmpty(line))
{
break;
}
var obj = GetModel(line, itemType);
arr.Add(obj);
}
var modelList = arr.ToArray(itemType);
return(await InputFormatterResult.SuccessAsync(modelList));
}
else if (typeof(IEnumerable).IsAssignableFrom(modelType))
{
var itemType = modelType.GenericTypeArguments[0];
var listType = typeof(List <>).MakeGenericType(itemType);
IList modelList = (IList)Activator.CreateInstance(listType);
while (true)
{
var line = textReader.ReadLine();
if (string.IsNullOrEmpty(line))
{
break;
}
var obj = GetModel(line, itemType);
modelList.Add(obj);
}
return(await InputFormatterResult.SuccessAsync(modelList));
}
else
{
var obj = GetModel(textReader.ReadLine(), modelType);
return(await InputFormatterResult.SuccessAsync(obj));
}
}
}
