// Methods
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
#region Contracts
if (context == null)
{
throw new ArgumentException(nameof(context));
}
#endregion
// Void
if (context.ObjectType == typeof(void) || context.ObjectType == typeof(Task))
{
return(true);
}
// Null
if (context.Object == null)
{
return(true);
}
// Return
return(false);
}
private IOutputFormatter SelectFormatterNotUsingContentType(
OutputFormatterCanWriteContext formatterContext,
IList <IOutputFormatter> formatters)
{
if (formatterContext == null)
{
throw new ArgumentNullException(nameof(formatterContext));
}
if (formatters == null)
{
throw new ArgumentNullException(nameof(formatters));
}
_logger.SelectFirstCanWriteFormatter();
foreach (var formatter in formatters)
{
formatterContext.ContentType = new StringSegment();
formatterContext.ContentTypeIsServerDefined = false;
if (formatter.CanWriteResult(formatterContext))
{
return(formatter);
}
}
return(null);
}
public override bool CanWriteResult([NotNull] OutputFormatterCanWriteContext context)
{
//var type = context.Object.GetType();
//var request = context.Request;
//if (request != null)
//{
// IEdmModel model = request.ODataProperties().Model;
// if (model != null)
// {
// ODataPayloadKind? payloadKind = null;
// Type elementType;
// if (typeof(IEdmObject).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()) ||
// (type.IsCollection(out elementType) && typeof(IEdmObject).GetTypeInfo().IsAssignableFrom(elementType.GetTypeInfo())))
// {
// payloadKind = GetEdmObjectPayloadKind(type, request);
// }
// else
// {
// payloadKind = GetClrObjectResponsePayloadKind(type, model, request);
// }
// return payloadKind == null ? false : _payloadKinds.Contains(payloadKind.Value);
// }
//}
//return false;
return(base.CanWriteResult(context));
}
/// <inheritdoc />
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (!base.CanWriteResult(context))
{
return(false);
}
var httpContext = context.HttpContext;
var viewEngine = httpContext.RequestServices.GetRequiredService <IRazorViewEngine>();
httpContext.Items.TryGetValue("ModelState", out var modelState);
httpContext.Items.TryGetValue("RouteData", out var routeData);
httpContext.Items.TryGetValue("ActionDescriptor", out var actionDescriptor);
var actionContext = new ActionContext(
httpContext,
routeData as RouteData ?? new RouteData(),
actionDescriptor as ActionDescriptor ?? new ActionDescriptor(),
modelState as ModelStateDictionary ?? new ModelStateDictionary());
if (!actionContext.RouteData.Values.TryGetValue("view", out var viewObject) || viewObject is not string viewName)
{
viewName = actionContext.RouteData.Values["action"]?.ToString() ?? string.Empty;
}
var result = viewEngine.FindView(actionContext, viewName, false);
return(result.Success);
}
private IOutputFormatter SelectFormatterUsingSortedAcceptHeadersAndContentTypes(
OutputFormatterCanWriteContext formatterContext,
IList <IOutputFormatter> formatters,
IList <MediaTypeSegmentWithQuality> sortedAcceptableContentTypes,
MediaTypeCollection possibleOutputContentTypes)
{
for (var i = 0; i < sortedAcceptableContentTypes.Count; i++)
{
var acceptableContentType = new MediaType(sortedAcceptableContentTypes[i].MediaType);
for (var j = 0; j < possibleOutputContentTypes.Count; j++)
{
var candidateContentType = new MediaType(possibleOutputContentTypes[j]);
if (candidateContentType.IsSubsetOf(acceptableContentType))
{
for (var k = 0; k < formatters.Count; k++)
{
var formatter = formatters[k];
formatterContext.ContentType = new StringSegment(possibleOutputContentTypes[j]);
formatterContext.ContentTypeIsServerDefined = true;
if (formatter.CanWriteResult(formatterContext))
{
return(formatter);
}
}
}
}
}
return(null);
}
internal static bool IsRawBinaryRequest(this OutputFormatterCanWriteContext context, Type type)
{
if (type == typeof(Binary) || (type == typeof(FhirResponse)) && ((FhirResponse)context.Object).Resource is Binary)
{
HttpRequest request = context.HttpContext.Request;
bool isFhirMediaType = false;
if (request.Method == "GET")
{
isFhirMediaType = request.IsAcceptHeaderFhirMediaType();
}
else if (request.Method == "POST" || request.Method == "PUT")
{
isFhirMediaType = HttpRequestExtensions.IsContentTypeHeaderFhirMediaType(request.ContentType);
}
var ub = new UriBuilder(request.GetRequestUri());
// TODO: KM: Path matching is not optimal should be replaced by a more solid solution.
return(ub.Path.Contains("Binary") &&
!isFhirMediaType);
}
else
{
return(false);
}
}
private void EnsureSerializer(OutputFormatterCanWriteContext context)
{
if (context.HttpContext.Items[Constants.ContextKeys.JsonMultiCase] is ITextTransform transform)
{
if (!_resolvers.TryGetValue(transform, out var resolver))
{
resolver = new JsonContractResolver(transform, JsonProcessingDirection.Output);
_resolvers.Add(transform, resolver);
}
_serializer.ContractResolver = resolver;
}
if (context.HttpContext.Items[Constants.ContextKeys.JsonPrettyPrint] is bool prettyPrint && !prettyPrint)
{
_serializer.Apply(s => s.Formatting = Formatting.None);
}
if (context.HttpContext.Items[Constants.ContextKeys.JsonTrim] is bool trim && trim)
{
_serializer.Apply(s =>
{
s.NullValueHandling = NullValueHandling.Ignore;
s.DefaultValueHandling = DefaultValueHandling.Ignore;
});
}
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
// This test formatter matches if and only if the content type is specified
// as "server defined". This lets tests identify what value the ObjectResultExecutor
// passed for that flag.
return(context.ContentTypeIsServerDefined);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(true);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.ContentType == null || context.ContentType.ToString() == ContentType);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.ObjectType == typeof(imsx_POXEnvelopeType));
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
var type = context.HttpContext.Request.Headers["accept"];
var ret = SupportedMediaTypes.Contains(type);
ret &= base.CanWriteResult(context);
return(ret);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
var name = context.HttpContext.GetFormatterName();
bool nameStatus = name == _formatterName;
bool contentTypeStatus = _types.Sum(x => x.Matches(GetContentType(context)).Count) > 0;
return(nameStatus && contentTypeStatus);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
var contentTypeString = context.ContentType.ToString();
return string.IsNullOrEmpty(contentTypeString) || contentTypeString == "application/json";
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(_jsonOutputFormatter.CanWriteResult(context));
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context.ObjectType == typeof(IEnumerable <string>))
{
return(true);
}
return(base.CanWriteResult(context));
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
var httpContext = ((OutputFormatterWriteContext)context).HttpContext;
var allowedContentTypes = new string[] { "text/ascii", "image/png" };
return
(httpContext.Request.Path == "/ping" &&
allowedContentTypes.Contains(httpContext.Request.ContentType));
}
public static void NoFormatter(
this ILogger logger,
OutputFormatterCanWriteContext formatterContext)
{
if (logger.IsEnabled(LogLevel.Warning))
{
_noFormatter(logger, Convert.ToString(formatterContext.ContentType), null);
}
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context.Object is T)
{
return(true);
}
return(false);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context.ObjectType == typeof(void) || context.ObjectType == typeof(Task))
{
return(true);
}
return(context.Object == null);
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (!base.CanWriteResult(context))
{
return(false);
}
return((context.Object as ExecutionResult)?.ContainsRequiredEntityType(_entityType) ?? false);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.HttpContext.IsJsonApiRequest());
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context.ContentType.HasValue)
{
return(context.ContentType.Value == ContentType);
}
context.ContentType = new StringSegment(ContentType);
return(true);
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.HttpContext.Request.ContentType == CONTENT_TYPE);
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return _jsonMediaTypeFormatter.CanWriteResult(context);
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context.Object is HypermediaQueryLocation)
{
return(true);
}
return(false);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (typeof(ResourceResult).GetTypeInfo().IsAssignableFrom(context.ObjectType.GetTypeInfo()))
{
return(true);
}
return(false);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
var response = context.HttpContext.Response;
var contentType = GetNonEmptyString(context.ContentType.Value, response.ContentType, JSONUTF8ContentType);
var mediaType = new MediaType(contentType);
return(mediaType.SubType == "json");
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
// if (context == null)
// throw new ArgumentNullException(nameof(context));
// if (context.Object is PushStreamResult)
// return true;
return(false);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
if (context.Object is PushStreamContent)
return true;
return false;
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context.Object != null && context.HttpContext.Request.ContentType.Equals(Protobuf.MediaType))
{
// Check whether the given object is a proto-generated object
return(context.ObjectType.GetInterfaces()
.Where(i => i.IsGenericTypeDefinition && i == typeof(IMessage <>)) != null);
}
return(false);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
var response = context.HttpContext.Response;
var contentType = GetNonEmptyString(context.ContentType.Value, response.ContentType, JSONContentType);
var mediaType = new MediaType(contentType);
return(mediaType.SubType.Equals("json", StringComparison.InvariantCultureIgnoreCase));
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
// this override is necessary to stop StringOutputFormatter from injecting UTF-8
// and text/plain media type arbitrarily
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return context.ObjectType == typeof(string) || context.Object is string;
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (base.CanWriteResult(context))
{
var actionReturnString = context.Object as string;
if (actionReturnString != null)
{
return true;
}
}
return false;
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
bool result = false;
if (this.CanWriteType(context.ObjectType))
{
if ((context.ContentType != null) && (context.ContentType.StartsWith("application", StringComparison.InvariantCultureIgnoreCase)) && context.ContentType.EndsWith("+xml", StringComparison.InvariantCultureIgnoreCase))
result = true;
else
result = base.CanWriteResult(context);
}
return result;
}
/// <inheritdoc />
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
// ignore the contentType and just look at the content.
// This formatter will be selected if the content is null.
// We check for Task as a user can directly create an ObjectContentResult with the unwrapped type.
if (context.ObjectType == typeof(void) || context.ObjectType == typeof(Task))
{
return true;
}
return TreatNullValueAsNoContent && context.Object == null;
}
/// <inheritdoc />
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// Ignore the passed in content type, if the object is a Stream.
if (context.Object is Stream)
{
return true;
}
return false;
}
/// <inheritdoc />
public virtual bool CanWriteResult(OutputFormatterCanWriteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (SupportedMediaTypes.Count == 0)
{
var message = Resources.FormatFormatter_NoMediaTypes(
GetType().FullName,
nameof(SupportedMediaTypes));
throw new InvalidOperationException(message);
}
if (!CanWriteType(context.ObjectType))
{
return false;
}
if (!context.ContentType.HasValue)
{
// If the desired content type is set to null, then the current formatter can write anything
// it wants.
context.ContentType = new StringSegment(SupportedMediaTypes[0]);
return true;
}
else
{
// Confirm this formatter supports a more specific media type than requested e.g. OK if "text/*"
// requested and formatter supports "text/plain". contentType is typically what we got in an Accept
// header.
var parsedContentType = new MediaType(context.ContentType);
for (var i = 0; i < SupportedMediaTypes.Count; i++)
{
var supportedMediaType = new MediaType(SupportedMediaTypes[i]);
if (supportedMediaType.IsSubsetOf(parsedContentType))
{
context.ContentType = new StringSegment(SupportedMediaTypes[i]);
return true;
}
}
}
return false;
}
public virtual bool CanWriteResult(OutputFormatterCanWriteContext context)
{
return false;
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
return context.Object is HttpResponseMessage;
}
public bool CanWriteResult(OutputFormatterCanWriteContext context) {
return context.ObjectType == typeof(HALResponse);
}
public bool CanWriteResult(OutputFormatterCanWriteContext context)
{
return true;
}
