public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding is null)
{
throw new ArgumentNullException(nameof(encoding));
}
var request = context.HttpContext.Request;
using var reader = new StreamReader(request.Body, encoding);
try
{
return(await InputFormatterResult.SuccessAsync(await reader.ReadToEndAsync()));
}
catch
{
return(await InputFormatterResult.FailureAsync());
}
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var request = context.HttpContext.Request;
using (var reader = context.ReaderFactory(request.Body, encoding))
{
try
{
return(InputFormatterResult.SuccessAsync(JSON.Deserialize(reader, context.ModelType, _options)));
}
catch (DeserializationException ex)
{
context.ModelState.AddModelError(context.ModelType.Name, ex.Message);
}
catch (Exception ex)
{
}
return(InputFormatterResult.FailureAsync());
}
}
/// <summary>
/// Reads and formats the request body based on the gladnet specifications.
/// </summary>
/// <param name="context">Formatter context.</param>
/// <returns>Waitable formatter result.</returns>
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
try
{
//we expect a request message to ASP servers so we should deserialize as a request message.
RequestMessage message = deserializerStrategy.Deserialize <RequestMessage>(context.HttpContext.Request.Body);
//if nothing was deserialized we should return failure
if (message == null)
{
return(InputFormatterResult.FailureAsync());
}
//This is important as we must deserialize the payload before passing it to the recieving controller
message.Payload.Deserialize(deserializerStrategy);
//If the payload is null or the datastate isn't default now then we failed
if (message.Payload.Data == null || message.Payload.DataState != NetSendableState.Default)
{
return(InputFormatterResult.FailureAsync());
}
return(InputFormatterResult.SuccessAsync(message));
}
catch (Exception)
{
return(InputFormatterResult.FailureAsync());
}
}
public Task <InputFormatterResult> ReadAsync(InputFormatterContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var request = context.HttpContext.Request;
if (request.ContentLength == 0)
{
return(InputFormatterResult.SuccessAsync(null));
}
try
{
var body = GetRequestBody(context.HttpContext.Request.Body);
var model = _jsonApiContext.IsRelationshipPath ?
_deSerializer.DeserializeRelationship(body) :
_deSerializer.Deserialize(body);
if (model == null)
{
_logger?.LogError("An error occurred while de-serializing the payload");
}
return(InputFormatterResult.SuccessAsync(model));
}
catch (JsonSerializationException ex)
{
_logger?.LogError(new EventId(), ex, "An error occurred while de-serializing the payload");
context.HttpContext.Response.StatusCode = 422;
return(InputFormatterResult.FailureAsync());
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
var contentType = context.HttpContext.Request.ContentType;
if (string.IsNullOrEmpty(contentType) || contentType.Contains("text/plain") ||
contentType.Contains("application/json"))
{
using (var reader = new StreamReader(request.Body))
{
var content = await reader.ReadToEndAsync();
if (IsContentValidBase64(content))
{
byte[] data = Convert.FromBase64String(content);
content = System.Text.Encoding.UTF8.GetString(data);
}
content = RemoveUnnecessaryChar(content);
return(await InputFormatterResult.SuccessAsync(content));
}
}
return(await InputFormatterResult.FailureAsync());
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var req = context.HttpContext.Request;
var ms = context.ModelState;
var type = context.ModelType;
object result = null;
var serializer = new JsonSerializer();
serializer.Error += (s, a) =>
{
var memberInfo = a.ErrorContext.Member.ToString();
var errorMsg = a.ErrorContext.Error.GetBaseException().Message;
ms.AddModelError(memberInfo, errorMsg);
a.ErrorContext.Handled = true;
};
serializer.DefaultValueHandling = DefaultValueHandling.Populate;
result = Utility.DeserializeStream(req.Body, type, serializer);
// If errors abort
if (ms.ErrorCount != 0)
{
return(await InputFormatterResult.FailureAsync());
}
return(await InputFormatterResult.SuccessAsync(result));
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
if (!request.ContentLength.HasValue || request.ContentLength == 0)
{
return(await InputFormatterResult.FailureAsync());
}
var mediaRequest = new ArticleEntryMediaRequest();
using (var streamContent = new StreamContent(request.Body))
{
var mediaBytes = await streamContent.ReadAsByteArrayAsync();
var base64Hash = mediaBytes.ComputeMD5HashBase54();
mediaRequest.MediaContent = mediaBytes;
mediaRequest.MD5Base64Hash = base64Hash;
}
mediaRequest.FileName = TryGetFileName(context);
mediaRequest.ContentType = TryMediaGetContentType(context);
return(await InputFormatterResult.SuccessAsync(mediaRequest));
}
public override SystemTask.Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
var request = context.HttpContext.Request;
using (var streamReader = context.ReaderFactory(request.Body, encoding))
using (JsonTextReader jsonReader = new JsonTextReader(streamReader))
{
var type = context.ModelType;
try
{
//TODO: parse json
//TODO: create a simple model to allow passthrough to validation because a missing element will throw wrong error here
var resource = new FhirJsonParser().Parse(jsonReader, type);
return(InputFormatterResult.SuccessAsync(resource));
}
catch (Exception ex)
{
//TODO: Remove Fhir Hack
if (ex != null)
{
//Assuming invalid json here, see above
return(InputFormatterResult.SuccessAsync(OperationOutcomeFactory.CreateInvalidRequest()));
}
return(InputFormatterResult.FailureAsync());
}
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
var contentType = context.HttpContext.Request.ContentType;
if (string.IsNullOrEmpty(contentType) ||
contentType.Contains(_applicationJson) ||
contentType.Contains(_textPlain))
{
using (var reader = new StreamReader(request.Body))
{
var content = await reader.ReadToEndAsync();
var decoded = await _encodeDecodeStrategy.Decode(content);
if (contentType.Contains(_applicationJson))
{
return(await InputFormatterResult.SuccessAsync(JsonConvert.DeserializeObject(decoded, context.ModelType)));
}
return(await InputFormatterResult.SuccessAsync(decoded));
}
}
return(await InputFormatterResult.FailureAsync());
}
/// <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;
// TODO: Use BodyReader and the NEW Span<T>
if (context.ModelType == typeof(string))
{
using (var reader = new StreamReader(request.Body))
{
string content = await reader.ReadToEndAsync();
return(await InputFormatterResult.SuccessAsync(content));
}
}
else if (context.ModelType == typeof(byte[]))
{
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 async Task <InputFormatterResult> ReadRequestBodyAsync(
InputFormatterContext context, Encoding effectiveEncoding)
{
var httpContext = context.HttpContext;
var serviceProvider = httpContext.RequestServices;
var logger = serviceProvider.GetRequiredService <ILogger <VcardInputFormatter> >();
using var reader = new StreamReader(httpContext.Request.Body, effectiveEncoding);
string?nameLine = null;
try
{
await ReadLineAsync("BEGIN:VCARD", reader, context, logger);
await ReadLineAsync("VERSION:", reader, context, logger);
nameLine = await ReadLineAsync("N:", reader, context, logger);
var split = nameLine.Split(";".ToCharArray());
var contact = new Contact(FirstName: split[1], LastName: split[0].Substring(2));
await ReadLineAsync("FN:", reader, context, logger);
await ReadLineAsync("END:VCARD", reader, context, logger);
logger.LogInformation("nameLine = {nameLine}", nameLine);
return(await InputFormatterResult.SuccessAsync(contact));
}
catch
{
logger.LogError("Read failed: nameLine = {nameLine}", nameLine);
return(await InputFormatterResult.FailureAsync());
}
}
public override SystemTask.Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
var request = context.HttpContext.Request;
using (var streamReader = context.ReaderFactory(request.Body, encoding))
using (XmlTextReader xmlReader = new XmlTextReader(streamReader))
{
var type = context.ModelType;
try
{
var settings = new ParserSettings
{
AllowUnrecognizedEnums = true,
AcceptUnknownMembers = false
};
var resource = new FhirXmlParser().Parse(xmlReader, type);
return(InputFormatterResult.SuccessAsync(resource));
}
catch (Exception ex)
{
context.ModelState.AddModelError("InputFormatter", ex.Message);
return(InputFormatterResult.FailureAsync());
}
}
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
var request = context.HttpContext.Request;
if (!context.HttpContext.Request.Headers.TryGetValue("X-Compress", out var header))
{
return(await InputFormatterResult.FailureAsync());
}
string compAlgo = header.ToString();
string eAmuseInfo = null;
if (context.HttpContext.Request.Headers.TryGetValue("X-Eamuse-Info", out header))
{
eAmuseInfo = header.ToString();
}
byte[] data;
using (var ms = new MemoryStream((int)(request.ContentLength ?? 512L)))
{
await request.Body.CopyToAsync(ms);
data = ms.ToArray();
}
return(await ProcessInputData(data, eAmuseInfo, compAlgo));
}
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());
}
}
}
/// <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());
}
/// text/plain or no content type => string
/// application/octet-stream => byte[] (those less than RawRequestBodyFormatter.MemoryStreamCapacity)
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext ctx)
{
var request = ctx.HttpContext.Request;
var mediaType = GetMediaType(ctx.HttpContext.Request);
if (mediaType.IsSubsetOf(TextPlain))
{
using (var reader = new StreamReader(request.Body, mediaType.Encoding ?? Encoding.UTF8))
return(await InputFormatterResult.SuccessAsync(await reader.ReadToEndAsync()));
}
else if (mediaType.IsSubsetOf(OctetStream))
{
if (request.ContentLength > MemoryStreamCapacity)
{
goto fail;
}
using (var ms = new MemoryStream(MemoryStreamCapacity))
{
await request.Body.CopyToAsync(ms);
return(await InputFormatterResult.SuccessAsync(ms.ToArray()));
}
}
fail:
return(await InputFormatterResult.FailureAsync());
}
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)
{
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 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());
}
}
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 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));
}
var request = context.HttpContext.Request;
using (var reader = new StreamReader(request.Body, effectiveEncoding)) {
try {
var textJson = await reader.ReadToEndAsync();
var circuit = await _dtoDeserializer.DeserializeFromText(textJson);
return(await InputFormatterResult.SuccessAsync(circuit));
} catch {
return(await InputFormatterResult.FailureAsync());
}
}
}
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));
}
using (var reader = new StreamReader(context.HttpContext.Request.Body, encoding))
{
try
{
var model = Jil.JSON.Deserialize(reader, context.ModelType, JilSerializer.JilOptions);
return(InputFormatterResult.SuccessAsync(model));
}
catch (Exception ex)
{
// https://github.com/aspnet/Docs/blob/master/aspnetcore/mvc/advanced/custom-formatters/Sample/Formatters/VcardInputFormatter.cs
// TODO: context.ModelState.TryAddModelError(context.ModelName, ex.Message);
context.ModelState.TryAddModelError(string.Empty, ex.Message);
return(InputFormatterResult.FailureAsync());
}
}
}
/// <summary>
/// Read the body of the input formatter request and produce an action that
/// can be mapped to the calling object context
/// </summary>
/// <param name="context">The incoming request context</param>
/// <returns>A success of failure result containing the object to be mapped</returns>
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
try
{
// Get the outgoing bound type to map to
Type modelType = context.ModelType;
// Load an Xml Document with the incoming stream
XmlDocument doc = new XmlDocument();
doc.LoadXml(GetBody(context.HttpContext.Request));
// Convert the XmlDocument to a Json Text representation
string jsonText = JsonConvert.SerializeXmlNode(doc, Formatting.Indented);
// Create a new outbound message
Object outboundMessage = Activator.CreateInstance(modelType);
// Convert the Json representation to the object
outboundMessage = JsonConvert.DeserializeObject(jsonText,
modelType,
new JsonSerializerSettings()
{
});
// Return the result
return(await InputFormatterResult.SuccessAsync(outboundMessage));
}
catch (Exception ex)
{
// Failed to process this request
return(await InputFormatterResult.FailureAsync());
}
}
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding is null)
{
throw new ArgumentNullException(nameof(encoding));
}
var request = context.HttpContext.Request;
using var streamReader = context.ReaderFactory(request.Body, encoding);
var type = context.ModelType;
#pragma warning disable CA1031 // Do not catch general exception types
try
{
var model = deserializer.Deserialize(streamReader, type);
return(InputFormatterResult.SuccessAsync(model));
}
catch
{
return(InputFormatterResult.FailureAsync());
}
#pragma warning restore CA1031 // Do not catch general exception types
}
/// <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());
}
/// <inheritdoc />
public override async Task <InputFormatterResult> ReadRequestBodyAsync([NotNull] InputFormatterContext context, [NotNull] Encoding encoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
HttpRequest request = context.HttpContext.Request;
if (!request.Body.CanSeek)
{
request.EnableBuffering();
await request.Body.DrainAsync(context.HttpContext.RequestAborted);
if (context.HttpContext.RequestAborted.IsCancellationRequested)
{
return(await InputFormatterResult.NoValueAsync());
}
request.Body.Seek(0L, SeekOrigin.Begin);
}
using (TextReader reader = context.ReaderFactory(request.Body, encoding))
{
using (CsvReader csvReader = new CsvReader(reader, Configuration))
{
Type modelType = context.ModelType;
try
{
await csvReader.ReadAsync();
csvReader.ReadHeader();
if (modelType.Implements <IEnumerable>())
{
modelType = modelType.ResolveGenericType();
IEnumerable <object> models = csvReader.GetRecords(modelType);
return(models != null || context.TreatEmptyInputAsDefaultValue
? await InputFormatterResult.SuccessAsync(models)
: await InputFormatterResult.NoValueAsync());
}
object model = csvReader.GetRecord(modelType);
return(model != null || context.TreatEmptyInputAsDefaultValue
? await InputFormatterResult.SuccessAsync(model)
: await InputFormatterResult.NoValueAsync());
}
catch (Exception e)
{
ExceptionDispatchInfo.Capture(e).Throw();
return(await InputFormatterResult.FailureAsync());
}
}
}
}
/// <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 == MediaTypeNames.Text.Plain)
{
using (var reader = new StreamReader(request.Body))
{
var content = await reader.ReadToEndAsync();
return(await InputFormatterResult.SuccessAsync(content));
}
}
if (contentType == MediaTypeNames.Application.Octet)
{
using (var ms = new MemoryStream(2048))
{
await request.Body.CopyToAsync(ms);
var content = ms.ToArray();
return(await InputFormatterResult.SuccessAsync(content));
}
}
if (context.HttpContext.Request.HasFormContentType)
{
Dictionary <string, object> formResult = new Dictionary <string, object>();
var form = context.HttpContext.Request.Form;
foreach (var formFile in form.Files)
{
byte[] data;
using (var br = new BinaryReader(formFile.OpenReadStream()))
data = br.ReadBytes((int)formFile.OpenReadStream().Length);
object obj;
if (context.HttpContext.Request.Headers.ContainsKey("Compress"))
{
obj = Util.ConvertByteArrayToObject(Util.Decompress((Util.Decompress(data))));
}
else
{
obj = Util.ConvertByteArrayToObject(data);
}
formResult.Add(formFile.Name, obj);
}
var result = await InputFormatterResult.SuccessAsync(formResult);
return(result);
}
return(await InputFormatterResult.FailureAsync());
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
HttpRequest request = context.HttpContext.Request;
IContentReader reader = _readers[request.ContentType];
(bool success, IMessage msg) = await reader.Read(context.ModelType, request.Body);
return(success ? await InputFormatterResult.SuccessAsync(msg) : await InputFormatterResult.FailureAsync());
}
// TODO: Понятные ошибки формата
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
var reader = new StreamReader(
context.HttpContext.Request.Body,
encoding);
var inp = await reader.ReadToEndAsync();
if (string.IsNullOrWhiteSpace(inp))
{
return(await InputFormatterResult.NoValueAsync());
}
try
{
var values = inp.Split("~").Select(v =>
{
var nameValuePair = v.Split("=");
if (nameValuePair.Length != 2)
{
throw new FormatException();
}
return(new
{
Name = nameValuePair[0],
Value = nameValuePair[1]
});
});
var namedValues = values.ToDictionary(v => v.Name, v => v.Value);
if (namedValues.Count != 2)
{
throw new FormatException();
}
if (!namedValues.TryGetValue("Name", out var name))
{
throw new FormatException();
}
if (!namedValues.TryGetValue("Description", out var description))
{
throw new FormatException();
}
return(await InputFormatterResult.SuccessAsync(
new NewProduct(name, description)
));
}
catch
{
return(await InputFormatterResult.FailureAsync());
}
}
/// <summary>
/// Reads and formats the request body based on the Protobuf-Net specifications.
/// </summary>
/// <param name="context">Formatter context.</param>
/// <returns>Waitable formatter result.</returns>
public override Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
try
{
return(InputFormatterResult.SuccessAsync(ProtoBuf.Serializer.Deserialize(context.ModelType, context.HttpContext.Request.Body)));
}
catch (Exception)
{
return(InputFormatterResult.FailureAsync());
}
}