/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format for this output context.</param>
/// <param name="messageStream">The message stream to write the payload to.</param>
/// <param name="encoding">The encoding to use for the payload.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="synchronous">true if the output should be written synchronously; false if it should be written asynchronously.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
private ODataMetadataOutputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
Debug.Assert(synchronous, "Metadata output context is only supported in synchronous operations.");
try
{
this.messageOutputStream = messageStream;
this.xmlWriter = ODataAtomWriterUtils.CreateXmlWriter(messageStream, messageWriterSettings, encoding);
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the output context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format for this output context.</param>
/// <param name="messageStream">The message stream to write the payload to.</param>
/// <param name="encoding">The encoding to use for the payload.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="synchronous">true if the output should be written synchronously; false if it should be written asynchronously.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
private ODataRawOutputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
this.messageOutputStream = messageStream;
this.encoding = encoding;
if (synchronous)
{
this.outputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
this.outputStream = this.asynchronousOutputStream;
}
}
catch
{
messageStream.Dispose();
throw;
}
}
public void ReadJsonLight()
{
// Arrange
var deserializer = new ODataEntityReferenceLinkDeserializer();
MockODataRequestMessage requestMessage = new MockODataRequestMessage();
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings();
writerSettings.SetContentType(ODataFormat.Json);
IEdmModel model = CreateModel();
ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, writerSettings, model);
messageWriter.WriteEntityReferenceLink(new ODataEntityReferenceLink { Url = new Uri("http://localhost/samplelink") });
ODataMessageReader messageReader = new ODataMessageReader(new MockODataRequestMessage(requestMessage),
new ODataMessageReaderSettings(), model);
IEdmNavigationProperty navigationProperty = GetNavigationProperty(model);
ODataDeserializerContext context = new ODataDeserializerContext
{
Request = new HttpRequestMessage(),
Path = new ODataPath(new NavigationPathSegment(navigationProperty))
};
// Act
Uri uri = deserializer.Read(messageReader, context) as Uri;
// Assert
Assert.NotNull(uri);
Assert.Equal("http://localhost/samplelink", uri.AbsoluteUri);
}
private ODataJsonOutputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
Stream asynchronousOutputStream;
this.messageOutputStream = messageStream;
if (synchronous)
{
asynchronousOutputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
asynchronousOutputStream = this.asynchronousOutputStream;
}
this.textWriter = new StreamWriter(asynchronousOutputStream, encoding);
this.jsonWriter = new Microsoft.Data.OData.Json.JsonWriter(this.textWriter, messageWriterSettings.Indent);
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
private ODataAtomOutputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
Stream asynchronousOutputStream;
this.messageOutputStream = messageStream;
if (synchronous)
{
asynchronousOutputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
asynchronousOutputStream = this.asynchronousOutputStream;
}
this.xmlRootWriter = ODataAtomWriterUtils.CreateXmlWriter(asynchronousOutputStream, messageWriterSettings, encoding);
this.xmlWriter = this.xmlRootWriter;
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataMediaTypeFormatter"/> class.
/// </summary>
/// <param name="deserializerProvider">The <see cref="ODataDeserializerProvider"/> to use.</param>
/// <param name="serializerProvider">The <see cref="ODataSerializerProvider"/> to use.</param>
/// <param name="payloadKinds">The kind of payloads this formatter supports.</param>
public ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider, ODataSerializerProvider serializerProvider,
IEnumerable<ODataPayloadKind> payloadKinds)
{
if (deserializerProvider == null)
{
throw Error.ArgumentNull("deserializerProvider");
}
if (serializerProvider == null)
{
throw Error.ArgumentNull("serializerProvider");
}
if (payloadKinds == null)
{
throw Error.ArgumentNull("payloadKinds");
}
_deserializerProvider = deserializerProvider;
_serializerProvider = serializerProvider;
_payloadKinds = payloadKinds;
// Maxing out the received message size as we depend on the hosting layer to enforce this limit.
MessageWriterSettings = new ODataMessageWriterSettings
{
Indent = true,
DisableMessageStreamDisposal = true,
MessageQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue }
};
MessageReaderSettings = new ODataMessageReaderSettings
{
DisableMessageStreamDisposal = true,
MessageQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue },
};
_version = DefaultODataVersion;
}
public void ProcessRequest(HttpContext context, Uri serviceBaseUri)
{
var sparqlGenerator = new SparqlGenerator(_config.Map, _config.DefaultLanguageCode, _config.MaxPageSize);
var messageWriterSettings = new ODataMessageWriterSettings(_config.BaseODataWriterSettings)
{
BaseUri = serviceBaseUri
};
if (context.Request.AcceptTypes != null)
{
messageWriterSettings.SetContentType(String.Join(",", context.Request.AcceptTypes),
context.Request.Headers["Accept-Charset"]);
}
var requestMessage = new HttpDataRequestMessage(context.Request);
ODataVersion effectiveVersion = GetEffectiveODataVersion(requestMessage);
messageWriterSettings.Version = effectiveVersion;
var metadataUri = new Uri(serviceBaseUri, "./$metadata");
if (serviceBaseUri.Equals(context.Request.Url))
{
// We need to respond with the service document
var responseMessage = new HttpDataResponseMessage(context.Response);
context.Response.ContentType = "application/xml";
context.Response.ContentEncoding = System.Text.Encoding.UTF8;
var feedGenerator = new ODataFeedGenerator(requestMessage, responseMessage,
_config.Map, serviceBaseUri.ToString(),
messageWriterSettings);
feedGenerator.WriteServiceDocument();
}
else if (serviceBaseUri.ToString().TrimEnd('/').Equals(context.Request.Url.ToString().TrimEnd('/')))
{
// Trimming of trailing slash to normalize - the serviceBaseUri should always have a trailing slash,
// but we will redirect requests that do not to the proper service document url
context.Response.RedirectPermanent(serviceBaseUri.ToString(), true);
}
else if (metadataUri.Equals(context.Request.Url))
{
context.Response.ContentType = "application/xml";
context.Response.WriteFile(_config.MetadataPath);
}
else
{
var parsedQuery = QueryDescriptorQueryNode.ParseUri(
context.Request.Url,
serviceBaseUri,
_config.Model);
sparqlGenerator.ProcessQuery(parsedQuery);
var responseMessage = new HttpDataResponseMessage(context.Response);
var feedGenerator = new ODataFeedGenerator(
requestMessage,
responseMessage,
_config.Map,
serviceBaseUri.ToString(),
messageWriterSettings);
sparqlGenerator.SparqlQueryModel.Execute(_config.SparqlEndpoint, feedGenerator);
context.Response.ContentType = "application/atom+xml";
}
}
/// <summary>
/// Create a new feed generator
/// </summary>
/// <param name="requestMessage">The OData request message that was received</param>
/// <param name="responseMessage">The OData response message to be populated by the generator</param>
/// <param name="entityMap">The map to use to map RDF URIs to OData types and properties</param>
/// <param name="baseUri">The base URI for the OData feed</param>
/// <param name="messageWriterSettings">Additional settings to apply to the generated OData output</param>
public ODataFeedGenerator(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage, SparqlMap entityMap, string baseUri, ODataMessageWriterSettings messageWriterSettings)
{
_request = requestMessage;
_response = responseMessage;
_map = entityMap;
_baseUri = baseUri;
_writerSettings = messageWriterSettings;
}
private void ConfigureWriterSettings(ODataSparqlServiceConfigurationSection serviceConfiguration)
{
BaseODataWriterSettings = new ODataMessageWriterSettings
{
Indent = serviceConfiguration.OutputConfiguration.Indent,
Version = ODataVersion.V3
};
}
/// <summary>
/// Validates that message writer settings are correct.
/// </summary>
/// <param name="messageWriterSettings">The message writer settings to validate.</param>
internal static void ValidateMessageWriterSettings(ODataMessageWriterSettings messageWriterSettings)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(messageWriterSettings != null, "messageWriterSettings != null");
if (messageWriterSettings.BaseUri != null && !messageWriterSettings.BaseUri.IsAbsoluteUri)
{
throw new ODataException(Strings.WriterValidationUtils_MessageWriterSettingsBaseUriMustBeNullOrAbsolute(UriUtilsCommon.UriToString(messageWriterSettings.BaseUri)));
}
}
/// <summary>
/// Sets the 'DataServiceVersion' HTTP header on the message based on the protocol version specified in the settings.
/// </summary>
/// <param name="message">The message to set the data service version header on.</param>
/// <param name="settings">The <see cref="ODataMessageWriterSettings"/> determining the protocol version to use.</param>
internal static void SetDataServiceVersion(ODataMessage message, ODataMessageWriterSettings settings)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(settings != null, "settings != null");
Debug.Assert(settings.Version.HasValue, "settings.Version.HasValue");
string dataServiceVersionString = ODataUtils.ODataVersionToString(settings.Version.Value) + ";";
message.SetHeader(ODataConstants.DataServiceVersionHeader, dataServiceVersionString);
}
protected ODataOutputContext(ODataFormat format, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver)
{
ExceptionUtils.CheckArgumentNotNull<ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull<ODataMessageWriterSettings>(messageWriterSettings, "messageWriterSettings");
this.format = format;
this.messageWriterSettings = messageWriterSettings;
this.writingResponse = writingResponse;
this.synchronous = synchronous;
this.model = model;
this.urlResolver = urlResolver;
}
public void ConvertFeed(Uri relativeODataUri, Uri relativeSodaUri, JsonPayload jsonPayload,
DateTimeOffset feedUpdateTime)
{
var jsonObject = jsonPayload.JsonObject;
var entries = jsonObject.PropertyValue<JArray>("entries");
var meta = jsonObject.PropertyValue<JObject>("meta");
var view = meta.PropertyValue<JObject>("view");
IList<string> fieldsToIgnore;
var model = BuildModel(view, out fieldsToIgnore);
var entitySet = model.EntityContainers.Single().EntitySets().Single();
var settings = new ODataMessageWriterSettings
{
Indent = true,
};
using (var writer = new ODataMessageWriter(Message, settings, model))
{
var feedWriter = writer.CreateODataFeedWriter();
var feed = new ODataFeed();
feed.SetAnnotation(new AtomFeedMetadata
{
Updated = feedUpdateTime,
});
feed.Id = new Uri(ODataEndpointUri, relativeODataUri.OriginalString).OriginalString;
feedWriter.WriteStart(feed);
foreach (var entry in entries.Cast<JObject>())
{
var entryMetadata = new ODataEntry();
entryMetadata.Id = (string) ((JValue) entry.Property("id").Value).Value;
entryMetadata.TypeName = entitySet.ElementType.FullName();
entryMetadata.Properties = ConvertProperties(entry, fieldsToIgnore);
entryMetadata.SetAnnotation(new AtomEntryMetadata
{
Updated = ConvertDateTimeOffset(entry.PrimitivePropertyValue<long>("updated_at")),
Published = ConvertDateTimeOffset(entry.PrimitivePropertyValue<long>("created_at")),
});
feedWriter.WriteStart(entryMetadata);
feedWriter.WriteEnd();
}
feedWriter.WriteEnd();
}
}
public ODataMessageWriterSettings(ODataMessageWriterSettings settings)
{
ExceptionUtils.CheckArgumentNotNull<ODataMessageWriterSettings>(settings, "settings");
this.acceptCharSets = settings.acceptCharSets;
this.acceptMediaTypes = settings.acceptMediaTypes;
this.BaseUri = settings.BaseUri;
this.CheckCharacters = settings.CheckCharacters;
this.DisableMessageStreamDisposal = settings.DisableMessageStreamDisposal;
this.format = settings.format;
this.Indent = settings.Indent;
this.messageQuotas = new ODataMessageQuotas(settings.MessageQuotas);
this.useFormat = settings.useFormat;
this.Version = settings.Version;
this.writerBehavior = settings.writerBehavior;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataBatchContent"/> class.
/// </summary>
/// <param name="responses">The batch responses.</param>
/// <param name="writerSettings">The <see cref="ODataMessageWriterSettings"/>.</param>
public ODataBatchContent(IEnumerable<ODataBatchResponseItem> responses, ODataMessageWriterSettings writerSettings)
{
if (responses == null)
{
throw Error.ArgumentNull("responses");
}
if (writerSettings == null)
{
throw Error.ArgumentNull("writerSettings");
}
Responses = responses;
_writerSettings = writerSettings;
Headers.ContentType = MediaTypeHeaderValue.Parse(String.Format(CultureInfo.InvariantCulture, "multipart/mixed;boundary=batchresponse_{0}", Guid.NewGuid()));
ODataVersion version = _writerSettings.Version ?? HttpRequestMessageProperties.DefaultODataVersion;
Headers.TryAddWithoutValidation(HttpRequestMessageProperties.ODataServiceVersionHeader, ODataUtils.ODataVersionToString(version));
}
public void ODataMetadataSerializer_Works()
{
// Arrange
ODataMetadataSerializer serializer = new ODataMetadataSerializer();
MemoryStream stream = new MemoryStream();
IODataResponseMessage message = new ODataMessageWrapper(stream);
ODataMessageWriterSettings settings = new ODataMessageWriterSettings();
IEdmModel model = new EdmModel();
// Act
serializer.WriteObject("42", typeof(IEdmModel), new ODataMessageWriter(message, settings, model), new ODataSerializerContext());
// Assert
stream.Seek(0, SeekOrigin.Begin);
XElement element = XElement.Load(stream);
Assert.Equal("Edmx", element.Name.LocalName);
}
internal static Tuple<HttpWebRequest, Stream> BuildRequestForTableOperation(Uri uri, UriQueryBuilder builder, IBufferManager bufferManager, int? timeout, TableOperation operation, OperationContext ctx)
{
HttpWebRequest msg = BuildRequestCore(uri, builder, operation.HttpMethod, timeout, ctx);
if (operation.OperationType == TableOperationType.InsertOrMerge || operation.OperationType == TableOperationType.Merge)
{
// post tunnelling
msg.Headers.Add("X-HTTP-Method", "MERGE");
}
// etag
if (operation.OperationType == TableOperationType.Delete ||
operation.OperationType == TableOperationType.Replace ||
operation.OperationType == TableOperationType.Merge)
{
if (operation.Entity.ETag != null)
{
msg.Headers.Add("If-Match", operation.Entity.ETag);
}
}
if (operation.OperationType == TableOperationType.Insert ||
operation.OperationType == TableOperationType.Merge ||
operation.OperationType == TableOperationType.InsertOrMerge ||
operation.OperationType == TableOperationType.InsertOrReplace ||
operation.OperationType == TableOperationType.Replace)
{
// create the writer, indent for readability of the examples.
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
CheckCharacters = false, // sets this flag on the XmlWriter for ATOM
Version = ODataVersion.V2 // set the Odata version to use when writing the entry
};
HttpWebRequestAdapterMessage adapterMsg = new HttpWebRequestAdapterMessage(msg, bufferManager);
ODataMessageWriter odataWriter = new ODataMessageWriter(adapterMsg, writerSettings);
ODataWriter writer = odataWriter.CreateODataEntryWriter();
WriteOdataEntity(operation.Entity, operation.OperationType, ctx, writer);
return new Tuple<HttpWebRequest, Stream>(adapterMsg.GetPopulatedMessage(), adapterMsg.GetStream());
}
return new Tuple<HttpWebRequest, Stream>(msg, null);
}
public string UpdateDataToOData(Change[] changes, string tableName, string[] headers)
{
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, new Uri(this.odataEndpointURL, "$batch"));
requestMessage.Headers.Add("DataServiceVersion", this.odataVersion);
requestMessage.Headers.Add("MaxDataServiceVersion", this.odataMaxVersion);
var setting = new ODataMessageWriterSettings();
setting.SetContentType(ODataFormat.Batch);
setting.BaseUri = this.odataEndpointURL;
var odataHttpRequest = new ODataHttpRequest(requestMessage);
var messageWriter = new ODataMessageWriter(odataHttpRequest, setting, this.metadata);
var batchWriter = messageWriter.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
for (int i = 0; i < changes.Length; i++)
{
batchWriter.WriteStartChangeset();
if (changes[i].operation == "DELETE")
{
createDeleteOperationRequestMessage(ref batchWriter, changes[i], tableName);
}
if (changes[i].operation == "UPDATE")
{
createUpdateOperationRequestMessage(ref batchWriter, changes[i], tableName, headers);
}
batchWriter.WriteEndChangeset();
}
batchWriter.WriteEndBatch();
batchWriter.Flush();
odataHttpRequest.GetStream().Seek(0, SeekOrigin.Begin);
HttpResponseMessage result = new HttpResponseMessage();
using (HttpClient client = new HttpClient())
{
result = client.SendAsync(requestMessage).Result;
}
return parseResponseMessage(result);
}
private ODataMetadataOutputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
this.messageOutputStream = messageStream;
this.xmlWriter = ODataAtomWriterUtils.CreateXmlWriter(messageStream, messageWriterSettings, encoding);
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
private void WriteToStream(Type type, object value, Stream writeStream, HttpContent content, HttpContentHeaders contentHeaders)
{
IEdmModel model = Request.GetEdmModel();
if (model == null)
{
throw Error.InvalidOperation(SRResources.RequestMustHaveModel);
}
ODataSerializer serializer = GetSerializer(type, value, model, _serializerProvider);
UrlHelper urlHelper = Request.GetUrlHelper();
Contract.Assert(urlHelper != null);
ODataPath path = Request.GetODataPath();
IEdmEntitySet targetEntitySet = path == null ? null : path.EntitySet;
// serialize a response
HttpConfiguration configuration = Request.GetConfiguration();
if (configuration == null)
{
throw Error.InvalidOperation(SRResources.RequestMustContainConfiguration);
}
IODataResponseMessage responseMessage = new ODataMessageWrapper(writeStream, content.Headers);
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings(MessageWriterSettings)
{
BaseUri = GetBaseAddress(Request),
Version = _version,
};
// The MetadataDocumentUri is never required for errors. Additionally, it sometimes won't be available
// for errors, such as when routing itself fails. In that case, the route data property is not
// available on the request, and due to a bug with HttpRoute.GetVirtualPath (bug #669) we won't be able
// to generate a metadata link.
if (serializer.ODataPayloadKind != ODataPayloadKind.Error)
{
string metadataLink = urlHelper.ODataLink(new MetadataPathSegment());
if (metadataLink == null)
{
throw new SerializationException(SRResources.UnableToDetermineMetadataUrl);
}
string selectClause = GetSelectClause(Request);
writerSettings.SetMetadataDocumentUri(new Uri(metadataLink), selectClause);
}
MediaTypeHeaderValue contentType = null;
if (contentHeaders != null && contentHeaders.ContentType != null)
{
contentType = contentHeaders.ContentType;
}
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, writerSettings, model))
{
ODataSerializerContext writeContext = new ODataSerializerContext()
{
Request = Request,
RequestContext = Request.GetRequestContext(),
Url = urlHelper,
EntitySet = targetEntitySet,
Model = model,
RootElementName = GetRootElementName(path) ?? "root",
SkipExpensiveAvailabilityChecks = serializer.ODataPayloadKind == ODataPayloadKind.Feed,
Path = path,
MetadataLevel = ODataMediaTypes.GetMetadataLevel(contentType),
SelectExpandClause = Request.GetSelectExpandClause()
};
serializer.WriteObject(value, type, messageWriter, writeContext);
}
}
private ODataRawOutputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
this.messageOutputStream = messageStream;
this.encoding = encoding;
if (synchronous)
{
this.outputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
this.outputStream = this.asynchronousOutputStream;
}
}
catch
{
messageStream.Dispose();
throw;
}
}
private static ODataMessageWriterSettings CreateJsonLightSettings()
{
ODataMessageWriterSettings settings = new ODataMessageWriterSettings();
settings.SetContentType(ODataFormat.Json);
settings.SetMetadataDocumentUri(CreateFakeUri());
return settings;
}
private static ODataMessageWriterSettings CreateMessageWriterSettings(Uri serviceUri, DataServiceProviderWrapper provider, Version responseVersion, bool disableDisposeStream, ODataFormat format)
{
ODataMessageWriterSettings settings = new ODataMessageWriterSettings {
BaseUri = serviceUri,
Version = new ODataVersion?(CommonUtil.ConvertToODataVersion(responseVersion)),
Indent = false,
CheckCharacters = false,
DisableMessageStreamDisposal = disableDisposeStream
};
settings.EnableWcfDataServicesServerBehavior(provider.IsV1Provider);
settings.SetContentType(format);
return settings;
}
/// <summary>
/// Copy constructor to create a copy of the settings for OData writers.
/// </summary>
/// <param name="settings">Settings to create a copy from</param>
public ODataMessageWriterSettings(ODataMessageWriterSettings settings)
{
ExceptionUtils.CheckArgumentNotNull(settings, "settings");
this.acceptCharSets = settings.acceptCharSets;
this.acceptMediaTypes = settings.acceptMediaTypes;
this.BaseUri = settings.BaseUri;
this.CheckCharacters = settings.CheckCharacters;
this.DisableMessageStreamDisposal = settings.DisableMessageStreamDisposal;
this.format = settings.format;
this.Indent = settings.Indent;
this.messageQuotas = new ODataMessageQuotas(settings.MessageQuotas);
this.useFormat = settings.useFormat;
this.Version = settings.Version;
this.atomFormatStartEntryXmlCustomizationCallback = settings.atomFormatStartEntryXmlCustomizationCallback;
this.atomFormatEndEntryXmlCustomizationCallback = settings.atomFormatEndEntryXmlCustomizationCallback;
// NOTE: writer behavior is immutable; copy by reference is ok.
this.writerBehavior = settings.writerBehavior;
}
internal static ODataOutputContext CreateOutputContext(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
if (format == ODataFormat.Atom)
{
return(ODataAtomOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
if (format == ODataFormat.Metadata)
{
return(ODataMetadataOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
if ((format != ODataFormat.Batch) && (format != ODataFormat.RawValue))
{
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataOutputContext_CreateOutputContext_UnrecognizedFormat));
}
return(ODataRawOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
internal static ODataOutputContext Create(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
return(new ODataRawOutputContext(format, message.GetStream(), encoding, messageWriterSettings, writingResponse, true, model, urlResolver));
}
private IEnumerable<KeyValuePair<string, string>> GetResponseMessageHeaders(Type graphType, ODataFormat odataFormat, ODataVersion version)
{
IODataResponseMessage responseMessage = new ODataMessageWrapper();
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = new Uri(ODataFormatterConstants.DefaultNamespace),
Version = version,
Indent = false
};
writerSettings.SetContentType(odataFormat);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, writerSettings))
{
ODataSerializer serializer = ODataSerializerProvider.GetODataPayloadSerializer(graphType);
// get the OData specific headers for the payloadkind
ODataUtils.SetHeadersForPayload(messageWriter, serializer.ODataPayloadKind);
}
return responseMessage.Headers;
}
internal static Task <ODataOutputContext> CreateAsync(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
return(message.GetStreamAsync().FollowOnSuccessWith <Stream, ODataOutputContext>(streamTask => new ODataRawOutputContext(format, streamTask.Result, encoding, messageWriterSettings, writingResponse, false, model, urlResolver)));
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (writeStream == null)
{
throw Error.ArgumentNull("writeStream");
}
if (Request == null)
{
throw Error.NotSupported(SRResources.WriteToStreamAsyncMustHaveRequest);
}
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
return TaskHelpers.RunSynchronously(() =>
{
// Get the format and version to use from the ODataServiceVersion content header or if not available use the
// values configured for the specialized formatter instance.
ODataVersion version;
ODataFormat odataFormat;
if (contentHeaders == null)
{
version = _defaultODataVersion;
odataFormat = ODataFormatterConstants.DefaultODataFormat;
}
else
{
version = GetODataVersion(contentHeaders, ODataFormatterConstants.ODataServiceVersion) ?? _defaultODataVersion;
odataFormat = GetODataFormat(contentHeaders);
}
ODataSerializer serializer = ODataSerializerProvider.GetODataPayloadSerializer(type);
if (serializer == null)
{
throw Error.InvalidOperation(SRResources.TypeCannotBeSerialized, type.Name, typeof(ODataMediaTypeFormatter).Name);
}
UrlHelper urlHelper = Request.GetUrlHelper();
NameValueCollection queryStringValues = Request.RequestUri.ParseQueryString();
IEdmEntitySet targetEntitySet = null;
ODataUriHelpers.TryGetEntitySetAndEntityType(Request.RequestUri, Model, out targetEntitySet);
ODataQueryProjectionNode rootProjectionNode = null;
if (targetEntitySet != null)
{
// TODO: Bug 467621: Move to ODataUriParser once it is done.
rootProjectionNode = ODataUriHelpers.GetODataQueryProjectionNode(queryStringValues["$select"], queryStringValues["$expand"], targetEntitySet);
}
// serialize a response
Uri baseAddress = new Uri(Request.RequestUri, Request.GetConfiguration().VirtualPathRoot);
// TODO: Bug 467617: figure out the story for the operation name on the client side and server side.
// This is clearly a workaround. We are assuming that the operation name is the last segment in the request uri
// which works for most cases and fall back to the type name of the object being written.
// We should rather use uri parser semantic tree to figure out the operation name from the request url.
string operationName = ODataUriHelpers.GetOperationName(Request.RequestUri, baseAddress);
operationName = operationName ?? type.Name;
IODataResponseMessage responseMessage = new ODataMessageWrapper(writeStream);
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = baseAddress,
Version = version,
Indent = true,
DisableMessageStreamDisposal = true,
};
if (contentHeaders != null && contentHeaders.ContentType != null)
{
writerSettings.SetContentType(contentHeaders.ContentType.ToString(), Encoding.UTF8.WebName);
}
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, writerSettings, ODataDeserializerProvider.EdmModel))
{
ODataSerializerContext writeContext = new ODataSerializerContext()
{
EntitySet = targetEntitySet,
UrlHelper = urlHelper,
RootProjectionNode = rootProjectionNode,
CurrentProjectionNode = rootProjectionNode,
ServiceOperationName = operationName
};
serializer.WriteObject(value, messageWriter, writeContext);
}
});
}
/// <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,
MediaTypeResolver mediaTypeResolver,
out MediaType mediaType,
out Encoding encoding)
{
DebugUtils.CheckNoExternalCallers();
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 <MediaTypeWithFormat> supportedMediaTypes = mediaTypeResolver.GetMediaTypesForPayloadKind(payloadKind);
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 <MediaType, string> > specifiedTypes = HttpUtils.MediaTypesFromString(settings.AcceptableMediaTypes);
// Starting in V3 we replace all occurrences of application/json with application/json;odata=minimalmetadata
// before handing the acceptable media types to the conneg code. This is necessary because for an accept
// header 'application/json, application/json;odata=verbose' we want to the result to be 'application/json;odata=minimalmetadata'
// although this is not compliant with the default conneg rules (where application/json;odata=verbose would win).
if (settings.Version >= ODataVersion.V3)
{
ConvertApplicationJsonInAcceptableMediaTypes(specifiedTypes);
}
MediaTypeWithFormat 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);
}
public void ConvertMetadata(Uri relativeODataUri, Uri relativeSodaUri, JsonPayload jsonPayload)
{
var jsonObject = jsonPayload.JsonObject;
var meta = jsonObject.PropertyValue<JObject>("meta");
var view = meta.PropertyValue<JObject>("view");
IList<string> fieldsToIgnore;
var model = BuildModel(view, out fieldsToIgnore);
var settings = new ODataMessageWriterSettings
{
Indent = true,
};
using (var writer = new ODataMessageWriter(Message, settings, model))
{
writer.WriteMetadataDocument();
}
}
internal static Tuple<HttpWebRequest, Stream> BuildRequestForTableBatchOperation(Uri uri, UriQueryBuilder builder, int? timeout, Uri baseUri, string tableName, TableBatchOperation batch, OperationContext ctx)
{
HttpWebRequest msg = BuildRequestCore(NavigationHelper.AppendPathToUri(uri, "$batch"), builder, "POST", timeout, ctx);
// create the writer, indent for readability of the examples.
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
CheckCharacters = false, // sets this flag on the XmlWriter for ATOM
Version = ODataVersion.V2 // set the Odata version to use when writing the entry
};
HttpWebRequestAdapterMessage adapterMsg = new HttpWebRequestAdapterMessage(msg);
// Start Batch
ODataMessageWriter odataWriter = new ODataMessageWriter(adapterMsg, writerSettings);
ODataBatchWriter batchWriter = odataWriter.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
bool isQuery = batch.Count == 1 && batch[0].OperationType == TableOperationType.Retrieve;
// Query operations should not be inside changeset in payload
if (!isQuery)
{
// Start Operation
batchWriter.WriteStartChangeset();
batchWriter.Flush();
}
foreach (TableOperation operation in batch)
{
string httpMethod = operation.OperationType == TableOperationType.Merge || operation.OperationType == TableOperationType.InsertOrMerge ? "MERGE" : operation.HttpMethod;
ODataBatchOperationRequestMessage mimePartMsg = batchWriter.CreateOperationRequestMessage(httpMethod, operation.GenerateRequestURI(baseUri, tableName));
// etag
if (operation.OperationType == TableOperationType.Delete ||
operation.OperationType == TableOperationType.Replace ||
operation.OperationType == TableOperationType.Merge)
{
mimePartMsg.SetHeader("If-Match", operation.Entity.ETag);
}
if (operation.OperationType != TableOperationType.Delete && operation.OperationType != TableOperationType.Retrieve)
{
using (ODataMessageWriter batchEntryWriter = new ODataMessageWriter(mimePartMsg, writerSettings))
{
// Write entity
ODataWriter entryWriter = batchEntryWriter.CreateODataEntryWriter();
WriteOdataEntity(operation.Entity, operation.OperationType, ctx, entryWriter);
}
}
}
if (!isQuery)
{
// End Operation
batchWriter.WriteEndChangeset();
}
// End Batch
batchWriter.WriteEndBatch();
batchWriter.Flush();
return new Tuple<HttpWebRequest, Stream>(adapterMsg.GetPopulatedMessage(), adapterMsg.GetStream());
}
public void ODataEntityReferenceLinkSerializer_Serializes_UrisAndEntityReferenceLinks_Json(object uris)
{
// Arrange
ODataEntityReferenceLinksSerializer serializer = new ODataEntityReferenceLinksSerializer();
IEdmNavigationProperty navigationProperty = _customerSet.ElementType.NavigationProperties().First();
ODataPath path = new ODataPath(new EntitySetPathSegment(_customerSet), new KeyValuePathSegment("1"),
new NavigationPathSegment(navigationProperty));
ODataSerializerContext writeContext = new ODataSerializerContext { Path = path };
MemoryStream stream = new MemoryStream();
IODataResponseMessage message = new ODataMessageWrapper(stream);
ODataMessageWriterSettings settings = new ODataMessageWriterSettings
{
BaseUri = new Uri("http://any/")
};
settings.SetMetadataDocumentUri(new Uri("http://any/$metadata"));
settings.SetContentType(ODataFormat.Json);
// Act
serializer.WriteObject(uris, typeof(ODataEntityReferenceLinks), new ODataMessageWriter(message, settings), writeContext);
stream.Seek(0, SeekOrigin.Begin);
string result = new StreamReader(stream).ReadToEnd();
// Assert
Assert.Equal(
string.Format("{0},{1}",
"{\"odata.metadata\":\"http://any/$metadata#Default.Container.Customers/$links/Orders\"",
"\"value\":[{\"url\":\"http://uri1/\"},{\"url\":\"http://uri2/\"}]}"), result);
}
internal static Tuple<HttpWebRequest, Stream> BuildRequestForTableBatchOperation(Uri uri, UriQueryBuilder builder, IBufferManager bufferManager, int? timeout, string tableName, TableBatchOperation batch, bool useVersionHeader, OperationContext ctx, TableRequestOptions options, string accountName)
{
HttpWebRequest msg = BuildRequestCore(NavigationHelper.AppendPathToSingleUri(uri, "$batch"), builder, "POST", timeout, useVersionHeader, ctx);
TablePayloadFormat payloadFormat = options.PayloadFormat.Value;
Logger.LogInformational(ctx, SR.PayloadFormat, payloadFormat);
// create the writer, indent for readability of the examples.
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
CheckCharacters = false, // sets this flag on the XmlWriter for ATOM
Version = TableConstants.ODataProtocolVersion // set the Odata version to use when writing the entry
};
HttpWebRequestAdapterMessage adapterMsg = new HttpWebRequestAdapterMessage(msg, bufferManager);
ODataMessageWriter odataWriter = new ODataMessageWriter(adapterMsg, writerSettings);
ODataBatchWriter batchWriter = odataWriter.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
bool isQuery = batch.Count == 1 && batch[0].OperationType == TableOperationType.Retrieve;
// Query operations should not be inside changeset in payload
if (!isQuery)
{
// Start Operation
batchWriter.WriteStartChangeset();
batchWriter.Flush();
}
foreach (TableOperation operation in batch)
{
string httpMethod = operation.HttpMethod;
if (operation.OperationType == TableOperationType.Merge || operation.OperationType == TableOperationType.InsertOrMerge)
{
options.AssertNoEncryptionPolicyOrStrictMode();
httpMethod = "MERGE";
}
ODataBatchOperationRequestMessage mimePartMsg = batchWriter.CreateOperationRequestMessage(httpMethod, operation.GenerateRequestURI(uri, tableName));
SetAcceptAndContentTypeForODataBatchMessage(mimePartMsg, payloadFormat);
// etag
if (operation.OperationType == TableOperationType.Delete ||
operation.OperationType == TableOperationType.Replace ||
operation.OperationType == TableOperationType.Merge)
{
mimePartMsg.SetHeader("If-Match", operation.Entity.ETag);
}
// Prefer header
if (operation.OperationType == TableOperationType.Insert)
{
mimePartMsg.SetHeader("Prefer", operation.EchoContent ? "return-content" : "return-no-content");
}
if (operation.OperationType != TableOperationType.Delete && operation.OperationType != TableOperationType.Retrieve)
{
using (ODataMessageWriter batchEntryWriter = new ODataMessageWriter(mimePartMsg, writerSettings, new TableStorageModel(accountName)))
{
// Write entity
ODataWriter entryWriter = batchEntryWriter.CreateODataEntryWriter();
WriteOdataEntity(operation.Entity, operation.OperationType, ctx, entryWriter, options);
}
}
}
if (!isQuery)
{
// End Operation
batchWriter.WriteEndChangeset();
}
// End Batch
batchWriter.WriteEndBatch();
batchWriter.Flush();
return new Tuple<HttpWebRequest, Stream>(adapterMsg.GetPopulatedMessage(), adapterMsg.GetStream());
}
internal static Tuple<HttpWebRequest, Stream> BuildRequestForTableOperation(Uri uri, UriQueryBuilder builder, IBufferManager bufferManager, int? timeout, TableOperation operation, bool useVersionHeader, OperationContext ctx, TableRequestOptions options, string accountName)
{
HttpWebRequest msg = BuildRequestCore(uri, builder, operation.HttpMethod, timeout, useVersionHeader, ctx);
TablePayloadFormat payloadFormat = options.PayloadFormat.Value;
// Set Accept and Content-Type based on the payload format.
SetAcceptHeaderForHttpWebRequest(msg, payloadFormat);
Logger.LogInformational(ctx, SR.PayloadFormat, payloadFormat);
if (operation.HttpMethod != "HEAD" && operation.HttpMethod != "GET")
{
SetContentTypeForHttpWebRequest(msg, payloadFormat);
}
if (operation.OperationType == TableOperationType.InsertOrMerge || operation.OperationType == TableOperationType.Merge)
{
options.AssertNoEncryptionPolicyOrStrictMode();
// post tunnelling
msg.Headers.Add("X-HTTP-Method", "MERGE");
}
// etag
if (operation.OperationType == TableOperationType.Delete ||
operation.OperationType == TableOperationType.Replace ||
operation.OperationType == TableOperationType.Merge)
{
if (operation.Entity.ETag != null)
{
msg.Headers.Add("If-Match", operation.Entity.ETag);
}
}
// prefer header
if (operation.OperationType == TableOperationType.Insert)
{
msg.Headers.Add("Prefer", operation.EchoContent ? "return-content" : "return-no-content");
}
if (operation.OperationType == TableOperationType.Insert ||
operation.OperationType == TableOperationType.Merge ||
operation.OperationType == TableOperationType.InsertOrMerge ||
operation.OperationType == TableOperationType.InsertOrReplace ||
operation.OperationType == TableOperationType.Replace)
{
// create the writer, indent for readability of the examples.
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
CheckCharacters = false, // sets this flag on the XmlWriter for ATOM
Version = TableConstants.ODataProtocolVersion // set the Odata version to use when writing the entry
};
HttpWebRequestAdapterMessage adapterMsg = new HttpWebRequestAdapterMessage(msg, bufferManager);
if (operation.HttpMethod != "HEAD" && operation.HttpMethod != "GET")
{
SetContentTypeForAdapterMessage(adapterMsg, payloadFormat);
}
ODataMessageWriter odataWriter = new ODataMessageWriter(adapterMsg, writerSettings, new TableStorageModel(accountName));
ODataWriter writer = odataWriter.CreateODataEntryWriter();
WriteOdataEntity(operation.Entity, operation.OperationType, ctx, writer, options);
return new Tuple<HttpWebRequest, Stream>(adapterMsg.GetPopulatedMessage(), adapterMsg.GetStream());
}
return new Tuple<HttpWebRequest, Stream>(msg, null);
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (writeStream == null)
{
throw Error.ArgumentNull("writeStream");
}
if (_request == null)
{
throw Error.InvalidOperation(SRResources.WriteToStreamAsyncMustHaveRequest);
}
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
return TaskHelpers.RunSynchronously(() =>
{
// get the most appropriate serializer given that we support inheritance.
IEdmModel model = _request.GetEdmModel();
if (model == null)
{
throw Error.InvalidOperation(SRResources.RequestMustHaveModel);
}
type = value == null ? type : value.GetType();
ODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(model, type);
if (serializer == null)
{
string message = Error.Format(SRResources.TypeCannotBeSerialized, type.Name, typeof(ODataMediaTypeFormatter).Name);
throw new SerializationException(message);
}
UrlHelper urlHelper = _request.GetUrlHelper();
Contract.Assert(urlHelper != null);
ODataPath path = _request.GetODataPath();
IEdmEntitySet targetEntitySet = path == null ? null : path.EntitySet;
// serialize a response
HttpConfiguration configuration = _request.GetConfiguration();
if (configuration == null)
{
throw Error.InvalidOperation(SRResources.RequestMustContainConfiguration);
}
IODataResponseMessage responseMessage = new ODataMessageWrapper(writeStream, content.Headers);
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = GetBaseAddress(_request),
Version = _version,
Indent = true,
DisableMessageStreamDisposal = true,
MessageQuotas = MessageWriterQuotas
};
// The MetadataDocumentUri is never required for errors. Additionally, it sometimes won't be available
// for errors, such as when routing itself fails. In that case, the route data property is not
// available on the request, and due to a bug with HttpRoute.GetVirtualPath (bug #669) we won't be able
// to generate a metadata link.
if (serializer.ODataPayloadKind != ODataPayloadKind.Error)
{
string metadataLink = urlHelper.ODataLink(new MetadataPathSegment());
if (metadataLink == null)
{
throw new SerializationException(SRResources.UnableToDetermineMetadataUrl);
}
writerSettings.SetMetadataDocumentUri(new Uri(metadataLink));
}
MediaTypeHeaderValue contentType = null;
if (contentHeaders != null && contentHeaders.ContentType != null)
{
contentType = contentHeaders.ContentType;
}
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, writerSettings, model))
{
ODataSerializerContext writeContext = new ODataSerializerContext()
{
Request = _request,
Url = urlHelper,
EntitySet = targetEntitySet,
Model = model,
RootElementName = GetRootElementName(path) ?? "root",
SkipExpensiveAvailabilityChecks = serializer.ODataPayloadKind == ODataPayloadKind.Feed,
Path = path,
MetadataLevel = ODataMediaTypes.GetMetadataLevel(contentType),
};
serializer.WriteObject(value, messageWriter, writeContext);
}
});
}
/// <summary>
/// Creates an instance of the output context for the specified format.
/// </summary>
/// <param name="format">The format to create the context for.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>The newly created output context.</returns>
internal static ODataOutputContext CreateOutputContext(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
if (format == ODataFormat.Atom)
{
return(ODataAtomOutputContext.Create(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonOutputContext.Create(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
if (format == ODataFormat.Metadata)
{
return(ODataMetadataOutputContext.Create(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
if (format == ODataFormat.Batch || format == ODataFormat.RawValue)
{
return(ODataRawOutputContext.Create(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataOutputContext_CreateOutputContext_UnrecognizedFormat));
}