public void SelectResponseCharacterEncoding_SelectsEncoding(
string acceptCharsetHeaders,
string[] supportedEncodings,
string expectedEncoding)
{
// Arrange
var httpContext = new Mock<HttpContext>();
var httpRequest = new DefaultHttpContext().Request;
httpRequest.Headers[HeaderNames.AcceptCharset] = acceptCharsetHeaders;
httpRequest.Headers[HeaderNames.Accept] = "application/acceptCharset";
httpContext.SetupGet(o => o.Request).Returns(httpRequest);
var formatter = new TestOutputFormatter();
foreach (string supportedEncoding in supportedEncodings)
{
formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
}
var context = new OutputFormatterWriteContext(
httpContext.Object,
new TestHttpResponseStreamWriterFactory().CreateWriter,
typeof(string),
"someValue")
{
ContentType = new StringSegment(httpRequest.Headers[HeaderNames.Accept]),
};
// Act
var actualEncoding = formatter.SelectCharacterEncoding(context);
// Assert
Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding);
}
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
string callback;
if (IsJsonpRequest(context.HttpContext.Request, _callbackQueryParameter, out callback))
{
if (!CallbackValidator.IsValid(callback))
{
throw new InvalidOperationException($"Callback '{callback}' is invalid!");
}
using (var writer = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding))
{
// the /**/ is a specific security mitigation for "Rosetta Flash JSONP abuse"
// the typeof check is just to reduce client error noise
writer.Write("/**/ typeof " + callback + " === 'function' && " + callback + "(");
writer.Flush();
_jsonMediaTypeFormatter.WriteObject(writer, context.Object);
writer.Write(");");
await writer.FlushAsync();
}
}
else
{
await _jsonMediaTypeFormatter.WriteResponseBodyAsync(context, selectedEncoding);
}
}
public void SelectFormatter_WithNoProvidedContentType_DoesConneg()
{
// Arrange
var executor = CreateExecutor();
var formatters = new List<IOutputFormatter>
{
new TestXmlOutputFormatter(),
new TestJsonOutputFormatter(), // This will be chosen based on the accept header
};
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null);
context.HttpContext.Request.Headers[HeaderNames.Accept] = "application/json";
// Act
var formatter = executor.SelectFormatter(
context,
new MediaTypeCollection { "application/json" },
formatters);
// Assert
Assert.Same(formatters[1], formatter);
MediaTypeAssert.Equal("application/json", context.ContentType);
}
public async Task WriteAsync(OutputFormatterWriteContext context)
{
using (var responceStream = new StreamWriter(context.HttpContext.Response.Body, Encoding.UTF8))
{
await responceStream.WriteAsync(JsonConvert.SerializeObject(context.Object, SerializerSettings));
}
}
public void CanWriteResult_ByDefault_ReturnsTrue_IfTheValueIsNull(
object value,
bool declaredTypeAsString,
bool expected,
bool useNonNullContentType)
{
// Arrange
var type = declaredTypeAsString ? typeof(string) : typeof(object);
var contentType = useNonNullContentType ? new StringSegment("text/plain") : new StringSegment();
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
type,
value)
{
ContentType = contentType,
};
var formatter = new HttpNoContentOutputFormatter();
// Act
var result = formatter.CanWriteResult(context);
// Assert
Assert.Equal(expected, result);
}
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context)
{
var response = context.HttpContext.Response;
//var selectedEncoding = context.ContentType.Encoding == null ? Encoding.UTF8 : context.ContentType.Encoding;
var selectedEncoding = Encoding.UTF8;
var value = context.Object;
if (value is IEdmModel || context.HttpContext.ODataProperties().Model == null)
{
using (var delegatingStream = new NonDisposableStream(response.Body))
using (var writer = new StreamWriter(delegatingStream, selectedEncoding, 1024, leaveOpen: true))
{
if (value is IEdmModel)
{
WriteMetadata(writer, (IEdmModel)value);
}
using (var jsonWriter = CreateJsonWriter(writer))
{
var jsonSerializer = CreateJsonSerializer();
jsonSerializer.Serialize(jsonWriter, value);
}
}
}
else
{
using (var delegatingStream = new NonDisposableStream(response.Body))
{
await WriteObjectAsync(delegatingStream, context);
}
}
}
public async Task WriteAsync(OutputFormatterWriteContext context)
{
var response = context.HttpContext.Response;
var responseMessage = context.Object as HttpResponseMessage;
if (responseMessage == null)
{
var message = Resources.FormatHttpResponseMessageFormatter_UnsupportedType(
nameof(HttpResponseMessageOutputFormatter),
nameof(HttpResponseMessage));
throw new InvalidOperationException(message);
}
using (responseMessage)
{
response.StatusCode = (int)responseMessage.StatusCode;
var responseFeature = context.HttpContext.Features.Get<IHttpResponseFeature>();
if (responseFeature != null)
{
responseFeature.ReasonPhrase = responseMessage.ReasonPhrase;
}
var responseHeaders = responseMessage.Headers;
// Ignore the Transfer-Encoding header if it is just "chunked".
// We let the host decide about whether the response should be chunked or not.
if (responseHeaders.TransferEncodingChunked == true &&
responseHeaders.TransferEncoding.Count == 1)
{
responseHeaders.TransferEncoding.Clear();
}
foreach (var header in responseHeaders)
{
response.Headers.Append(header.Key, header.Value.ToArray());
}
if (responseMessage.Content != null)
{
var contentHeaders = responseMessage.Content.Headers;
// Copy the response content headers only after ensuring they are complete.
// We ask for Content-Length first because HttpContent lazily computes this
// and only afterwards writes the value into the content headers.
var unused = contentHeaders.ContentLength;
foreach (var header in contentHeaders)
{
response.Headers.Append(header.Key, header.Value.ToArray());
}
await responseMessage.Content.CopyToAsync(response.Body);
}
}
}
/// <inheritdoc />
public Task WriteAsync(OutputFormatterWriteContext context)
{
var response = context.HttpContext.Response;
response.ContentLength = 0;
if (response.StatusCode == StatusCodes.Status200OK)
{
response.StatusCode = StatusCodes.Status204NoContent;
}
return Task.FromResult(true);
}
public ODataJsonSerializer(OutputFormatterWriteContext context)
{
_context = context;
_odataProperties = context.HttpContext.ODataProperties();
_version = ODataProperties.DefaultODataVersion;
MessageWriterSettings = new ODataMessageWriterSettings
{
Indent = true,
DisableMessageStreamDisposal = true,
MessageQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue },
AutoComputePayloadMetadataInJson = true,
};
}
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
var contact = (Contact)context.Object;
var builder = new StringBuilder();
builder.AppendLine("BEGIN:VCARD");
builder.AppendFormat("FN:{0}", contact.Name);
builder.AppendLine();
builder.AppendLine("END:VCARD");
await context.HttpContext.Response.WriteAsync(
builder.ToString(),
selectedEncoding);
}
public async Task WriteAsync(OutputFormatterWriteContext context)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
var response = context.HttpContext.Response;
using (var writer = context.WriterFactory(response.Body, Encoding.UTF8))
{
var responseJson = SerializationService.SerializeWithRoot(context.Object, _outputPayloadFormatOptions);
await writer.WriteAsync(responseJson);
await writer.FlushAsync();
}
}
public async Task WriteAsync_Sets406NotAcceptable()
{
// Arrange
var formatter = new HttpNotAcceptableOutputFormatter();
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null);
// Act
await formatter.WriteAsync(context);
// Assert
Assert.Equal(StatusCodes.Status406NotAcceptable, context.HttpContext.Response.StatusCode);
}
public void CanWriteResult_ForNullContentType_UsesFirstEntryInSupportedContentTypes()
{
// Arrange
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null);
var formatter = new TestOutputFormatter();
// Act
var result = formatter.CanWriteResult(context);
// Assert
Assert.True(result);
Assert.Equal(formatter.SupportedMediaTypes[0].ToString(), context.ContentType.ToString());
}
public void CanWriteResult_OnlyActsOnStreams(Type type)
{
// Arrange
var formatter = new StreamOutputFormatter();
var @object = type != null ? Activator.CreateInstance(type) : null;
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
type,
@object);
// Act
var result = formatter.CanWriteResult(context);
// Assert
Assert.False(result);
}
public async Task WriteAsync(OutputFormatterWriteContext context) {
string mediaType = context.ContentType.HasValue ? context.ContentType.Value : null;
object value = null;
var halResponse = ((HALResponse)context.Object);
// If it is a HAL response but set to application/json - convert to a plain response
var serializer = JsonSerializer.Create();
if(!halResponse.Config.ForceHAL && !halJsonMediaTypes.Contains(mediaType)) {
value = halResponse.ToPlainResponse(serializer);
} else {
value = halResponse.ToJObject(serializer);
}
var jsonContext = new OutputFormatterWriteContext(context.HttpContext, context.WriterFactory, value.GetType(), value);
await jsonFormatter.WriteAsync(jsonContext);
}
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (selectedEncoding == null)
{
throw new ArgumentNullException(nameof(selectedEncoding));
}
var response = context.HttpContext.Response;
using (var bsonWriter = new BsonWriter(response.Body) { CloseOutput = false })
{
var jsonSerializer = CreateJsonSerializer();
jsonSerializer.Serialize(bsonWriter, context.Object);
bsonWriter.Flush();
}
}
public void CanWriteResult_ReturnsTrue_IfReturnTypeIsVoidOrTask(Type declaredType)
{
// Arrange
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
declaredType,
"Something non null.")
{
ContentType = new StringSegment("text/plain"),
};
var formatter = new HttpNoContentOutputFormatter();
// Act
var result = formatter.CanWriteResult(context);
// Assert
Assert.True(result);
}
public void CanWriteResult_ReturnsTrue_WhenConnegHasFailed()
{
// Arrange
var formatter = new HttpNotAcceptableOutputFormatter();
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
FailedContentNegotiation = true,
};
// Act
var result = formatter.CanWriteResult(context);
// Assert
Assert.True(result);
}
public void CanWriteResult_ReturnsTrue_ForStreams(Type type, string contentType)
{
// Arrange
var formatter = new StreamOutputFormatter();
var contentTypeHeader = new StringSegment(contentType);
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
type,
new MemoryStream())
{
ContentType = contentTypeHeader,
};
// Act
var canWrite = formatter.CanWriteResult(context);
// Assert
Assert.True(canWrite);
}
public void CanWriteResult_OnlyActsOnStreams_IgnoringContentType(Type type, string contentType)
{
// Arrange
var formatter = new StreamOutputFormatter();
var contentTypeHeader = contentType == null ? new StringSegment() : new StringSegment(contentType);
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
type,
new SimplePOCO())
{
ContentType = contentTypeHeader,
};
// Act
var canWrite = formatter.CanWriteResult(context);
// Assert
Assert.False(canWrite);
}
/// <inheritdoc />
public async Task WriteAsync(OutputFormatterWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
using (var valueAsStream = ((Stream)context.Object))
{
var response = context.HttpContext.Response;
if (context.ContentType != null)
{
response.ContentType = context.ContentType.ToString();
}
var bufferingFeature = context.HttpContext.Features.Get<IHttpBufferingFeature>();
bufferingFeature?.DisableResponseBuffering();
await valueAsStream.CopyToAsync(response.Body);
}
}
public void CanWrite_ReturnsFalse_ForUnsupportedType()
{
// Arrange
var formatter = new TypeSpecificFormatter();
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
formatter.SupportedTypes.Add(typeof(int));
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
typeof(string),
"Hello, world!")
{
ContentType = new StringSegment(formatter.SupportedMediaTypes[0].ToString()),
};
// Act
var result = formatter.CanWriteResult(context);
// Assert
Assert.False(result);
}
/// <summary>
/// Selects the <see cref="IOutputFormatter"/> to write the response.
/// </summary>
/// <param name="formatterContext">The <see cref="OutputFormatterWriteContext"/>.</param>
/// <param name="contentTypes">
/// The list of content types provided by <see cref="ObjectResult.ContentTypes"/>.
/// </param>
/// <param name="formatters">
/// The list of <see cref="IOutputFormatter"/> instances to consider.
/// </param>
/// <returns>
/// The selected <see cref="IOutputFormatter"/> or <c>null</c> if no formatter can write the response.
/// </returns>
protected virtual IOutputFormatter SelectFormatter(
OutputFormatterWriteContext formatterContext,
MediaTypeCollection contentTypes,
IList <IOutputFormatter> formatters)
{
if (formatterContext == null)
{
throw new ArgumentNullException(nameof(formatterContext));
}
if (contentTypes == null)
{
throw new ArgumentNullException(nameof(contentTypes));
}
if (formatters == null)
{
throw new ArgumentNullException(nameof(formatters));
}
var request = formatterContext.HttpContext.Request;
var acceptableMediaTypes = GetAcceptableMediaTypes(request);
var selectFormatterWithoutRegardingAcceptHeader = false;
IOutputFormatter selectedFormatter = null;
if (acceptableMediaTypes.Count == 0)
{
// There is either no Accept header value, or it contained */* and we
// are not currently respecting the 'browser accept header'.
Logger.NoAcceptForNegotiation();
selectFormatterWithoutRegardingAcceptHeader = true;
}
else
{
if (contentTypes.Count == 0)
{
// Use whatever formatter can meet the client's request
selectedFormatter = SelectFormatterUsingSortedAcceptHeaders(
formatterContext,
formatters,
acceptableMediaTypes);
}
else
{
// Verify that a content type from the context is compatible with the client's request
selectedFormatter = SelectFormatterUsingSortedAcceptHeadersAndContentTypes(
formatterContext,
formatters,
acceptableMediaTypes,
contentTypes);
}
if (selectedFormatter == null && !ReturnHttpNotAcceptable)
{
Logger.NoFormatterFromNegotiation(acceptableMediaTypes);
selectFormatterWithoutRegardingAcceptHeader = true;
}
}
if (selectFormatterWithoutRegardingAcceptHeader)
{
if (contentTypes.Count == 0)
{
selectedFormatter = SelectFormatterNotUsingContentType(
formatterContext,
formatters);
}
else
{
selectedFormatter = SelectFormatterUsingAnyAcceptableContentType(
formatterContext,
formatters,
contentTypes);
}
}
return(selectedFormatter);
}
public override Encoding SelectCharacterEncoding(OutputFormatterWriteContext context)
{
return _encoding;
}
public void WriteResponseContentHeaders_NoSupportedEncodings_NoEncodingIsSet()
{
// Arrange
var formatter = new TestOutputFormatter();
var testContentType = new StringSegment("text/json");
formatter.SupportedEncodings.Clear();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/json"));
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = testContentType,
};
// Act
formatter.WriteResponseHeaders(context);
// Assert
Assert.Null(MediaTypeHeaderValue.Parse(context.ContentType.Value).Encoding);
Assert.Equal(testContentType, context.ContentType);
// If we had set an encoding, it would be part of the content type header
Assert.Equal(MediaTypeHeaderValue.Parse(testContentType.Value), context.HttpContext.Response.GetTypedHeaders().ContentType);
}
private IHtmlElement[] CookieInformation(OutputFormatterWriteContext ctx)
{
return(ctx.HttpContext.Request.Cookies
.Select(c => new Span($"{c.Key}={c.Value}"))
.Cast <IHtmlElement>().ToArray());
}
/// <summary>
/// Called during serialization to create the <see cref="JsonSerializer"/>.The formatter context
/// that is passed gives an ability to create serializer specific to the context.
/// </summary>
/// <param name="context">A context object for <see cref="IOutputFormatter.WriteAsync(OutputFormatterWriteContext)"/>.</param>
/// <returns>The <see cref="JsonSerializer"/> used during serialization and deserialization.</returns>
protected virtual JsonSerializer CreateJsonSerializer(OutputFormatterWriteContext context)
{
return(CreateJsonSerializer());
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(selectedEncoding, nameof(selectedEncoding));
context.HttpContext.AllowSynchronousIO();
var elementsSearchParameter = context.HttpContext.GetElementsOrDefault();
var hasElements = elementsSearchParameter?.Any() == true;
var summaryProvider = _modelInfoProvider.StructureDefinitionSummaryProvider;
var additionalElements = new HashSet <string>();
Resource resourceObject = null;
if (typeof(RawResourceElement).IsAssignableFrom(context.ObjectType))
{
resourceObject = _deserializer.Deserialize(context.Object as RawResourceElement).ToPoco <Resource>();
if (hasElements)
{
var typeinfo = summaryProvider.Provide(resourceObject.TypeName);
var required = typeinfo.GetElements().Where(e => e.IsRequired).ToList();
additionalElements.UnionWith(required.Select(x => x.ElementName));
}
}
else if (typeof(Hl7.Fhir.Model.Bundle).IsAssignableFrom(context.ObjectType))
{
// Need to set Resource property for resources in entries
var bundle = context.Object as Hl7.Fhir.Model.Bundle;
foreach (var entry in bundle.Entry.Where(x => x is RawBundleEntryComponent))
{
var rawResource = entry as RawBundleEntryComponent;
entry.Resource = _deserializer.Deserialize(rawResource.ResourceElement).ToPoco <Resource>();
if (hasElements)
{
var typeinfo = summaryProvider.Provide(entry.Resource.TypeName);
var required = typeinfo.GetElements().Where(e => e.IsRequired).ToList();
additionalElements.UnionWith(required.Select(x => x.ElementName));
}
}
resourceObject = bundle;
}
else
{
resourceObject = (Resource)context.Object;
if (hasElements)
{
var typeinfo = summaryProvider.Provide(resourceObject.TypeName);
var required = typeinfo.GetElements().Where(e => e.IsRequired).ToList();
additionalElements.UnionWith(required.Select(x => x.ElementName));
}
}
if (hasElements)
{
additionalElements.UnionWith(elementsSearchParameter);
additionalElements.Add("meta");
}
HttpResponse response = context.HttpContext.Response;
using (TextWriter textWriter = context.WriterFactory(response.Body, selectedEncoding))
using (var writer = new XmlTextWriter(textWriter))
{
if (context.HttpContext.GetPrettyOrDefault())
{
writer.Formatting = Formatting.Indented;
}
_fhirXmlSerializer.Serialize(resourceObject, writer, context.HttpContext.GetSummaryTypeOrDefault(), elements: hasElements ? additionalElements.ToArray() : null);
}
return(Task.CompletedTask);
}
public Task WriteAsync(OutputFormatterWriteContext context)
{
throw new NotImplementedException();
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context)
{
return(MessagePackSerializer.SerializeAsync(context.HttpContext.Response.Body, context.Object));
}
public void WriteResponse_GetMediaTypeWithCharsetReturnsMediaTypeFromCache_IfEncodingIsUtf8()
{
// Arrange
var formatter = new TestOutputFormatter();
var formatterContext = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = new StringSegment("application/json"),
};
formatter.SupportedMediaTypes.Add("application/json");
formatter.SupportedEncodings.Add(Encoding.UTF8);
// Act
formatter.WriteAsync(formatterContext);
var firstContentType = formatterContext.ContentType;
formatterContext.ContentType = new StringSegment("application/json");
formatter.WriteAsync(formatterContext);
var secondContentType = formatterContext.ContentType;
// Assert
Assert.Same(firstContentType.Buffer, secondContentType.Buffer);
}
/// <summary>
/// Selects the <see cref="IOutputFormatter"/> to write the response.
/// </summary>
/// <param name="formatterContext">The <see cref="OutputFormatterWriteContext"/>.</param>
/// <param name="contentTypes">
/// The list of content types provided by <see cref="ObjectResult.ContentTypes"/>.
/// </param>
/// <param name="formatters">
/// The list of <see cref="IOutputFormatter"/> instances to consider.
/// </param>
/// <returns>
/// The selected <see cref="IOutputFormatter"/> or <c>null</c> if no formatter can write the response.
/// </returns>
protected virtual IOutputFormatter SelectFormatter(
OutputFormatterWriteContext formatterContext,
IList <MediaTypeHeaderValue> contentTypes,
IEnumerable <IOutputFormatter> formatters)
{
if (formatterContext == null)
{
throw new ArgumentNullException(nameof(formatterContext));
}
if (contentTypes == null)
{
throw new ArgumentNullException(nameof(contentTypes));
}
if (formatters == null)
{
throw new ArgumentNullException(nameof(formatters));
}
// Check if any content-type was explicitly set (for example, via ProducesAttribute
// or URL path extension mapping). If yes, then ignore content-negotiation and use this content-type.
if (contentTypes.Count == 1)
{
Logger.LogVerbose(
"Skipped content negotiation as content type '{ContentType}' is explicitly set for the response.",
contentTypes[0]);
return(SelectFormatterUsingAnyAcceptableContentType(formatterContext, formatters, contentTypes));
}
var sortedAcceptHeaderMediaTypes = GetSortedAcceptHeaderMediaTypes(formatterContext);
IOutputFormatter selectedFormatter = null;
if (contentTypes == null || contentTypes.Count == 0)
{
// Check if we have enough information to do content-negotiation, otherwise get the first formatter
// which can write the type. Let the formatter choose the Content-Type.
if (!sortedAcceptHeaderMediaTypes.Any())
{
Logger.LogVerbose("No information found on request to perform content negotiation.");
return(SelectFormatterNotUsingAcceptHeaders(formatterContext, formatters));
}
//
// Content-Negotiation starts from this point on.
//
// 1. Select based on sorted accept headers.
selectedFormatter = SelectFormatterUsingSortedAcceptHeaders(
formatterContext,
formatters,
sortedAcceptHeaderMediaTypes);
// 2. No formatter was found based on Accept header. Fallback to the first formatter which can write
// the type. Let the formatter choose the Content-Type.
if (selectedFormatter == null)
{
Logger.LogVerbose("Could not find an output formatter based on content negotiation.");
// Set this flag to indicate that content-negotiation has failed to let formatters decide
// if they want to write the response or not.
formatterContext.FailedContentNegotiation = true;
return(SelectFormatterNotUsingAcceptHeaders(formatterContext, formatters));
}
}
else
{
if (sortedAcceptHeaderMediaTypes.Any())
{
// Filter and remove accept headers which cannot support any of the user specified content types.
// That is, confirm this result supports a more specific media type than requested e.g. OK if
// "text/*" requested and result supports "text/plain".
var filteredAndSortedAcceptHeaders = sortedAcceptHeaderMediaTypes
.Where(acceptHeader => contentTypes.Any(contentType => contentType.IsSubsetOf(acceptHeader)));
selectedFormatter = SelectFormatterUsingSortedAcceptHeaders(
formatterContext,
formatters,
filteredAndSortedAcceptHeaders);
}
if (selectedFormatter == null)
{
// Either there were no acceptHeaders that were present OR
// There were no accept headers which matched OR
// There were acceptHeaders which matched but there was no formatter
// which supported any of them.
// In any of these cases, if the user has specified content types,
// do a last effort to find a formatter which can write any of the user specified content type.
selectedFormatter = SelectFormatterUsingAnyAcceptableContentType(
formatterContext,
formatters,
contentTypes);
}
}
return(selectedFormatter);
}
public abstract Task WriteAsync(OutputFormatterWriteContext context);
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context) => Task.CompletedTask;
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
return(context.HttpContext.Response.WriteAsync(this.ToHtml(context)));
}
/// <inheritdoc />
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (selectedEncoding == null)
{
throw new ArgumentNullException(nameof(selectedEncoding));
}
// Compat mode for derived options
_jsonOptions ??= context.HttpContext.RequestServices.GetRequiredService <IOptions <MvcNewtonsoftJsonOptions> >().Value;
var response = context.HttpContext.Response;
var responseStream = response.Body;
FileBufferingWriteStream?fileBufferingWriteStream = null;
if (!_mvcOptions.SuppressOutputFormatterBuffering)
{
fileBufferingWriteStream = new FileBufferingWriteStream(_jsonOptions.OutputFormatterMemoryBufferThreshold);
responseStream = fileBufferingWriteStream;
}
var value = context.Object;
if (value is not null && _asyncEnumerableReaderFactory.TryGetReader(value.GetType(), out var reader))
{
var logger = context.HttpContext.RequestServices.GetRequiredService <ILogger <NewtonsoftJsonOutputFormatter> >();
Log.BufferingAsyncEnumerable(logger, value);
try
{
value = await reader(value, context.HttpContext.RequestAborted);
}
catch (OperationCanceledException) when(context.HttpContext.RequestAborted.IsCancellationRequested)
{
}
if (context.HttpContext.RequestAborted.IsCancellationRequested)
{
return;
}
}
try
{
await using (var writer = context.WriterFactory(responseStream, selectedEncoding))
{
using var jsonWriter = CreateJsonWriter(writer);
var jsonSerializer = CreateJsonSerializer(context);
jsonSerializer.Serialize(jsonWriter, value);
}
if (fileBufferingWriteStream != null)
{
response.ContentLength = fileBufferingWriteStream.Length;
await fileBufferingWriteStream.DrainBufferAsync(response.BodyWriter);
}
}
finally
{
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DisposeAsync();
}
}
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
return(jsonOutputFormatter.WriteResponseBodyAsync(context, selectedEncoding));
}
public override void WriteResponseHeaders(OutputFormatterWriteContext context)
{
context.ContentType = "text/plain; charset=utf-8";
base.WriteResponseHeaders(context);
}
public static void NoFormatter(
this ILogger logger,
OutputFormatterWriteContext formatterContext)
{
_noFormatter(logger, Convert.ToString(formatterContext.ContentType), null);
}
// In the future, should convert to ODataEntry and use ODL to write out.
// Or use ODL to build a JObject and use Json.NET to write out.
public void WriteObject(Stream stream, OutputFormatterWriteContext context)
{
new ODataJsonSerializer(context).WriteJson(context.Object, stream);
}
public static IOutputFormatter SelectFormatter(this HttpContext context, OutputFormatterWriteContext writeContext)
{
var outputFormatterSelector = context.RequestServices.GetRequiredService <OutputFormatterSelector>();
return(outputFormatterSelector.SelectFormatter(writeContext, Array.Empty <IOutputFormatter>(), new MediaTypeCollection()));
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
// ReSharper disable once PossibleNullReferenceException
context.HttpContext.Response.WriteAsync(
JsonConvert.SerializeObject(context.Object, _jsonSerializerSettings));
/// <summary>
/// Writes the response body.
/// </summary>
/// <param name="context">The formatter context associated with the call.</param>
/// <param name="selectedEncoding">Encoding.</param>
/// <returns>
/// A task which can write the response body.
/// </returns>
/// <inheritdoc />
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
await base.WriteResponseBodyAsync(context, selectedEncoding);
}
/// <summary>
/// Executes the <see cref="ObjectResult"/>.
/// </summary>
/// <param name="context">The <see cref="ActionContext"/> for the current request.</param>
/// <param name="result">The <see cref="ObjectResult"/>.</param>
/// <returns>
/// A <see cref="Task"/> which will complete once the <see cref="ObjectResult"/> is written to the response.
/// </returns>
public virtual Task ExecuteAsync(ActionContext context, ObjectResult result)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
// If the user sets the content type both on the ObjectResult (example: by Produces) and Response object,
// then the one set on ObjectResult takes precedence over the Response object
if (result.ContentTypes == null || result.ContentTypes.Count == 0)
{
var responseContentType = context.HttpContext.Response.ContentType;
if (!string.IsNullOrEmpty(responseContentType))
{
if (result.ContentTypes == null)
{
result.ContentTypes = new MediaTypeCollection();
}
result.ContentTypes.Add(responseContentType);
}
}
ValidateContentTypes(result.ContentTypes);
var formatters = result.Formatters;
if (formatters == null || formatters.Count == 0)
{
formatters = OptionsFormatters;
// Complain about MvcOptions.OutputFormatters only if the result has an empty Formatters.
Debug.Assert(formatters != null, "MvcOptions.OutputFormatters cannot be null.");
if (formatters.Count == 0)
{
throw new InvalidOperationException(Resources.FormatOutputFormattersAreRequired(
typeof(MvcOptions).FullName,
nameof(MvcOptions.OutputFormatters),
typeof(IOutputFormatter).FullName));
}
}
var objectType = result.DeclaredType;
if (objectType == null || objectType == typeof(object))
{
objectType = result.Value?.GetType();
}
var formatterContext = new OutputFormatterWriteContext(
context.HttpContext,
WriterFactory,
objectType,
result.Value);
var selectedFormatter = SelectFormatter(formatterContext, result.ContentTypes, formatters);
if (selectedFormatter == null)
{
// No formatter supports this.
Logger.NoFormatter(formatterContext);
context.HttpContext.Response.StatusCode = StatusCodes.Status406NotAcceptable;
return(Task.CompletedTask);
}
Logger.FormatterSelected(selectedFormatter, formatterContext);
Logger.ObjectResultExecuting(context);
result.OnFormatting(context);
return(selectedFormatter.WriteAsync(formatterContext));
}
public async Task WriteAsync(OutputFormatterWriteContext context)
{
var response = context.HttpContext.Response;
await response.WriteAsync("barfoo");
}
public async override Task WriteResponseBodyAsync(OutputFormatterWriteContext context)
{
var response = context.HttpContext.Response;
Type type = context.Object.GetType();
Type itemType;
if (type.GetGenericArguments().Length > 0)
{
itemType = type.GetGenericArguments()[0];
}
else
{
itemType = type.GetElementType();
}
StringWriter _stringWriter = new StringWriter();
if (_options.UseSingleLineHeaderInCsv)
{
_stringWriter.WriteLine(
string.Join <string>(
_options.CsvDelimiter, itemType.GetProperties().Select(x => x.Name)
)
);
}
foreach (var obj in (IEnumerable <object>)context.Object)
{
var vals = obj.GetType().GetProperties().Select(
pi => new {
Value = pi.GetValue(obj, null),
Type = pi.PropertyType // ここ追加して
}
);
string _valueLine = string.Empty;
foreach (var val in vals)
{
if (val.Value != null)
{
var _val = val.Value.ToString();
//Check if the value contans a comma and place it in quotes if so
//if (val.Type == typeof(string) || _val.Contains(","))
// val.Type == typeof(string) を判定に追加
if (val.Type == typeof(string) || _val.Contains(","))
{
_val = string.Concat("\"", _val, "\"");
}
//Replace any \r or \n special characters from a new line with a space
if (_val.Contains("\r"))
{
_val = _val.Replace("\r", " ");
}
if (_val.Contains("\n"))
{
_val = _val.Replace("\n", " ");
}
_valueLine = string.Concat(_valueLine, _val, _options.CsvDelimiter);
}
else
{
_valueLine = string.Concat(_valueLine, string.Empty, _options.CsvDelimiter);
}
}
_stringWriter.WriteLine(_valueLine.TrimEnd(_options.CsvDelimiter.ToCharArray()));
}
// var streamWriter = new StreamWriter(response.Body); // ここを以下に
// UTF-8
// var streamWriter = new StreamWriter(response.Body, new UTF8Encoding(true));
// SHIFT-JIS
var streamWriter = new StreamWriter(
response.Body,
Encoding.GetEncoding("shift_jis",
new EncoderReplacementFallback("□"),
DecoderFallback.ReplacementFallback));
await streamWriter.WriteAsync(_stringWriter.ToString());
await streamWriter.FlushAsync();
}
public override Task WriteResponseBodyAsync
(OutputFormatterWriteContext context,
Encoding selectedEncoding)
{
throw new NotImplementedException();
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
var query = (IQueryable)context.Object;
var queryString = context.HttpContext.Request.QueryString;
var columns = queryString.Value.Contains("$select") ?
OutputFormatter.GetPropertiesFromSelect(queryString.Value, query.ElementType) :
OutputFormatter.GetProperties(query.ElementType);
var stream = new MemoryStream();
using (var document = SpreadsheetDocument.Create(stream, SpreadsheetDocumentType.Workbook))
{
var workbookPart = document.AddWorkbookPart();
workbookPart.Workbook = new Workbook();
var worksheetPart = workbookPart.AddNewPart <WorksheetPart>();
worksheetPart.Worksheet = new Worksheet();
var workbookStylesPart = workbookPart.AddNewPart <WorkbookStylesPart>();
GenerateWorkbookStylesPartContent(workbookStylesPart);
var sheets = workbookPart.Workbook.AppendChild(new Sheets());
var sheet = new Sheet()
{
Id = workbookPart.GetIdOfPart(worksheetPart), SheetId = 1, Name = "Sheet1"
};
sheets.Append(sheet);
workbookPart.Workbook.Save();
var sheetData = worksheetPart.Worksheet.AppendChild(new SheetData());
var headerRow = new Row();
foreach (var column in columns)
{
headerRow.Append(new Cell()
{
CellValue = new CellValue(column.Key),
DataType = new EnumValue <CellValues>(CellValues.String)
});
}
sheetData.AppendChild(headerRow);
foreach (var item in query)
{
var row = new Row();
foreach (var column in columns)
{
var value = OutputFormatter.GetValue(item, column.Key);
var stringValue = value.ToString();
var cell = new Cell();
var underlyingType = column.Value.IsGenericType &&
column.Value.GetGenericTypeDefinition() == typeof(Nullable <>) ?
Nullable.GetUnderlyingType(column.Value) : column.Value;
var typeCode = Type.GetTypeCode(underlyingType);
if (typeCode == TypeCode.DateTime)
{
if (stringValue != string.Empty)
{
cell.CellValue = new CellValue()
{
Text = DateTime.Parse(stringValue).ToOADate().ToString()
};
cell.StyleIndex = (UInt32Value)1U;
}
}
else if (typeCode == TypeCode.Boolean)
{
cell.CellValue = new CellValue(stringValue.ToLower());
cell.DataType = new EnumValue <CellValues>(CellValues.Boolean);
}
else if (IsNumeric(typeCode))
{
cell.CellValue = new CellValue(stringValue);
cell.DataType = new EnumValue <CellValues>(CellValues.Number);
}
else
{
cell.CellValue = new CellValue(stringValue);
cell.DataType = new EnumValue <CellValues>(CellValues.String);
}
row.Append(cell);
}
sheetData.AppendChild(row);
}
workbookPart.Workbook.Save();
}
if (stream?.Length > 0)
{
stream.Seek(0, SeekOrigin.Begin);
}
return(stream.CopyToAsync(context.HttpContext.Response.Body));
}
public void WriteResponse_GetMediaTypeWithCharsetReturnsSameString_IfCharsetEqualToEncoding()
{
// Arrange
var formatter = new TestOutputFormatter();
var contentType = "application/json; charset=utf-16";
var formatterContext = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = new StringSegment(contentType),
};
formatter.SupportedMediaTypes.Add("application/json");
formatter.SupportedEncodings.Add(Encoding.Unicode);
// Act
formatter.WriteAsync(formatterContext);
// Assert
Assert.Same(contentType, formatterContext.ContentType.Buffer);
}
public async override Task WriteResponseBodyAsync(OutputFormatterWriteContext context)
{
var response = context.HttpContext.Response;
Type type = context.Object.GetType();
Type itemType;
if (type.GetGenericArguments().Length > 0)
{
itemType = type.GetGenericArguments()[0];
}
else
{
itemType = type.GetElementType();
}
var streamWriter = new StreamWriter(response.Body, Encoding.GetEncoding(_options.Encoding));
if (_options.UseSingleLineHeaderInCsv)
{
await streamWriter.WriteLineAsync(
string.Join(
_options.CsvDelimiter, itemType.GetProperties().Select(x => x.GetCustomAttribute <DisplayAttribute>(false)?.Name ?? x.Name)
)
);
}
foreach (var obj in (IEnumerable <object>)context.Object)
{
var vals = obj.GetType().GetProperties().Select(
pi => new
{
Value = pi.GetValue(obj, null)
}
);
string valueLine = string.Empty;
foreach (var val in vals)
{
if (val.Value != null)
{
var _val = val.Value.ToString();
//Escape quotas
_val = _val.Replace("\"", "\"\"");
//Check if the value contans a delimiter and place it in quotes if so
if (_val.Contains(_options.CsvDelimiter))
{
_val = string.Concat("\"", _val, "\"");
}
//Replace any \r or \n special characters from a new line with a space
if (_val.Contains("\r"))
{
_val = _val.Replace("\r", " ");
}
if (_val.Contains("\n"))
{
_val = _val.Replace("\n", " ");
}
valueLine = string.Concat(valueLine, _val, _options.CsvDelimiter);
}
else
{
valueLine = string.Concat(valueLine, string.Empty, _options.CsvDelimiter);
}
}
await streamWriter.WriteLineAsync(valueLine.TrimEnd(_options.CsvDelimiter.ToCharArray()));
}
await streamWriter.FlushAsync();
}
public async Task WriteAsync_ReturnsNotAcceptable_IfSelectCharacterEncodingReturnsNull()
{
// Arrange
var formatter = new OverrideEncodingFormatter(encoding: null);
var testContentType = new StringSegment("text/json");
formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/json"));
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = testContentType,
};
// Act
await formatter.WriteAsync(context);
// Assert
Assert.Equal(StatusCodes.Status406NotAcceptable, context.HttpContext.Response.StatusCode);
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
return(Task.FromResult(0));
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
return Task.FromResult(true);
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context)
{
return(Task.FromResult(0));
}
public void WriteResponse_OverridesCharset_IfDifferentFromContentTypeCharset(
string contentType,
string expectedContentType)
{
// Arrange
var formatter = new OverrideEncodingFormatter(Encoding.UTF32);
var formatterContext = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = new StringSegment(contentType),
};
// Act
formatter.WriteAsync(formatterContext);
// Assert
Assert.Equal(new StringSegment(expectedContentType), formatterContext.ContentType);
}
public Task WriteAsync(OutputFormatterWriteContext context)
{
return(Task.FromResult(0));
}
public Task WriteAsync(OutputFormatterWriteContext context)
{
return Task.FromResult(true);
}
private T GetService <T>(OutputFormatterWriteContext context)
{
return(context.HttpContext.RequestServices.GetService <T>());
}
public async override Task WriteResponseBodyAsync(OutputFormatterWriteContext context)
{
var response = context.HttpContext.Response;
Type type = context.Object.GetType();
Type itemType;
if (type.GetGenericArguments().Length > 0)
{
itemType = type.GetGenericArguments()[0];
}
else
{
itemType = type.GetElementType();
}
var streamWriter = new StreamWriter(response.Body, Encoding.GetEncoding(_options.Encoding));
if (_options.IncludeExcelDelimiterHeader)
{
await streamWriter.WriteLineAsync($"sep ={_options.CsvDelimiter}");
}
if (_options.UseSingleLineHeaderInCsv)
{
var values = useJsonAttributes
? itemType.GetProperties().Where(pi => !pi.GetCustomAttributes <JsonIgnoreAttribute>(false).Any()) // Only get the properties that do not define JsonIgnore
.Select(pi => new
{
Order = pi.GetCustomAttribute <JsonPropertyAttribute>(false)?.Order ?? 0,
Prop = pi
}).OrderBy(d => d.Order).Select(d => GetDisplayNameFromNewtonsoftJsonAnnotations(d.Prop))
: itemType.GetProperties().Select(pi => pi.GetCustomAttribute <DisplayAttribute>(false)?.Name ?? pi.Name);
await streamWriter.WriteLineAsync(string.Join(_options.CsvDelimiter, values));
}
foreach (var obj in (IEnumerable <object>)context.Object)
{
var vals = useJsonAttributes
? obj.GetType().GetProperties()
.Where(pi => !pi.GetCustomAttributes <JsonIgnoreAttribute>().Any())
.Select(pi => new
{
Order = pi.GetCustomAttribute <JsonPropertyAttribute>(false)?.Order ?? 0,
Value = pi.GetValue(obj, null)
}).OrderBy(d => d.Order).Select(d => new { d.Value })
: obj.GetType().GetProperties().Select(
pi => new
{
Value = pi.GetValue(obj, null)
});
string valueLine = string.Empty;
foreach (var val in vals)
{
if (val.Value != null)
{
var _val = val.Value.ToString();
//Escape quotas
_val = _val.Replace("\"", "\"\"");
//Check if the value contans a delimiter and place it in quotes if so
if (_val.Contains(_options.CsvDelimiter))
{
_val = string.Concat("\"", _val, "\"");
}
//Replace any \r or \n special characters from a new line with a space
if (_val.Contains("\r"))
{
_val = _val.Replace("\r", " ");
}
if (_val.Contains("\n"))
{
_val = _val.Replace("\n", " ");
}
valueLine = string.Concat(valueLine, _val, _options.CsvDelimiter);
}
else
{
valueLine = string.Concat(valueLine, string.Empty, _options.CsvDelimiter);
}
}
await streamWriter.WriteLineAsync(valueLine.Remove(valueLine.Length - _options.CsvDelimiter.Length));
}
await streamWriter.FlushAsync();
}
public override Encoding SelectCharacterEncoding(OutputFormatterWriteContext context)
{
return(_encoding);
}
