/// <summary>
/// Determine the <see cref="ODataFormat"/> to use for the given <paramref name="contentTypeName"/>. If no supported content type
/// is found an exception is thrown.
/// </summary>
/// <param name="contentTypeName">The name of the content type to be checked.</param>
/// <param name="supportedPayloadKinds">All possible kinds of payload that can be read with this content type.</param>
/// <param name="mediaTypeResolver">The media type resolver to use when interpreting the content type.</param>
/// <param name="mediaType">The media type parsed from the <paramref name="contentTypeName"/>.</param>
/// <param name="encoding">The encoding from the content type or the default encoding for the <paramref name="mediaType" />.</param>
/// <param name="selectedPayloadKind">
/// The payload kind that was selected form the list of <paramref name="supportedPayloadKinds"/> for the
/// specified <paramref name="contentTypeName"/>.
/// </param>
/// <returns>The <see cref="ODataFormat"/> for the <paramref name="contentTypeName"/>.</returns>
internal static ODataFormat GetFormatFromContentType(string contentTypeName, ODataPayloadKind[] supportedPayloadKinds, ODataMediaTypeResolver mediaTypeResolver, out ODataMediaType mediaType, out Encoding encoding, out ODataPayloadKind selectedPayloadKind)
{
Debug.Assert(!supportedPayloadKinds.Contains(ODataPayloadKind.Unsupported), "!supportedPayloadKinds.Contains(ODataPayloadKind.Unsupported)");
string charset;
mediaType = ParseContentType(contentTypeName, out charset);
IList <ODataMediaTypeFormat> supportedMediaTypes = null;
for (int i = 0; i < supportedPayloadKinds.Length; ++i)
{
// get the supported and default media types for the current payload kind
ODataPayloadKind supportedPayloadKind = supportedPayloadKinds[i];
supportedMediaTypes = mediaTypeResolver.GetMediaTypeFormats(supportedPayloadKind).ToList();
// match the specified media types against the supported/default ones
// and get the format
var cacheKey = new MatchInfoCacheKey(mediaTypeResolver, supportedPayloadKind, contentTypeName);
MediaTypeMatchInfo matchInfo;
if (!MatchInfoCache.TryGetValue(cacheKey, out matchInfo))
{
matchInfo = MatchMediaTypes(supportedMediaTypes.Select(smt => smt.MediaType), new[] { mediaType });
MatchInfoCache.Add(cacheKey, matchInfo);
}
if (matchInfo != null)
{
Debug.Assert(matchInfo.TargetTypeIndex == 0, "Invalid target type index detected.");
selectedPayloadKind = supportedPayloadKind;
encoding = GetEncoding(charset, selectedPayloadKind, mediaType, /*useDefaultEncoding*/ false);
return(supportedMediaTypes[matchInfo.SourceTypeIndex].Format);
}
}
// We're calling the ToArray here since not all platforms support the string.Join which takes IEnumerable.
string supportedTypesAsString = String.Join(", ", supportedPayloadKinds.SelectMany(pk => mediaTypeResolver.GetMediaTypeFormats(pk).Select(mt => mt.MediaType.ToText())).ToArray());
throw new ODataContentTypeException(Strings.MediaTypeUtils_CannotDetermineFormatFromContentType(supportedTypesAsString, contentTypeName));
}
/// <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>
/// Given the Accept and the Accept-Charset headers of the request message computes the media type, encoding and <see cref="ODataFormat"/>
/// to be used for the response message.
/// </summary>
/// <param name="settings">The message writer settings to use for serializing the response payload.</param>
/// <param name="payloadKind">The kind of payload to be serialized as part of the response message.</param>
/// <param name="mediaTypeResolver">The media type resolver to use when interpreting the content type.</param>
/// <param name="mediaType">The media type to be used in the response message.</param>
/// <param name="encoding">The encoding to be used in the response message.</param>
/// <returns>The <see cref="ODataFormat"/> used when serializing the response.</returns>
internal static ODataFormat GetContentTypeFromSettings(
ODataMessageWriterSettings settings,
ODataPayloadKind payloadKind,
ODataMediaTypeResolver mediaTypeResolver,
out ODataMediaType mediaType,
out Encoding encoding)
{
Debug.Assert(settings != null, "settings != null");
// compute format, media type and encoding
ODataFormat format;
// get the supported and default media types for the specified payload kind
IList <ODataMediaTypeFormat> supportedMediaTypes = mediaTypeResolver.GetMediaTypeFormats(payloadKind).ToList();
if (supportedMediaTypes == null || supportedMediaTypes.Count == 0)
{
throw new ODataContentTypeException(Strings.MediaTypeUtils_DidNotFindMatchingMediaType(null, settings.AcceptableMediaTypes));
}
if (settings.UseFormat == true)
{
Debug.Assert(settings.AcceptableMediaTypes == null, "settings.AcceptableMediaTypes == null");
Debug.Assert(settings.AcceptableCharsets == null, "settings.AcceptableCharsets == null");
mediaType = GetDefaultMediaType(supportedMediaTypes, settings.Format, out format);
// NOTE the default media types don't have any parameters (in particular no 'charset' parameters)
encoding = mediaType.SelectEncoding();
}
else
{
// parse the accept header into its parts
IList <KeyValuePair <ODataMediaType, string> > specifiedTypes = HttpUtils.MediaTypesFromString(settings.AcceptableMediaTypes);
// Starting in V3 we replace all occurrences of application/json with application/json;odata.metadata=minimal
// before handing the acceptable media types to the conneg code. This is necessary because for an accept
// header 'application/json, we want to the result to be 'application/json;odata.metadata=minimal'
ConvertApplicationJsonInAcceptableMediaTypes(specifiedTypes);
ODataMediaTypeFormat selectedMediaTypeWithFormat;
string specifiedCharset = null;
if (specifiedTypes == null || specifiedTypes.Count == 0)
{
selectedMediaTypeWithFormat = supportedMediaTypes[0];
}
else
{
// match the specified media types against the supported/default ones and get the format
MediaTypeMatchInfo matchInfo = MatchMediaTypes(specifiedTypes.Select(kvp => kvp.Key), supportedMediaTypes.Select(smt => smt.MediaType).ToArray());
if (matchInfo == null)
{
// We're calling the ToArray here since not all platforms support the string.Join which takes IEnumerable.
string supportedTypesAsString = String.Join(", ", supportedMediaTypes.Select(mt => mt.MediaType.ToText()).ToArray());
throw new ODataContentTypeException(Strings.MediaTypeUtils_DidNotFindMatchingMediaType(supportedTypesAsString, settings.AcceptableMediaTypes));
}
selectedMediaTypeWithFormat = supportedMediaTypes[matchInfo.TargetTypeIndex];
specifiedCharset = specifiedTypes[matchInfo.SourceTypeIndex].Value;
}
format = selectedMediaTypeWithFormat.Format;
mediaType = selectedMediaTypeWithFormat.MediaType;
// If a charset was specified with the accept header, consider it for the encoding
string acceptableCharsets = settings.AcceptableCharsets;
if (specifiedCharset != null)
{
acceptableCharsets = acceptableCharsets == null ? specifiedCharset : specifiedCharset + "," + acceptableCharsets;
}
encoding = GetEncoding(acceptableCharsets, payloadKind, mediaType, /*useDefaultEncoding*/ true);
}
return(format);
}
