public async Task <ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage)
{
var readerSettings = new ODataMessageReaderSettings();
// TODO ODataLib7
if (_session.Settings.IgnoreUnmappedProperties)
{
readerSettings.Validations &= ~ValidationKinds.ThrowOnUndeclaredPropertyForNonOpenType;
}
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
readerSettings.ShouldIncludeAnnotation = x => _session.Settings.IncludeAnnotationsInResults;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return(ODataResponse.FromStatusCode(responseMessage.StatusCode));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
return(ODataResponse.FromValueStream(await responseMessage.GetStreamAsync().ConfigureAwait(false), responseMessage is ODataBatchOperationResponseMessage));
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return(await ReadResponse(messageReader.CreateODataBatchReader()).ConfigureAwait(false));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.ResourceSet))
{
return(ReadResponse(messageReader.CreateODataResourceSetReader()));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return(ReadResponse(messageReader.CreateODataCollectionReader()));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Resource))
{
return(ReadResponse(messageReader.CreateODataResourceReader()));
}
else
{
var property = messageReader.ReadProperty();
return(ODataResponse.FromProperty(property.Name, GetPropertyValue(property.Value)));
}
}
else
{
return(ReadResponse(messageReader.CreateODataResourceReader()));
}
}
}
public async Task <ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage)
{
if (responseMessage.StatusCode == (int)HttpStatusCode.NoContent)
{
return(ODataResponse.FromStatusCode(TypeCache, responseMessage.StatusCode, responseMessage.Headers));
}
var readerSettings = _session.ToReaderSettings();
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind().ToList();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return(ODataResponse.FromStatusCode(TypeCache, responseMessage.StatusCode, responseMessage.Headers));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
return(ODataResponse.FromValueStream(TypeCache, await responseMessage.GetStreamAsync().ConfigureAwait(false), responseMessage is ODataBatchOperationResponseMessage));
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return(await ReadResponse(messageReader.CreateODataBatchReader()).ConfigureAwait(false));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.ResourceSet))
{
return(ReadResponse(messageReader.CreateODataResourceSetReader(), responseMessage));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return(ReadResponse(messageReader.CreateODataCollectionReader()));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Resource))
{
return(ReadResponse(messageReader.CreateODataResourceReader(), responseMessage));
}
else
{
var property = messageReader.ReadProperty();
return(ODataResponse.FromProperty(TypeCache, property.Name, GetPropertyValue(property.Value)));
}
}
else
{
return(ReadResponse(messageReader.CreateODataResourceReader(), responseMessage));
}
}
}
public void QueryByDateKey()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Calendars(2015-11-11)", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
ODataResource entry = reader.Item as ODataResource;
// Verify Date Property
Assert.Equal(new Date(2015, 11, 11), entry.Properties.Single(p => p.Name == "Day").Value);
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
/// <summary>
/// Specifically use to query single entry or multi entries(query with $expand)
/// </summary>
/// <param name="requestUri"></param>
/// <param name="mimeType"></param>
/// <returns></returns>
public List <ODataResource> QueryEntries(string requestUri, string mimeType)
{
List <ODataResource> entries = new List <ODataResource>();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = baseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
requestMessage.SetHeader("Prefer", string.Format("{0}={1}", IncludeAnnotation, "*"));
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entries.Add(reader.Item as ODataResource);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return(entries);
}
public ODataResourceSet QueryInnerFeed(string requestUri, string mimeType)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = baseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceSetEnd)
{
return(reader.Item as ODataResourceSet);
}
}
}
}
return(null);
}
private void ReadEntryPayload(IEdmModel userModel, string payload, EdmEntitySet entitySet, IEdmEntityType entityType, Action <ODataReader> action, bool isIeee754Compatible = true, IServiceProvider container = null)
{
var message = new InMemoryMessage()
{
Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload)), Container = container
};
string contentType = isIeee754Compatible
? "application/json;odata.metadata=minimal;IEEE754Compatible=true"
: "application/json;odata.metadata=minimal;IEEE754Compatible=false";
message.SetHeader("Content-Type", contentType);
var readerSettings = new ODataMessageReaderSettings {
EnableMessageStreamDisposal = true
};
readerSettings.Validations &= ~ValidationKinds.ThrowOnUndeclaredPropertyForNonOpenType;
using (var msgReader = new ODataMessageReader((IODataResponseMessage)message, readerSettings, userModel))
{
var reader = msgReader.CreateODataResourceReader(entitySet, entityType);
while (reader.Read())
{
action(reader);
}
}
}
private ODataResource ReadEntityFromStream(Stream content, Uri requestUrl, String contentType, out IEdmEntitySet entitySet)
{
ODataUri odataUri = OeParser.ParseUri(_edmModel, _baseUri, requestUrl);
entitySet = ((EntitySetSegment)odataUri.Path.FirstSegment).EntitySet;
_edmEntityType = entitySet.EntityType();
IEdmModel edmModel = _edmModel.GetEdmModel(entitySet);
ODataResource entry = null;
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(content, contentType, _serviceProvider);
var settings = new ODataMessageReaderSettings
{
ClientCustomTypeResolver = ClientCustomTypeResolver,
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entitySet.EntityType());
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
return(entry);
}
private ODataResource QueryComplexProperty(string uri, string mimeType)
{
ODataResource complex = null;
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + uri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var odataReader = messageReader.CreateODataResourceReader();
while (odataReader.Read())
{
if (odataReader.State == ODataReaderState.ResourceEnd)
{
complex = odataReader.Item as ODataResource;
}
}
Assert.IsNotNull(complex);
}
}
return(complex);
}
public void ReadCompletedAsyncResponse()
{
string payload = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nOData-Version: 4.0\r\n\r\n{\"@odata.context\":\"http://host/service/$metadata#MySingleton\",\"Id\":1}";
var asyncReader = this.CreateAsyncReader(payload);
var asyncResponse = asyncReader.CreateResponseMessage();
Assert.Equal(200, asyncResponse.StatusCode);
Assert.Equal("application/json", asyncResponse.GetHeader("Content-Type"));
Assert.Equal("4.0", asyncResponse.GetHeader("OData-Version"));
using (var innerMessageReader = new ODataMessageReader(asyncResponse, new ODataMessageReaderSettings(), userModel))
{
var reader = innerMessageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
ODataResource entry = reader.Item as ODataResource;
Assert.Equal(1, entry.Properties.Single(p => p.Name == "Id").Value);
}
}
}
}
public void EntryTypeDefinedInReferencedModel()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "VehicleGPSSet('VehicleKey2')", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
List <ODataResource> entries = new List <ODataResource>();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entries.Add(reader.Item as ODataResource);
}
}
Assert.Equal("VehicleKey2", entries.Last().Properties.Single(p => p.Name == "Key").Value);
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
public void PropertyDefinedInReferencedModel()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(
new Uri(ServiceBaseUri.AbsoluteUri + "DerivedVehicleGPSSet('VehicleKey4')/Microsoft.OData.SampleService.Models.ModelRefDemo.GPS.VehicleGPSType/StartLocation", UriKind.Absolute));
requestMessage.SetHeader("Accept", MimeTypes.ApplicationJson + MimeTypes.ODataParameterFullMetadata);
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var odatareader = messageReader.CreateODataResourceReader();
while (odatareader.Read())
{
if (odatareader.State == ODataReaderState.ResourceEnd)
{
Assert.NotNull(odatareader.Item as ODataResource);
}
}
}
}
public void UnBoundFunctionReturnTypeInReferencedModel()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "GetDefaultOutsideGeoFenceAlarm()", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
ODataResource perp = null;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var odataReader = messageReader.CreateODataResourceReader();
while (odataReader.Read())
{
if (odataReader.State == ODataReaderState.ResourceEnd)
{
perp = odataReader.Item as ODataResource;
}
}
Assert.Equal(1, perp.Properties.Single(p => p.Name == "Severity").Value);
}
}
private ODataItem QueryEntityItem(string uri, int expectedStatusCode = 200)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var queryRequestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + uri, UriKind.Absolute));
queryRequestMessage.SetHeader("Accept", MimeTypes.ApplicationJsonLight);
var queryResponseMessage = queryRequestMessage.GetResponse();
Assert.AreEqual(expectedStatusCode, queryResponseMessage.StatusCode);
ODataItem item = null;
if (expectedStatusCode == 200)
{
using (var messageReader = new ODataMessageReader(queryResponseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
item = reader.Item;
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return(item);
}
public void QueryVCardEntityProperty()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri,
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "People(31)/BusinessCard", UriKind.Absolute));
SetVCardMediaTypeResolver(requestMessage);
requestMessage.SetHeader("Accept", "text/x-vCard");
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
ODataResource resource = null;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var odataReader = messageReader.CreateODataResourceReader();
while (odataReader.Read())
{
if (odataReader.State == ODataReaderState.ResourceEnd)
{
resource = odataReader.Item as ODataResource;
}
}
}
Assert.NotNull(resource);
Assert.Equal("Name1", resource.Properties.Single(p => p.Name == "N").Value);
}
private static ODataResource GetReadedResource(string messageContent, EdmModel model, IEdmEntitySetBase entitySet, EdmEntityType entityType, IServiceProvider container)
{
var outputStream = new MemoryStream();
var writer = new StreamWriter(outputStream);
writer.Write(messageContent);
writer.Flush();
outputStream.Seek(0, SeekOrigin.Begin);
IODataResponseMessage message = new InMemoryMessage
{
Stream = outputStream,
Container = container
};
message.SetHeader("Content-Type", "application/json");
var settings = new ODataMessageReaderSettings();
using (var messageReader = new ODataMessageReader(message, settings, model))
{
var reader = messageReader.CreateODataResourceReader(entitySet, entityType);
Assert.True(reader.Read());
return(reader.Item as ODataResource);
}
}
private OeEntityItem ReadEntityFromStream(OeMessageContext context, Stream content)
{
var parser = new ODataUriParser(context.Model, context.BaseUri, RequestUrl);
IEdmEntitySet entitySet;
IEdmEntityTypeReference entityTypeRef = GetEdmEntityTypeRef(parser.ParsePath(), out entitySet);
var entityType = (IEdmEntityType)entityTypeRef.Definition;
ODataResource entry = null;
IODataRequestMessage requestMessage = new OeInMemoryMessage(content, ContentType);
var settings = new ODataMessageReaderSettings {
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, context.Model))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entityType);
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
Db.OeEntitySetMetaAdapter entitySetMetaAdapter = context.EntitySetMetaAdapters.FindByEntitySetName(entitySet.Name);
return(new OeEntityItem(entitySet, entityType, entitySetMetaAdapter.EntityType, entry));
}
private static IList <ODataResource> GetReadedResourceWithNestedInfo(string messageContent, EdmModel model, IEdmEntitySetBase entitySet, EdmEntityType entityType, IServiceProvider container)
{
var outputStream = new MemoryStream();
var writer = new StreamWriter(outputStream);
writer.Write(messageContent);
writer.Flush();
outputStream.Seek(0, SeekOrigin.Begin);
IODataResponseMessage message = new InMemoryMessage
{
Stream = outputStream,
Container = container
};
message.SetHeader("Content-Type", "application/json;odata.metadata=full");
var settings = new ODataMessageReaderSettings();
using (var messageReader = new ODataMessageReader(message, settings, model))
{
var reader = messageReader.CreateODataResourceReader(entitySet, entityType);
IList <ODataResource> resources = new List <ODataResource>();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
resources.Add(reader.Item as ODataResource);
}
}
return(resources);
}
}
public void EntityInstanceAnnotation()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in TestMimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Boss", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
requestMessage.SetHeader("Prefer", string.Format("{0}={1}", IncludeAnnotation, "*"));
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
List <ODataResource> entries = new List <ODataResource>();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entries.Add(reader.Item as ODataResource);
}
}
Assert.AreEqual(true, (entries.Last().InstanceAnnotations.First(i => i.Name.Equals(string.Format("{0}.IsBoss", TestModelNameSpace))).Value as ODataPrimitiveValue).Value);
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
}
}
private static ODataResource ReadEntityFromStream(IEdmModel edmModel, Uri baseUri, Stream content, Uri requestUrl, String contentType, out IEdmEntitySet entitySet)
{
var parser = new ODataUriParser(edmModel, baseUri, requestUrl);
IEdmEntityTypeReference entityTypeRef = GetEdmEntityTypeRef(parser.ParsePath(), out entitySet);
ODataResource entry = null;
IODataRequestMessage requestMessage = new OeInMemoryMessage(content, contentType);
var settings = new ODataMessageReaderSettings {
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entitySet.EntityType());
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
return(entry);
}
private ODataResource QueryEntry(string uri, string mimeType)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var queryRequestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + uri, UriKind.Absolute));
queryRequestMessage.SetHeader("Accept", mimeType);
var queryResponseMessage = queryRequestMessage.GetResponse();
Assert.AreEqual(200, queryResponseMessage.StatusCode);
ODataResource entry = null;
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(queryResponseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = reader.Item as ODataResource;
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return(entry);
}
private List <ODataResource> ReadPayload(string payload, IEdmModel model, IEdmNavigationSource entitySet, IEdmStructuredType entityType, bool isFullMetadata = false)
{
InMemoryMessage message = new InMemoryMessage();
if (isFullMetadata)
{
message.SetHeader("Content-Type", "application/json;odata.metadata=full");
}
else
{
message.SetHeader("Content-Type", "application/json;odata.metadata=minimal");
}
message.Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
List <ODataResource> entryList = new List <ODataResource>();
using (var messageReader = new ODataMessageReader((IODataResponseMessage)message, null, model))
{
var reader = messageReader.CreateODataResourceReader(entitySet, entityType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceEnd:
entryList.Add((ODataResource)reader.Item);
break;
}
}
}
return(entryList);
}
public void ActionTakeDateAndTimeAsParameter()
{
var writerSettings = new ODataMessageWriterSettings();
writerSettings.BaseUri = ServiceBaseUri;
var readerSettings = new ODataMessageReaderSettings();
readerSettings.BaseUri = ServiceBaseUri;
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "Orders(7)/Microsoft.Test.OData.Services.ODataWCFService.ChangeShipTimeAndDate"));
requestMessage.SetHeader("Content-Type", mimeType);
requestMessage.SetHeader("Accept", mimeType);
requestMessage.Method = "POST";
Date newDate = Date.MinValue;
TimeOfDay newTime = TimeOfDay.MinValue;
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter((IEdmOperation)null);
odataWriter.WriteStart();
odataWriter.WriteValue("date", newDate);
odataWriter.WriteValue("time", newTime);
odataWriter.WriteEnd();
}
// send the http request
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
ODataResource entry = reader.Item as ODataResource;
if (entry != null)
{
Assert.Equal(Date.MinValue, entry.Properties.Single(p => p.Name == "ShipDate").Value);
Assert.Equal(TimeOfDay.MinValue, entry.Properties.Single(p => p.Name == "ShipTime").Value);
}
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
/// <summary>
/// Read the response message and perform given verifications
/// </summary>
/// <param name="isFeed">Whether the response has a feed</param>
/// <param name="responseMessage">The response message</param>
/// <param name="expectedSet">Expected IEdmEntitySet</param>
/// <param name="expectedType">Expected IEdmEntityType</param>
/// <param name="verifyFeed">Action to verify the feed</param>
/// <param name="verifyEntry">Action to verify the entry</param>
/// <param name="verifyNavigation">Action to verify the navigation</param>
public static void ReadAndVerifyFeedEntryMessage(bool isFeed, StreamResponseMessage responseMessage,
IEdmEntitySet expectedSet, IEdmEntityType expectedType,
Action <ODataResourceSet> verifyFeed, Action <ODataResource> verifyEntry,
Action <ODataNestedResourceInfo> verifyNavigation)
{
var settings = new ODataMessageReaderSettings()
{
BaseUri = ServiceUri
};
settings.ShouldIncludeAnnotation = s => true;
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, Model);
ODataReader reader = isFeed
? messageReader.CreateODataResourceSetReader(expectedSet, expectedType)
: messageReader.CreateODataResourceReader(expectedSet, expectedType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceSetEnd:
{
if (verifyFeed != null)
{
verifyFeed((ODataResourceSet)reader.Item);
}
break;
}
case ODataReaderState.ResourceEnd:
{
if (verifyEntry != null && reader.Item != null)
{
verifyEntry((ODataResource)reader.Item);
}
break;
}
case ODataReaderState.NestedResourceInfoEnd:
{
if (verifyNavigation != null)
{
verifyNavigation((ODataNestedResourceInfo)reader.Item);
}
break;
}
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
/// <summary>
/// Creates and Wraps an ODataReader for feeds or entries.
/// </summary>
/// <param name="messageReader">The message reader.</param>
/// <param name="messageType">The message type.</param>
/// <param name="expectedType">The expected EDM type.</param>
/// <param name="responsePipeline">The data service response pipeling configuration object.</param>
/// <returns>A reader.</returns>
internal static ODataReaderWrapper Create(ODataMessageReader messageReader, ODataPayloadKind messageType, IEdmType expectedType, DataServiceClientResponsePipelineConfiguration responsePipeline)
{
IEdmStructuredType entityType = expectedType as IEdmStructuredType;
if (messageType == ODataPayloadKind.Resource)
{
return(new ODataReaderWrapper(messageReader.CreateODataResourceReader(entityType), responsePipeline));
}
return(new ODataReaderWrapper(messageReader.CreateODataResourceSetReader(entityType), responsePipeline));
}
public static async Task Main1(string[] args)
{
String path = @"C:\Users\kibandi\Desktop\SimpleExchangeOutput.txt";
using (StreamReader sr = File.OpenText(path))
{
IEdmModel model = null;
/*model = builder
* .BuildAddressType()
* .BuildCategoryType()
* .BuildCustomerType()
* .BuildDefaultContainer()
* .BuildCustomerSet()
* .GetModel();*/
Stream stream = sr.BaseStream;
ODataMessageReaderSettings settings = new ODataMessageReaderSettings();
IODataResponseMessage responseMessage = new InMemoryMessage {
Stream = stream
};
responseMessage.SetHeader("Content-Type", "application/json;odata.metadata=minimal;");
// ODataMessageReader reader = new ODataMessageReader((IODataResponseMessage)message, settings, GetEdmModel());
ODataMessageReader reader = new ODataMessageReader(responseMessage, settings, new EdmModel());
var oDataResourceReader = reader.CreateODataResourceReader();
var property = reader.ReadProperty();
//ODataStreamInfo odataStream = reader.Item as ODataStreamInfo;
stream.Position = 0;
//var asynchronousReader = reader.CreateODataAsynchronousReader();
IEdmStructuredType resource = new EdmComplexType("odata", "odata");
oDataResourceReader = reader.CreateODataResourceReader(resourceType: resource);
while (oDataResourceReader.Read())
{
var oItem = oDataResourceReader.Item;
Console.WriteLine(oItem.ToString());
}
//var responseMessage = asynchronousReader.CreateResponseMessage();
}
}
public void ModelReferenceWithExpandOption()
{
Dictionary <string, int[]> testCases = new Dictionary <string, int[]>()
{
{ "Trucks('Key1')?$select=Key,VehicleGPS&$expand=VehicleGPS", new int[] { 2, 1 } },
{ "Trucks('Key1')?$expand=HeadUnit,VehicleGPS", new int[] { 3, 4 } },
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var testCase in testCases)
{
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + testCase.Key, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
List <ODataResource> entries = new List <ODataResource>();
List <ODataNestedResourceInfo> navigationLinks = new List <ODataNestedResourceInfo>();
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entries.Add(reader.Item as ODataResource);
}
else if (reader.State == ODataReaderState.NestedResourceInfoEnd)
{
navigationLinks.Add(reader.Item as ODataNestedResourceInfo);
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
Assert.Equal(testCase.Value[0], entries.Where(e => e.TypeName.Contains("TruckType") ||
e.TypeName.Contains("VehicleGPSType") ||
e.TypeName.Contains("HeadUnitType")).Count());
Assert.Equal(testCase.Value[1], navigationLinks.Where(n => n.Url != null).Count());
}
}
}
}
}
public void TestCreateODataResourceReader_WithoutEntitySetOrType_DoesNotThrow()
{
// Arrange
IODataRequestMessage request = CreateRequest();
ODataMessageReaderSettings settings = CreateSettings();
IEdmModel model = CreateModel();
using (ODataMessageReader reader = new ODataMessageReader(request, settings, model))
{
// Act & Assert
ExceptionAssert.DoesNotThrow(() => reader.CreateODataResourceReader());
}
}
public void QueryEntityNavigationWithImplicitKeys()
{
// test Uri's
List <string> testCases = new List <string>
{
"Products(5)/Details(3)",
"Products(5)/Details(ProductDetailID=3)",
"Products(5)/Details(ProductID=5,ProductDetailID=3)",
"ProductDetails(ProductID=5,ProductDetailID=2)/Reviews(ReviewTitle='So so',RevisionID=1)",
"ProductDetails(ProductID=5,ProductDetailID=2)/Reviews(ProductDetailID=2,ReviewTitle='So so',RevisionID=1)",
"ProductDetails(ProductID=5,ProductDetailID=2)/Reviews(ProductDetailID=2,RevisionID=1,ProductID=5,ReviewTitle='So so')",
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var testCase in testCases)
{
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + testCase, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
ODataResource entry = null;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = reader.Item as ODataResource;
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
Assert.IsTrue(entry.Id.OriginalString.EndsWith("ProductDetails(ProductID=5,ProductDetailID=3)") ||
entry.Id.OriginalString.EndsWith("ProductReviews(ProductID=5,ProductDetailID=2,ReviewTitle='So%20so',RevisionID=1)"));
}
}
}
}
public void TestCreateODataResourceReader_WithEntitySetButWithoutType_DoesNotThrow()
{
// Arrange
IODataRequestMessage request = CreateRequest();
ODataMessageReaderSettings settings = CreateSettings();
IEdmModel model = CreateModel();
IEdmEntitySet entitySet = model.EntityContainer.EntitySets().First();
using (ODataMessageReader reader = new ODataMessageReader(request, settings, model))
{
// Act & Assert
ExceptionAssert.DoesNotThrow(() => reader.CreateODataResourceReader(entitySet, null));
}
}
public void EntryMetadataUrlRoundTrip()
{
var stream = new MemoryStream();
var writerRequestMemoryMessage = new InMemoryMessage();
writerRequestMemoryMessage.Stream = stream;
writerRequestMemoryMessage.SetHeader("Content-Type", "application/json");
var writerSettings = new ODataMessageWriterSettings()
{
Version = ODataVersion.V4, EnableMessageStreamDisposal = false
};
writerSettings.ODataUri = new ODataUri()
{
ServiceRoot = new Uri("http://christro.svc/")
};
var messageWriter = new ODataMessageWriter((IODataResponseMessage)writerRequestMemoryMessage, writerSettings, this.model);
var organizationSetWriter = messageWriter.CreateODataResourceWriter(this.organizationsSet);
var odataEntry = new ODataResource()
{
TypeName = ModelNamespace + ".Corporation"
};
odataEntry.Property("Id", 1);
odataEntry.Property("Name", "");
odataEntry.Property("TickerSymbol", "MSFT");
organizationSetWriter.WriteStart(odataEntry);
organizationSetWriter.WriteEnd();
var readerPayloadInput = Encoding.UTF8.GetString(stream.GetBuffer());
Console.WriteLine(readerPayloadInput);
var readerResponseMemoryMessage = new InMemoryMessage();
readerResponseMemoryMessage.Stream = new MemoryStream(stream.GetBuffer());
readerResponseMemoryMessage.SetHeader("Content-Type", "application/json");
var messageReader = new ODataMessageReader((IODataResponseMessage)readerResponseMemoryMessage, new ODataMessageReaderSettings()
{
MaxProtocolVersion = ODataVersion.V4, EnableMessageStreamDisposal = false
}, this.model);
var organizationReader = messageReader.CreateODataResourceReader(this.organizationsSet, this.organizationsSet.EntityType());
organizationReader.Read().Should().Be(true);
organizationReader.Item.As <ODataResource>();
}
