/// <inheritdoc /> public override bool CanRead(InputFormatterContext context) { if (!typeof(IJsonPatchDocument).IsAssignableFrom(context.ModelType) || !context.ModelType.IsGenericType()) { return false; } return base.CanRead(context); }
/// <inheritdoc /> public virtual async Task<object> ReadAsync(InputFormatterContext context) { var request = context.HttpContext.Request; if (request.ContentLength == 0) { return GetDefaultValueForType(context.ModelType); } return await ReadRequestBodyAsync(context); }
/// <inheritdoc /> public override bool CanRead(InputFormatterContext context) { var modelTypeInfo = context.ModelType.GetTypeInfo(); if (!typeof(IJsonPatchDocument).GetTypeInfo().IsAssignableFrom(modelTypeInfo) || !modelTypeInfo.IsGenericType) { return false; } return base.CanRead(context); }
public override Task<object> ReadRequestBodyAsync(InputFormatterContext context) { var type = context.ModelType; var request = context.ActionContext.HttpContext.Request; MediaTypeHeaderValue requestContentType = null; MediaTypeHeaderValue.TryParse(request.ContentType, out requestContentType); object result = Model.Deserialize(context.ActionContext.HttpContext.Request.Body, null, type); return Task.FromResult(result); }
public override Task<object> ReadRequestBodyAsync(InputFormatterContext context) { var request = context.HttpContext.Request; MediaTypeHeaderValue requestContentType = null; MediaTypeHeaderValue.TryParse(request.ContentType, out requestContentType); var effectiveEncoding = SelectCharacterEncoding(requestContentType); using (var reader = new StreamReader(request.Body, effectiveEncoding)) { var stringContent = reader.ReadToEnd(); return Task.FromResult<object>(stringContent); } }
/// <inheritdoc /> public virtual bool CanRead(InputFormatterContext context) { if (!CanReadType(context.ModelType)) { return false; } var contentType = context.HttpContext.Request.ContentType; MediaTypeHeaderValue requestContentType; if (!MediaTypeHeaderValue.TryParse(contentType, out requestContentType)) { return false; } return SupportedMediaTypes .Any(supportedMediaType => supportedMediaType.IsSubsetOf(requestContentType)); }
/// <inheritdoc /> public override Task<object> ReadRequestBodyAsync(InputFormatterContext context) { var type = context.ModelType; var request = context.HttpContext.Request; using (var bsonReader = CreateBsonReader(context, request.Body)) { bsonReader.CloseInput = false; var jsonSerializer = CreateJsonSerializer(); EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs> errorHandler = null; errorHandler = (sender, e) => { var exception = e.ErrorContext.Error; context.ModelState.TryAddModelError(e.ErrorContext.Path, e.ErrorContext.Error); // Error must always be marked as handled // Failure to do so can cause the exception to be rethrown at every recursive level and // overflow the stack for x64 CLR processes e.ErrorContext.Handled = true; }; jsonSerializer.Error += errorHandler; try { return Task.FromResult(jsonSerializer.Deserialize(bsonReader, type)); } finally { // Clean up the error handler in case CreateJsonSerializer() reuses a serializer if (errorHandler != null) { jsonSerializer.Error -= errorHandler; } } } }
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState() { // Arrange var content = "{name: 'Person Name', Age: 'not-an-age'}"; var formatter = new JsonInputFormatter(); var contentBytes = Encoding.UTF8.GetBytes(content); var actionContext = GetActionContext(contentBytes); var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(User)); var context = new InputFormatterContext(actionContext, metadata.ModelType); actionContext.ModelState.MaxAllowedErrors = 3; actionContext.ModelState.AddModelError("key1", "error1"); actionContext.ModelState.AddModelError("key2", "error2"); // Act var model = await formatter.ReadAsync(context); // Assert Assert.False(actionContext.ModelState.ContainsKey("age")); var error = Assert.Single(actionContext.ModelState[""].Errors); Assert.IsType <TooManyModelErrorsException>(error.Exception); }
public async Task JsonPatchInputFormatter_ReadsMultipleOperations_Successfully() { // Arrange var formatter = new JsonPatchInputFormatter(); var content = "[{\"op\": \"add\", \"path\" : \"Customer/Name\", \"value\":\"John\"}," + "{\"op\": \"remove\", \"path\" : \"Customer/Name\"}]"; var contentBytes = Encoding.UTF8.GetBytes(content); var modelState = new ModelStateDictionary(); var httpContext = GetHttpContext(contentBytes); var context = new InputFormatterContext(httpContext, modelState, typeof(JsonPatchDocument <Customer>)); // Act var model = await formatter.ReadAsync(context); // Assert var patchDoc = Assert.IsType <JsonPatchDocument <Customer> >(model); Assert.Equal("add", patchDoc.Operations[0].op); Assert.Equal("Customer/Name", patchDoc.Operations[0].path); Assert.Equal("John", patchDoc.Operations[0].value); Assert.Equal("remove", patchDoc.Operations[1].op); Assert.Equal("Customer/Name", patchDoc.Operations[1].path); }
/// <summary> /// Called during deserialization to get the <see cref="JsonReader"/>. /// </summary> /// <param name="context">The <see cref="InputFormatterContext"/> for the read.</param> /// <param name="readStream">The <see cref="Stream"/> from which to read.</param> /// <param name="effectiveEncoding">The <see cref="Encoding"/> to use when reading.</param> /// <returns>The <see cref="JsonReader"/> used during deserialization.</returns> public virtual JsonReader CreateJsonReader([NotNull] InputFormatterContext context, [NotNull] Stream readStream, [NotNull] Encoding effectiveEncoding) { return(new JsonTextReader(new StreamReader(readStream, effectiveEncoding))); }
/// <summary> /// Reads the request body. /// </summary> /// <param name="context">The <see cref="InputFormatterContext"/> associated with the call.</param> /// <returns>A task which can read the request body.</returns> public abstract Task<object> ReadRequestBodyAsync(InputFormatterContext context);
public bool CanRead(InputFormatterContext context) { throw new NotImplementedException(); }
public Task<object> ReadAsync(InputFormatterContext context) { throw new NotImplementedException(); }
/// <summary> /// Reads the request body. /// </summary> /// <param name="context">The <see cref="InputFormatterContext"/> associated with the call.</param> /// <returns>A task which can read the request body.</returns> public abstract Task <object> ReadRequestBodyAsync(InputFormatterContext context);
public override bool CanRead(InputFormatterContext context) { return true; }
public override Task <object> ReadRequestBodyAsync(InputFormatterContext context) { throw new InvalidOperationException("Your input is bad!"); }
/// <summary> /// Called during deserialization to get the <see cref="BsonReader"/>. /// </summary> /// <param name="context">The <see cref="InputFormatterContext"/> for the read.</param> /// <param name="readStream">The <see cref="Stream"/> from which to read.</param> /// <returns>The <see cref="BsonReader"/> used during deserialization.</returns> protected virtual BsonReader CreateBsonReader( InputFormatterContext context, Stream readStream) { return new BsonReader(readStream); }
public Task <object> ReadAsync(InputFormatterContext context) { throw new NotImplementedException(); }