public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
using var read = context.ReaderFactory(context.HttpContext.Request.Body, encoding);
var obj = Serialization.DeserializeUTF16(await read.ReadToEndAsync());
return(await InputFormatterResult.SuccessAsync(obj ?? "null"));
}
/// <summary>
/// Handle text/plain or no content type for string results
/// Handle application/octet-stream for byte[] results
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
var contentType = context.HttpContext.Request.ContentType;
if (string.IsNullOrEmpty(contentType) || contentType == "text/plain")
{
using (var reader = new StreamReader(request.Body))
{
var content = await reader.ReadToEndAsync();
return(await InputFormatterResult.SuccessAsync(content));
}
}
if (contentType == "application/octet-stream")
{
using (var ms = new MemoryStream(2048))
{
await request.Body.CopyToAsync(ms);
var content = ms.ToArray();
return(await InputFormatterResult.SuccessAsync(content));
}
}
return(await InputFormatterResult.FailureAsync());
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
var request = context.HttpContext.Request;
using (var reader = new BsonReader(request.Body))
{
var successful = true;
EventHandler <ErrorEventArgs> errorHandler = (sender, eventArgs) =>
{
successful = false;
var exception = eventArgs.ErrorContext.Error;
eventArgs.ErrorContext.Handled = true;
};
var jsonSerializer = CreateJsonSerializer();
jsonSerializer.Error += errorHandler;
var type = context.ModelType;
object model;
try
{
model = jsonSerializer.Deserialize(reader, type);
}
finally
{
_jsonSerializerPool.Return(jsonSerializer);
}
if (successful)
{
return(InputFormatterResult.SuccessAsync(model));
}
return(InputFormatterResult.FailureAsync());
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var request = context.HttpContext.Request;
if (!request.Body.CanSeek && !_options.SuppressReadBuffering)
{
BufferingHelper.EnableRewind(request);
await request.Body.DrainAsync(CancellationToken.None);
request.Body.Seek(0L, SeekOrigin.Begin);
}
try
{
var result =
MessagePackSerializer.NonGeneric.Deserialize(context.ModelType, request.Body, _options.FormatterResolver);
var formatterResult = await InputFormatterResult.SuccessAsync(result);
return(formatterResult);
}
catch (Exception e)
{
SystemLogger.Instance.LogDebug($"Could not deserialize object {e}");
throw;
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
string s = "";
try
{
var request = context.HttpContext.Request;
var type = context.ModelType;
using (var reader = new StreamReader(request.Body, Encoding.UTF8))
{
s = await reader.ReadToEndAsync();
JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions();
jsonSerializerOptions.Converters.Add(new DateTimeConverter());
jsonSerializerOptions.Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping;
var obj = JsonSerializer.Deserialize(s, type, jsonSerializerOptions);
return(await InputFormatterResult.SuccessAsync(obj));
}
}
catch (Exception ex)
{
var logger = context.HttpContext.RequestServices.Resolve <ILogger <RsInputFormatter> >();
logger?.LogError("传参" + s + " 转换错误" + ex.Message);
return(await InputFormatterResult.FailureAsync());
}
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
var request = context.HttpContext.Request;
using var streamReader = context.ReaderFactory(request.Body, encoding);
var type = context.ModelType;
try
{
var model = _deserializer.Deserialize(streamReader, type);
return(InputFormatterResult.SuccessAsync(model));
}
catch (Exception)
{
return(InputFormatterResult.FailureAsync());
}
}
public Task <InputFormatterResult> ReadAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
var result = MessagePackSerializer.NonGeneric.Deserialize(context.ModelType, request.Body, resolver);
return(InputFormatterResult.SuccessAsync(result));
}
/// <inheritdoc/>
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
// note: *today*, protobuf-net lacks fully async read, so this buffers in the pipe until
// we get the Content-Length that was advertised by the caller
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
var request = context.HttpContext.Request;
var length = request.ContentLength ?? -1;
if (length < 0 || length > _memoryBufferThreshold)
{
// use Stream-based read - either chunked or oversized
// - if buffering is disabled, or if the caller has already buffered it fully (EnableRewind), go direct
// - otherwise uses FileBufferingReadStream based on _memoryBufferThreshold
return((_suppressBuffering || request.Body.CanSeek) ? DirectStreamAsync(context) : BufferedStreamAsync(context));
}
// otherwise, we can use the Pipe itself for in-memory buffering
var reader = request.BodyReader;
// try and read synchronously
if (reader.TryRead(out var readResult) && ProcessReadBuffer(context.ModelType, reader, length, readResult, out var payload))
{
return(InputFormatterResult.SuccessAsync(payload));
}
return(ReadRequestBodyAsyncSlow(context.ModelType, reader, length));
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
if (encoding != Encoding.UTF8)
{
throw Error.BadRequest("FHIR supports UTF-8 encoding exclusively, not " + encoding.WebName);
}
context.HttpContext.AllowSynchronousIO();
try
{
using (TextReader reader = context.ReaderFactory(context.HttpContext.Request.Body, encoding))
{
FhirJsonParser parser = context.HttpContext.RequestServices.GetRequiredService <FhirJsonParser>();
return(await InputFormatterResult.SuccessAsync(parser.Parse(await reader.ReadToEndAsync())));
}
}
catch (FormatException exception)
{
throw Error.BadRequest($"Body parsing failed: {exception.Message}");
}
}
/// <inheritdoc />
public override async Task <InputFormatterResult> ReadRequestBodyAsync([NotNull] InputFormatterContext context)
{
if (CanRead(context))
{
HttpRequest request = context.HttpContext.Request;
string contentType = context.HttpContext.Request.ContentType.ToNullIfEmpty();
if (string.IsNullOrEmpty(contentType) || contentType.IsSame("text/plain"))
{
using (StreamReader reader = new StreamReader(request.Body))
{
string content = await reader.ReadToEndAsync();
return(await InputFormatterResult.SuccessAsync(content));
}
}
await using (MemoryStream ms = new MemoryStream(Constants.GetBufferKB(2)))
{
await request.Body.CopyToAsync(ms);
byte[] content = ms.ToArray();
return(await InputFormatterResult.SuccessAsync(content));
}
}
return(await InputFormatterResult.FailureAsync());
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context,
Encoding encoding)
{
var request = context.HttpContext.Request;
return(InputFormatterResult.SuccessAsync(request.Body.FromUtf8Json(context.ModelType)));
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
CompoundDocument document = this.configuration.Serializer.RequestBodyTo <CompoundDocument>(context.HttpContext, encoding);
object convertedObject = this.configuration.GetInputMapper(context.ModelType).Map(document);
return(InputFormatterResult.SuccessAsync(convertedObject));
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
var request = context.HttpContext.Request;
using (var reader = new StreamReader(request.Body, encoding))
{
try
{
string content = await reader.ReadToEndAsync();
var convertObject = JsonConvert.DeserializeObject <ObjectDefinition>(content,
new ObjectDefintionConverter());
return(await InputFormatterResult.SuccessAsync(convertObject));
}
catch
{
return(await InputFormatterResult.FailureAsync());
}
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
using (var streamReader = context.ReaderFactory(context.HttpContext.Request.Body, encoding))
{
string jsonData = await streamReader.ReadToEndAsync();
var nObj = Newtonsoft.Json.JsonConvert.DeserializeObject(jsonData, context.ModelType);
var modelType = context.ModelType;
try
{
var sbj = SanitizeObject(nObj, modelType);
return(await InputFormatterResult.SuccessAsync(sbj));
}catch (Exception ex)
{
return(await InputFormatterResult.FailureAsync());
}
}
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var reader = GetReader(context);
var jsonObject = ReadFromStream(context, reader);
return(InputFormatterResult.SuccessAsync(jsonObject));
}
/// <inheritdoc />
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding effectiveEncoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (effectiveEncoding == null)
{
throw new ArgumentNullException(nameof(effectiveEncoding));
}
using (var reader = new StreamReader(context.HttpContext.Request.Body, effectiveEncoding))
{
try
{
var result = await reader.ReadToEndAsync();
return(await InputFormatterResult.SuccessAsync(result));
}
catch
{
return(await InputFormatterResult.FailureAsync());
}
}
}
/// <inheritdoc />
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context,
Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
var request = context.HttpContext.Request;
using var streamReader = context.ReaderFactory(request.Body, encoding);
try
{
var text = await streamReader.ReadToEndAsync();
return(await InputFormatterResult.SuccessAsync(text));
}
catch (Exception)
{
return(await InputFormatterResult.FailureAsync());
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
/*
* StreamReader reader = null;
* try
* {
* reader = new StreamReader(request.Body);
* var str = await reader.ReadLineAsync();
* reader.Dispose();
* }
* finally
* {
* reader?.Dispose();
* }
*/
using (var reader = new StreamReader(request.Body))
{
var str = await reader.ReadLineAsync();
var sucess = Guid.TryParse(str, out var result);
if (sucess)
{
return(await InputFormatterResult.SuccessAsync(result));
}
else
{
return(await InputFormatterResult.FailureAsync());
}
}
}
public Task <InputFormatterResult> ReadAsync(InputFormatterContext context)
{
BitcoinStream bs = new BitcoinStream(context.HttpContext.Request.Body, false);
Type type = context.ModelType;
var signature = type == typeof(TransactionSignature);
if (context.ModelType.IsArray)
{
var elementType = context.ModelType.GetElementType();
type = typeof(ArrayWrapper <>).MakeGenericType(elementType);
}
if (signature)
{
type = typeof(SignatureWrapper);
}
var result = _Parse.MakeGenericMethod(type).Invoke(null, new object[] { bs });
if (context.ModelType.IsArray)
{
var getElements = type.GetTypeInfo().GetProperty("Elements", BindingFlags.Instance | BindingFlags.Public).GetGetMethod();
result = getElements.Invoke(result, new object[0]);
}
if (signature)
{
result = ((SignatureWrapper)result).Signature;
}
return(InputFormatterResult.SuccessAsync(result));
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
var request = context.HttpContext.Request;
using (var reader = context.ReaderFactory(request.Body, encoding))
{
object model;
try
{
model = JSON.Deserialize(reader, context.ModelType, _options);
}
catch (DeserializationException exception)
{
_logger.LogDebug(exception, "Exception was occurred during deserialization");
return(InputFormatterResult.FailureAsync());
}
return(InputFormatterResult.SuccessAsync(model));
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
var contentType = context.HttpContext.Request.ContentType;
if (string.IsNullOrEmpty(contentType) ||
ContentMediaTypes.IsContentType(contentType, ContentMediaTypes.Text.Plain))
{
using (var reader = new StreamReader(request.Body))
{
var content = await reader.ReadToEndAsync().ConfigureAwait(false);
return(await InputFormatterResult.SuccessAsync(content).ConfigureAwait(false));
}
}
if (!ContentMediaTypes.IsContentType(contentType, ContentMediaTypes.Application.OctetStream))
{
return(await InputFormatterResult.FailureAsync().ConfigureAwait(false));
}
await using (var ms = new MemoryStream(2048))
{
await request.Body.CopyToAsync(ms).ConfigureAwait(false);
var content = ms.ToArray();
return(await InputFormatterResult.SuccessAsync(content).ConfigureAwait(false));
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
try
{
var request = context.HttpContext.Request;
var contentType = context.HttpContext.Request.ContentType;
if (contentType == "application/octet-stream")
{
using (var ms = new MemoryStream(2048))
{
await request.Body.CopyToAsync(ms);
var content = ms.ToArray();
return(await InputFormatterResult.SuccessAsync(content));
}
}
return(await InputFormatterResult.FailureAsync());
}
catch (Exception ex)
{
Console.WriteLine($"ReadRequestBodyAsync error - {ex.Message}");
throw ex;
}
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var stream = new MemoryStream();
context.HttpContext.Request.Body.CopyTo(stream);
return(InputFormatterResult.SuccessAsync(stream.ToArray()));
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
context.HttpContext.Request.Headers.TryGetValue("face", out StringValues face);
var request = context.HttpContext.Request;
if (face == "true")
{
using (var reader = new StreamReader(request.Body))
{
var content = await reader.ReadToEndAsync();
return(await InputFormatterResult.SuccessAsync(content));
}
}
else
{
MemoryStream streamReader;
byte[] result;
using (streamReader = new MemoryStream())
{
request.Body.CopyTo(streamReader);
result = streamReader.ToArray();
}
return(await InputFormatterResult.SuccessAsync(streamReader));
}
}
public async Task BindModel_CallsSelectedInputFormatterOnce()
{
// Arrange
var mockInputFormatter = new Mock <IInputFormatter>();
mockInputFormatter.Setup(f => f.CanRead(It.IsAny <InputFormatterContext>()))
.Returns(true)
.Verifiable();
mockInputFormatter.Setup(o => o.ReadAsync(It.IsAny <InputFormatterContext>()))
.Returns(InputFormatterResult.SuccessAsync(new Person()))
.Verifiable();
var inputFormatter = mockInputFormatter.Object;
var provider = new TestModelMetadataProvider();
provider.ForType <Person>().BindingDetails(d => d.BindingSource = BindingSource.Body);
var bindingContext = GetBindingContext(
typeof(Person),
metadataProvider: provider);
var binder = CreateBinder(new[] { inputFormatter });
// Act
await binder.BindModelAsync(bindingContext);
// Assert
mockInputFormatter.Verify(v => v.CanRead(It.IsAny <InputFormatterContext>()), Times.Once);
mockInputFormatter.Verify(v => v.ReadAsync(It.IsAny <InputFormatterContext>()), Times.Once);
Assert.True(bindingContext.Result.IsModelSet);
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
IServiceProvider serviceProvider = context.HttpContext.RequestServices;
MessagePackOptions options = serviceProvider.GetService(typeof(MessagePackOptions)) as MessagePackOptions;
MessagePack.IFormatterResolver resolver = options?.Resolver;
if (resolver == null)
{
return(InputFormatterResult.FailureAsync());
}
Type actionModelType = context.ModelType;
var serializerType = typeof(MessagePackSerializer);
var deserializeMethod = serializerType.GetMethod("Deserialize", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(Stream), typeof(IFormatterResolver) }, null);
deserializeMethod = deserializeMethod?.MakeGenericMethod(actionModelType);
var streamParameter = Expression.Parameter(typeof(Stream), "stream");
var formatterResolver = Expression.Parameter(typeof(IFormatterResolver), "resolver");
var deserializationExpression = Expression.Call(deserializeMethod, streamParameter, formatterResolver);
var lambda = Expression.Lambda <DeserializeMethod>(deserializationExpression, new ParameterExpression[] { streamParameter, formatterResolver }).Compile();
var request = context.HttpContext.Request;
object instance = lambda(request.Body, resolver);
return(InputFormatterResult.SuccessAsync(instance));
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
var httpContext = context.HttpContext;
using var reader = new StreamReader(httpContext.Request.Body, encoding);
try
{
var json = await reader.ReadToEndAsync();
switch (httpContext.Request.Method)
{
case Http.Post:
var providerMessageModel = JsonConvert.DeserializeObject <ProviderMessageModel>(json);
// можно вынести в настройки
providerMessageModel.Name = "ProviderA";
return(await InputFormatterResult.SuccessAsync(providerMessageModel.GetProviderEntity()));
default:
return(await InputFormatterResult.FailureAsync());
}
}
catch
{
return(await InputFormatterResult.FailureAsync());
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
using (var reader = new StreamReader(context.HttpContext.Request.Body, encoding))
{
try
{
var input = await reader.ReadToEndAsync();
var obj = Xml.Deserialize <SoapXmlEnvelope>(input, typeCollections);
if (obj != null)
{
return(await InputFormatterResult.SuccessAsync(obj.Body.Data));
}
else
{
return(await InputFormatterResult.NoValueAsync());
}
}
catch
{
return(await InputFormatterResult.FailureAsync());
}
}
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
var request = context.HttpContext.Request;
var result = JsonSerializer.NonGeneric.Deserialize(context.ModelType, request.Body, resolver);
return(InputFormatterResult.SuccessAsync(result));
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
var request = context.HttpContext.Request;
try
{
var cloudEvent = await request.ReadCloudEventAsync(_formatter);
return(await InputFormatterResult.SuccessAsync(cloudEvent));
}
catch (Exception)
{
return(await InputFormatterResult.FailureAsync());
}
}