/// <summary>Gets the named encoding if specified.</summary>
/// <param name="name">Name (possibly null or empty).</param>
/// <returns>
/// The named encoding if specified; the encoding for HTTP missing
/// charset specification otherwise.
/// </returns>
/// <remarks>
/// See http://tools.ietf.org/html/rfc2616#section-3.4.1 for details.
/// </remarks>
private static Encoding EncodingFromName(string name)
{
Debug.Assert(!string.IsNullOrEmpty(name), "!string.IsNullOrEmpty(name)");
Debug.Assert(name.Trim() == name, "Should already be trimmed.");
Encoding result = HttpUtils.GetEncodingFromCharsetName(name);
if (result == null)
{
throw new ODataException(Strings.MediaType_EncodingNotSupported(name));
}
return(result);
}
/// <summary>
/// Gets all payload kinds and their corresponding formats that match the specified content type header.
/// </summary>
/// <param name="contentTypeHeader">The content type header to get the payload kinds for.</param>
/// <param name="mediaTypeResolver">The media type resolver to use when interpreting the content type.</param>
/// <param name="contentType">The parsed content type as <see cref="ODataMediaType"/>.</param>
/// <param name="encoding">The encoding from the content type or the default encoding from <see cref="ODataMediaType" />.</param>
/// <returns>The list of payload kinds and formats supported for the specified <paramref name="contentTypeHeader"/>.</returns>
internal static IList <ODataPayloadKindDetectionResult> GetPayloadKindsForContentType(string contentTypeHeader, ODataMediaTypeResolver mediaTypeResolver, out ODataMediaType contentType, out Encoding encoding)
{
Debug.Assert(!String.IsNullOrEmpty(contentTypeHeader), "Content-Type header must not be null or empty.");
string charset;
encoding = null;
contentType = ParseContentType(contentTypeHeader, out charset);
ODataMediaType[] targetTypes = new ODataMediaType[] { contentType };
List <ODataPayloadKindDetectionResult> payloadKinds = new List <ODataPayloadKindDetectionResult>();
IList <ODataMediaTypeFormat> mediaTypesForKind = null;
for (int i = 0; i < allSupportedPayloadKinds.Length; ++i)
{
// get the supported and default media types for the current payload kind
ODataPayloadKind payloadKind = allSupportedPayloadKinds[i];
mediaTypesForKind = mediaTypeResolver.GetMediaTypeFormats(payloadKind).ToList();
// match the specified media types against the supported/default ones
// and get the format
MediaTypeMatchInfo matchInfo = MatchMediaTypes(mediaTypesForKind.Select(smt => smt.MediaType), targetTypes);
if (matchInfo != null)
{
Debug.Assert(matchInfo.TargetTypeIndex == 0, "Invalid target type index detected.");
payloadKinds.Add(new ODataPayloadKindDetectionResult(payloadKind, mediaTypesForKind[matchInfo.SourceTypeIndex].Format));
}
}
if (!String.IsNullOrEmpty(charset))
{
encoding = HttpUtils.GetEncodingFromCharsetName(charset);
}
return(payloadKinds);
}
/// <summary>
/// Append default values required by OData to specified HTTP header.
///
/// When header name is ODataConstants.ContentTypeHeader, if header value is application/json
/// append the following default values for 4.0:
/// odata.metadata=minimal
/// odata.streaming=true
/// IEEE754Compatible=false
/// append the following default values for 4.01:
/// metadata=minimal
/// streaming=true
/// IEEE754Compatible=false
/// </summary>
/// <param name="headerName">The name of the header to append default values.</param>
/// <param name="headerValue">The original header value string.</param>
/// <param name="version">The ODataVersion for which to create the default header value</param>
/// <returns>The header value string with appended default values.</returns>
public static string AppendDefaultHeaderValue(string headerName, string headerValue, ODataVersion version)
{
if (string.CompareOrdinal(headerName, ODataConstants.ContentTypeHeader) != 0)
{
return(headerValue);
}
if (headerValue == null)
{
return(null);
}
var mediaTypeList = HttpUtils.MediaTypesFromString(headerValue);
var mediaType = mediaTypeList.Single().Key;
var encoding = HttpUtils.GetEncodingFromCharsetName(mediaTypeList.Single().Value);
if (string.CompareOrdinal(mediaType.FullTypeName, MimeConstants.MimeApplicationJson) != 0)
{
return(headerValue);
}
var extendedParameters = new List <KeyValuePair <string, string> >();
var extendedMediaType = new ODataMediaType(mediaType.Type, mediaType.SubType, extendedParameters);
var hasMetadata = false;
var hasStreaming = false;
var hasIeee754Compatible = false;
if (mediaType.Parameters != null)
{
foreach (var parameter in mediaType.Parameters)
{
extendedParameters.Add(parameter);
if (HttpUtils.IsMetadataParameter(parameter.Key))
{
hasMetadata = true;
}
if (HttpUtils.IsStreamingParameter(parameter.Key))
{
hasStreaming = true;
}
if (string.Compare(parameter.Key, MimeConstants.MimeIeee754CompatibleParameterName, StringComparison.OrdinalIgnoreCase) == 0)
{
hasIeee754Compatible = true;
}
}
}
if (!hasMetadata)
{
extendedParameters.Add(new KeyValuePair <string, string>(
version < ODataVersion.V401 ? MimeConstants.MimeMetadataParameterName : MimeConstants.MimeShortMetadataParameterName,
MimeConstants.MimeMetadataParameterValueMinimal));
}
if (!hasStreaming)
{
extendedParameters.Add(new KeyValuePair <string, string>(
version < ODataVersion.V401 ? MimeConstants.MimeStreamingParameterName : MimeConstants.MimeShortStreamingParameterName,
MimeConstants.MimeParameterValueTrue));
}
if (!hasIeee754Compatible)
{
extendedParameters.Add(new KeyValuePair <string, string>(
MimeConstants.MimeIeee754CompatibleParameterName,
MimeConstants.MimeParameterValueFalse));
}
return(extendedMediaType.ToText(encoding));
}
