public async Task NextPageLink()
{
String request = "OrderItems?$orderby=Id&$count=true";
ODataUri odataUri = Fixture.ParseUri(request);
var parser = new OeParser(odataUri.ServiceRoot, Fixture.OeDataAdapter, Fixture.EdmModel);
var uri = new Uri(odataUri.ServiceRoot, request);
OeRequestHeaders requestHeaders = OeRequestHeaders.JsonDefault.SetMaxPageSize(2);
long count = -1;
var fromOe = new List<Object>();
do
{
var response = new MemoryStream();
await parser.ExecuteGetAsync(uri, requestHeaders, response, CancellationToken.None).ConfigureAwait(false);
var reader = new ResponseReader(Fixture.EdmModel, Fixture.OeDataAdapter);
response.Position = 0;
List<Object> result = reader.Read(response).Cast<Object>().ToList();
Assert.InRange(result.Count, 0, requestHeaders.MaxPageSize);
fromOe.AddRange(result);
if (count < 0)
count = reader.ResourceSet.Count.GetValueOrDefault();
uri = reader.ResourceSet.NextPageLink;
}
while (uri != null);
Assert.Equal(count, fromOe.Count);
IList fromDb;
using (var context = Fixture.CreateContext())
fromDb = context.OrderItems.OrderBy(i => i.Id).ToList();
TestHelper.Compare(fromDb, fromOe, null);
}
private static OeRequestHeaders GetRequestHeaders(HttpRequestHeaders requestHeaders, HttpResponse httpResponse)
{
((IDictionary <String, StringValues>)requestHeaders).TryGetValue("Prefer", out StringValues preferHeader);
var headers = OeRequestHeaders.Parse(requestHeaders.HeaderAccept, preferHeader);
return(new OeHttpRequestHeaders(headers, httpResponse));
}
private async Task InvokeApi(HttpContext httpContext)
{
httpContext.Request.Headers.TryGetValue("Prefer", out StringValues preferHeader);
OeRequestHeaders headers = OeRequestHeaders.Parse(httpContext.Request.Headers["Accept"], preferHeader);
Uri baseUri = UriHelper.GetBaseUri(httpContext.Request);
Uri requestUri = UriHelper.GetUri(httpContext.Request);
if (HttpMethods.IsGet(httpContext.Request.Method))
{
var parser = new OeParser(baseUri, EdmModel, GetModelBoundProvider(httpContext), OeParser.ServiceProvider);
await parser.ExecuteGetAsync(requestUri, new OeHttpRequestHeaders(headers, httpContext.Response),
httpContext.Response.Body, httpContext.RequestAborted).ConfigureAwait(false);
}
else if (HttpMethods.IsPost(httpContext.Request.Method) ||
HttpMethods.IsPut(httpContext.Request.Method) ||
HttpMethods.IsPatch(httpContext.Request.Method) ||
HttpMethods.IsDelete(httpContext.Request.Method))
{
ODataUri odataUri = OeParser.ParseUri(EdmModel, baseUri, requestUri, OeParser.ServiceProvider);
if (odataUri.Path.LastSegment is OperationImportSegment)
{
var parser = new OeParser(baseUri, EdmModel, GetModelBoundProvider(httpContext), OeParser.ServiceProvider);
await parser.ExecuteOperationAsync(odataUri, new OeHttpRequestHeaders(headers, httpContext.Response),
httpContext.Request.Body, httpContext.Response.Body, httpContext.RequestAborted).ConfigureAwait(false);
}
else
{
httpContext.Response.ContentType = httpContext.Request.ContentType;
var batchParser = new OeBatchParser(baseUri, EdmModel, OeParser.ServiceProvider);
await batchParser.ExecuteOperationAsync(requestUri, httpContext.Request.Body, httpContext.Response.Body,
httpContext.Request.ContentType, httpContext.Request.Method, httpContext.RequestAborted).ConfigureAwait(false);
}
}
}
private OeAsyncEnumerator ExecuteGet(IEdmModel refModel, ODataUri odataUri, OeRequestHeaders headers, CancellationToken cancellationToken, IQueryable source)
{
var parser = new OeGetParser(refModel);
_queryContext = parser.CreateQueryContext(odataUri, headers.MaxPageSize, headers.NavigationNextLink, headers.MetadataLevel);
if (odataUri.Path.LastSegment is OperationSegment)
{
return(OeOperationHelper.ApplyBoundFunction(_queryContext));
}
if (source != null)
{
_queryContext.QueryableSource = e => e == _queryContext.EntryFactory.EntitySet ? source : null;
}
if (_queryContext.IsCountSegment)
{
headers.ResponseContentType = OeRequestHeaders.TextDefault.ContentType;
int count = _dataAdapter.ExecuteScalar <int>(_dataContext, _queryContext);
return(new OeScalarAsyncEnumeratorAdapter(Task.FromResult((Object)count), cancellationToken));
}
return(_dataAdapter.ExecuteEnumerator(_dataContext, _queryContext, cancellationToken));
}
public async Task ExecuteAsync(ODataUri odataUri, OeRequestHeaders headers, Stream stream, CancellationToken cancellationToken)
{
OeQueryContext queryContext = CreateQueryContext(odataUri, headers.MaxPageSize, headers.NavigationNextLink, headers.MetadataLevel);
Db.OeDataAdapter dataAdapter = _edmModel.GetDataAdapter(queryContext.EdmModel.EntityContainer);
Object dataContext = null;
try
{
dataContext = dataAdapter.CreateDataContext();
if (queryContext.IsCountSegment)
{
headers.ResponseContentType = OeRequestHeaders.TextDefault.ContentType;
int count = dataAdapter.ExecuteScalar <int>(dataContext, queryContext);
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(count.ToString(CultureInfo.InvariantCulture));
stream.Write(buffer, 0, buffer.Length);
}
else
{
using (Db.OeAsyncEnumerator asyncEnumerator = dataAdapter.ExecuteEnumerator(dataContext, queryContext, cancellationToken))
await Writers.OeGetWriter.SerializeAsync(queryContext, asyncEnumerator, headers.ContentType, stream).ConfigureAwait(false);
}
}
finally
{
if (dataContext != null)
{
dataAdapter.CloseDataContext(dataContext);
}
}
}
public async Task ExecuteAsync(ODataUri odataUri, Stream requestStream, OeRequestHeaders headers, Stream responseStream, CancellationToken cancellationToken)
{
Object dataContext = null;
try
{
dataContext = _dataAdapter.CreateDataContext();
using (Db.OeAsyncEnumerator asyncEnumerator = GetAsyncEnumerator(odataUri, requestStream, headers, dataContext, out bool isScalar))
{
if (isScalar)
{
if (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false) && asyncEnumerator.Current != null)
{
headers.ResponseContentType = OeRequestHeaders.TextDefault.ContentType;
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(asyncEnumerator.Current.ToString());
responseStream.Write(buffer, 0, buffer.Length);
}
else
headers.ResponseContentType = null;
}
else
{
OeQueryContext queryContext = CreateQueryContext(odataUri, headers.MetadataLevel);
if (queryContext == null)
await WriteCollectionAsync(_edmModel, odataUri, asyncEnumerator, responseStream).ConfigureAwait(false);
else
await Writers.OeGetWriter.SerializeAsync(queryContext, asyncEnumerator, headers.ContentType, responseStream).ConfigureAwait(false);
}
}
}
finally
{
if (dataContext != null)
_dataAdapter.CloseDataContext(dataContext);
}
}
public async Task <OdataWcfQuery> Get(OdataWcfQuery request)
{
OeRequestHeaders headers = OeRequestHeaders.Parse(request.ContentType, request.Prefer);
headers.ResponseContentType = headers.ContentType;
Query.OeModelBoundProvider modelBoundProvider = null;
if (headers.MaxPageSize > 0)
{
var pageNextLinkModelBoundBuilder = new PageNextLinkModelBoundBuilder(_edmModel, false);
modelBoundProvider = pageNextLinkModelBoundBuilder.BuildProvider(headers.MaxPageSize, false);
}
var parser = new OeParser(_baseUri, _edmModel, modelBoundProvider);
String query = new StreamReader(request.Content).ReadToEnd();
var uri = new Uri(_baseUri, new Uri(query, UriKind.Relative));
var responseStream = new MemoryStream();
await parser.ExecuteGetAsync(uri, headers, responseStream, CancellationToken.None);
responseStream.Position = 0;
return(new OdataWcfQuery()
{
Content = responseStream,
ContentType = headers.ResponseContentType
});
}
private OeAsyncEnumerator GetAsyncEnumerator(IQueryable source = null, bool navigationNextLink = false, int?maxPageSize = null)
{
_httpContext.Response.RegisterForDispose(this);
ODataUri odataUri = OeParser.ParseUri(_edmModel, UriHelper.GetBaseUri(_httpContext.Request), UriHelper.GetUri(_httpContext.Request));
IEdmModel refModel = _edmModel.GetEdmModel(odataUri.Path);
_dataAdapter = refModel.GetDataAdapter(refModel.EntityContainer);
if (_dataContext == null)
{
_dataContext = _dataAdapter.CreateDataContext();
}
var requestHeaders = (HttpRequestHeaders)_httpContext.Request.Headers;
OeRequestHeaders headers = GetRequestHeaders(requestHeaders, _httpContext.Response, navigationNextLink, maxPageSize);
if (odataUri.Path.LastSegment is OperationImportSegment)
{
return(ExecutePost(refModel, odataUri, headers, _httpContext.RequestAborted, _httpContext.Request.Body));
}
else
{
return(ExecuteGet(refModel, odataUri, headers, _httpContext.RequestAborted, source));
}
}
public virtual async Task ExecuteResultAsync(ActionContext context)
{
var settings = new ODataMessageWriterSettings()
{
BaseUri = _odataUri.ServiceRoot,
EnableMessageStreamDisposal = false,
ODataUri = _odataUri,
Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
var requestHeaders = OeRequestHeaders.Parse(context.HttpContext.Request.Headers["Accept"], context.HttpContext.Request.Headers["Prefer"]);
if (requestHeaders.MaxPageSize > 0 && PageSize == 0)
{
PageSize = requestHeaders.MaxPageSize;
}
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(context.HttpContext.Response.Body, context.HttpContext.Request.ContentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, _edmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
IEdmEntityType entityType = _resultEntitySet.EntityType();
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(_resultEntitySet, entityType);
await SerializeAsync(writer, requestHeaders.MetadataLevel);
}
}
public static int GetMaxPageSize(IDictionary <String, StringValues> requestHeaders)
{
requestHeaders.TryGetValue("Prefer", out StringValues preferHeader);
var headers = OeRequestHeaders.Parse(requestHeaders["Accept"], preferHeader);
return(headers.MaxPageSize);
}
public async Task NavigationNextPageLink()
{
String request = "Orders?$expand=Items($filter=Count gt 0 or Count eq null;$orderby=Id;$count=true)&$orderby=Id&$count=true";
ODataUri odataUri = Fixture.ParseUri(request);
var parser = new OeParser(odataUri.ServiceRoot, Fixture.OeDataAdapter, Fixture.EdmModel);
var requestUri = new Uri(odataUri.ServiceRoot, request);
Uri uri = requestUri;
OeRequestHeaders requestHeaders = OeRequestHeaders.JsonDefault.SetMaxPageSize(1).SetNavigationNextLink(true);
long count = -1;
var fromOe = new List<Object>();
do
{
var response = new MemoryStream();
await parser.ExecuteGetAsync(uri, requestHeaders, response, CancellationToken.None).ConfigureAwait(false);
response.Position = 0;
var reader = new ResponseReader(Fixture.EdmModel, Fixture.OeDataAdapter);
List<Object> result = reader.Read(response).Cast<Object>().ToList();
Assert.InRange(result.Count, 0, requestHeaders.MaxPageSize);
fromOe.AddRange(result);
var navigationPropertyParser = new OeParser(odataUri.ServiceRoot, Fixture.OeDataAdapter, Fixture.EdmModel);
foreach (dynamic order in result)
{
var navigationProperty = (IEnumerable)order.Items;
ODataResourceSetBase resourceSet = reader.GetResourceSet(navigationProperty);
var navigationPropertyResponse = new MemoryStream();
await navigationPropertyParser.ExecuteGetAsync(resourceSet.NextPageLink, OeRequestHeaders.JsonDefault, navigationPropertyResponse, CancellationToken.None).ConfigureAwait(false);
navigationPropertyResponse.Position = 0;
var navigationPropertyReader = new ResponseReader(Fixture.EdmModel, Fixture.OeDataAdapter);
foreach (dynamic orderItem in navigationPropertyReader.Read(navigationPropertyResponse))
order.Items.Add(orderItem);
Assert.Equal(navigationPropertyReader.ResourceSet.Count, order.Items.Count);
}
if (count < 0)
count = reader.ResourceSet.Count.GetValueOrDefault();
uri = reader.ResourceSet.NextPageLink;
}
while (uri != null);
Assert.Equal(count, fromOe.Count);
var exprectedResponse = new MemoryStream();
var expectedParser = new OeParser(odataUri.ServiceRoot, Fixture.OeDataAdapter, Fixture.EdmModel);
await expectedParser.ExecuteGetAsync(requestUri, OeRequestHeaders.JsonDefault, exprectedResponse, CancellationToken.None).ConfigureAwait(false);
exprectedResponse.Position = 0;
var exprectedReader = new ResponseReader(Fixture.EdmModel, Fixture.OeDataAdapter);
List<Object> expectedResult = exprectedReader.Read(exprectedResponse).Cast<Object>().ToList();
TestHelper.Compare(expectedResult, fromOe, null);
}
protected async Task Get(HttpContext httpContext, Stream responseStream, bool navigationNextLink = false, int?maxPageSize = null)
{
var requestHeaders = (FrameRequestHeaders)httpContext.Request.Headers;
OeRequestHeaders headers = GetRequestHeaders(requestHeaders, httpContext.Response, navigationNextLink, maxPageSize);
var parser = new OeParser(UriHelper.GetBaseUri(httpContext.Request), _dataAdapter, _edmModel);
await parser.ExecuteGetAsync(UriHelper.GetUri(httpContext.Request), headers, responseStream, httpContext.RequestAborted);
}
public static async Task Get(HttpContext httpContext, Query.OeModelBoundProvider?modelBoundProvider = null)
{
OeRequestHeaders headers = GetRequestHeaders(httpContext.Request.Headers, httpContext.Response);
var edmModel = (IEdmModel)httpContext.RequestServices.GetService(typeof(IEdmModel));
var parser = new OeParser(UriHelper.GetBaseUri(httpContext.Request), edmModel, modelBoundProvider, null);
await parser.ExecuteGetAsync(UriHelper.GetUri(httpContext.Request), headers, httpContext.Response.Body, httpContext.RequestAborted).ConfigureAwait(false);
}
private async Task InvokeApi(HttpContext httpContext)
{
httpContext.Request.Headers.TryGetValue("Prefer", out StringValues preferHeader);
OeRequestHeaders headers = OeRequestHeaders.Parse(httpContext.Request.Headers["Accept"], preferHeader);
var parser = new OeParser(UriHelper.GetBaseUri(httpContext.Request), EdmModel, GetModelBoundProvider(httpContext), OeParser.ServiceProvider);
await parser.ExecuteGetAsync(UriHelper.GetUri(httpContext.Request), new OeHttpRequestHeaders(headers, httpContext.Response),
httpContext.Response.Body, CancellationToken.None).ConfigureAwait(false);
}
public static async Task Get(HttpContext httpContext, bool navigationNextLink = false, int?maxPageSize = null)
{
var requestHeaders = (HttpRequestHeaders)httpContext.Request.Headers;
OeRequestHeaders headers = GetRequestHeaders(requestHeaders, httpContext.Response, navigationNextLink, maxPageSize);
var edmModel = (IEdmModel)httpContext.RequestServices.GetService(typeof(IEdmModel));
var parser = new OeParser(UriHelper.GetBaseUri(httpContext.Request), edmModel);
await parser.ExecuteGetAsync(UriHelper.GetUri(httpContext.Request), headers, httpContext.Response.Body, httpContext.RequestAborted);
}
private async Task Invoke(HttpContext httpContext, PathString remaining)
{
var requestHeaders = (HttpRequestHeaders)httpContext.Request.Headers;
((IDictionary <String, StringValues>)requestHeaders).TryGetValue("Prefer", out StringValues preferHeader);
OeRequestHeaders headers = OeRequestHeaders.Parse(requestHeaders.HeaderAccept, preferHeader);
var parser = new OeParser(UriHelper.GetBaseUri(httpContext.Request), _edmModel);
await parser.ExecuteGetAsync(UriHelper.GetUri(httpContext.Request), new OeHttpRequestHeaders(headers, httpContext.Response), httpContext.Response.Body, CancellationToken.None);
}
public async Task ExecuteAsync(ODataUri odataUri, Stream?requestStream, OeRequestHeaders headers, Stream responseStream, CancellationToken cancellationToken)
{
Object?dataContext = null;
try
{
dataContext = _dataAdapter.CreateDataContext();
IAsyncEnumerator <Object>?asyncEnumerator = null;
try
{
asyncEnumerator = GetAsyncEnumerable(odataUri, requestStream, headers, dataContext, cancellationToken, out bool isScalar).GetAsyncEnumerator(cancellationToken);
if (isScalar)
{
if (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false) && asyncEnumerator.Current != null)
{
headers.ResponseContentType = OeRequestHeaders.TextDefault.ContentType;
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(asyncEnumerator.Current.ToString());
await responseStream.WriteAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
}
else
{
headers.ResponseContentType = null;
}
}
else
{
var importSegment = (OperationImportSegment)odataUri.Path.FirstSegment;
IEdmEntitySet?entitySet = OeOperationHelper.GetEntitySet(importSegment.OperationImports.Single());
if (entitySet == null)
{
await WriteCollectionAsync(_edmModel, odataUri, asyncEnumerator, responseStream).ConfigureAwait(false);
}
else
{
OeQueryContext queryContext = CreateQueryContext(odataUri, entitySet, headers.MetadataLevel);
await Writers.OeGetWriter.SerializeAsync(queryContext, asyncEnumerator, headers.ContentType, responseStream, _serviceProvider, cancellationToken).ConfigureAwait(false);
}
}
}
finally
{
if (asyncEnumerator != null)
{
await asyncEnumerator.DisposeAsync().ConfigureAwait(false);
}
}
}
finally
{
if (dataContext != null)
{
_dataAdapter.CloseDataContext(dataContext);
}
}
}
private async Task Invoke(HttpContext httpContext, PathString remaining)
{
var requestHeaders = (FrameRequestHeaders)httpContext.Request.Headers;
httpContext.Response.ContentType = requestHeaders.HeaderAccept;
var uri = new Uri(_baseUri.OriginalString + remaining + httpContext.Request.QueryString);
OeRequestHeaders headers = OeRequestHeaders.Parse(requestHeaders.HeaderAccept);
var parser = new OeParser(_baseUri, _dataAdapter, _edmModel);
await parser.ExecuteQueryAsync(uri, headers, httpContext.Response.Body, CancellationToken.None);
}
private static OeRequestHeaders GetRequestHeaders(HttpRequestHeaders requestHeaders, HttpResponse httpResponse, bool navigationNextLink, int?maxPageSize)
{
((IDictionary <String, StringValues>)requestHeaders).TryGetValue("Prefer", out StringValues preferHeader);
var headers = OeRequestHeaders.Parse(requestHeaders.HeaderAccept, preferHeader).SetNavigationNextLink(navigationNextLink);
if (maxPageSize != null)
{
headers = headers.SetMaxPageSize(maxPageSize.Value);
}
return(new OeHttpRequestHeaders(headers, httpResponse));
}
public async Task <Stream> Get(string query, String acceptHeader)
{
OeRequestHeaders headers = OeRequestHeaders.Parse(acceptHeader);
var parser = new OeParser(_baseUri, DataAdapter, _edmModel);
var uri = new Uri(_baseUri, new Uri(query, UriKind.Relative));
var responseStream = new MemoryStream();
await parser.ExecuteQueryAsync(uri, headers, responseStream, CancellationToken.None);
responseStream.Position = 0;
return(responseStream);
}
private OeAsyncEnumerator Execute(OeRequestHeaders headers, Stream responseStream, CancellationToken cancellationToken)
{
_dataContext = _dataAdapter.CreateDataContext();
if (_queryContext.IsCountSegment)
{
headers.ResponseContentType = OeRequestHeaders.TextDefault.ContentType;
int count = _dataAdapter.ExecuteScalar <int>(_dataContext, _queryContext);
return(new OeScalarAsyncEnumeratorAdapter(Task.FromResult((Object)count), cancellationToken));
}
return(_dataAdapter.ExecuteEnumerator(_dataContext, _queryContext, cancellationToken));
}
private OeAsyncEnumerator ExecutePost(IEdmModel refModel, ODataUri odataUri, OeRequestHeaders headers, CancellationToken cancellationToken, Stream requestStream)
{
_odataUri = odataUri;
var parser = new OePostParser(refModel);
OeAsyncEnumerator asyncEnumerator = parser.GetAsyncEnumerator(odataUri, requestStream, headers, _dataContext, out bool isScalar);
if (!isScalar)
{
_queryContext = parser.CreateQueryContext(odataUri, headers.MetadataLevel);
}
return(asyncEnumerator);
}
private OeAsyncEnumerator Execute(ODataUri odataUri, Stream requestStream, OeRequestHeaders headers, CancellationToken cancellationToken)
{
Object dataContext = _dataAdapter.CreateDataContext();
var parser = new OePostParser(_dataAdapter, _edmModel);
OeAsyncEnumerator asyncEnumerator = parser.GetAsyncEnumerator(odataUri, requestStream, headers, dataContext, out Type returnClrType);
if (returnClrType != null && !(returnClrType.IsPrimitive || returnClrType == typeof(String)))
{
_queryContext = parser.CreateQueryContext(odataUri, headers.MetadataLevel, returnClrType);
}
return(asyncEnumerator);
}
private bool CompareHeaders(OeRequestHeaders headers1, OeRequestHeaders headers2)
{
if (headers1 == headers2)
{
return(true);
}
if (headers1 == null || headers2 == null)
{
return(false);
}
return(headers1.Charset == headers2.Charset &&
headers1.ContentType == headers2.ContentType &&
headers1.MetadataLevel == headers2.MetadataLevel &&
headers1.Streaming == headers2.Streaming);
}
public async Task ExecuteAsync(ODataUri odataUri, OeRequestHeaders headers, Stream stream, CancellationToken cancellationToken)
{
if (_modelBoundProvider != null)
{
_modelBoundProvider.Validate(_edmModel, odataUri);
}
var queryContext = new OeQueryContext(_edmModel, odataUri)
{
MetadataLevel = headers.MetadataLevel
};
if (queryContext.ODataUri.Path.LastSegment is OperationSegment)
{
using (IAsyncEnumerator <Object> asyncEnumerator = OeOperationHelper.ApplyBoundFunction(queryContext).GetEnumerator())
await Writers.OeGetWriter.SerializeAsync(queryContext, asyncEnumerator, headers.ContentType, stream, cancellationToken).ConfigureAwait(false);
return;
}
Object dataContext = null;
Db.OeDataAdapter dataAdapter = queryContext.EdmModel.GetDataAdapter(queryContext.EdmModel.EntityContainer);
try
{
dataContext = dataAdapter.CreateDataContext();
if (odataUri.Path.LastSegment is CountSegment)
{
headers.ResponseContentType = OeRequestHeaders.TextDefault.ContentType;
int count = dataAdapter.ExecuteScalar <int>(dataContext, queryContext);
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(count.ToString(CultureInfo.InvariantCulture));
stream.Write(buffer, 0, buffer.Length);
}
else
{
using (IAsyncEnumerator <Object> asyncEnumerator = dataAdapter.Execute(dataContext, queryContext).GetEnumerator())
await Writers.OeGetWriter.SerializeAsync(queryContext, asyncEnumerator, headers.ContentType, stream, cancellationToken).ConfigureAwait(false);
}
}
finally
{
if (dataContext != null)
{
dataAdapter.CloseDataContext(dataContext);
}
}
}
public async Task <OdataWcfQuery> Get(OdataWcfQuery request)
{
OeRequestHeaders headers = OeRequestHeaders.Parse(request.ContentType, request.Prefer);
headers.ResponseContentType = headers.ContentType;
var parser = new OeParser(_baseUri, _edmModel);
String query = new StreamReader(request.Content).ReadToEnd();
var uri = new Uri(_baseUri, new Uri(query, UriKind.Relative));
var responseStream = new MemoryStream();
await parser.ExecuteGetAsync(uri, headers, responseStream, CancellationToken.None);
responseStream.Position = 0;
return(new OdataWcfQuery()
{
Content = responseStream,
ContentType = headers.ResponseContentType
});
}
protected OeAsyncEnumerator GetAsyncEnumerator(HttpContext httpContext, Stream responseStream, bool navigationNextLink = false, int?maxPageSize = null)
{
var odataParser = new ODataUriParser(_edmModel, UriHelper.GetBaseUri(httpContext.Request), UriHelper.GetUri(httpContext.Request));
odataParser.Resolver.EnableCaseInsensitive = true;
ODataUri odataUri = odataParser.ParseUri();
var requestHeaders = (FrameRequestHeaders)httpContext.Request.Headers;
OeRequestHeaders headers = GetRequestHeaders(requestHeaders, httpContext.Response, navigationNextLink, maxPageSize);
if (odataUri.Path.LastSegment is OperationImportSegment)
{
return(Execute(odataUri, httpContext.Request.Body, headers, httpContext.RequestAborted));
}
var getParser = new OeGetParser(_dataAdapter, _edmModel);
_queryContext = getParser.CreateQueryContext(odataUri, headers.MaxPageSize, headers.NavigationNextLink, headers.MetadataLevel);
return(Execute(headers, responseStream, httpContext.RequestAborted));
}
public async Task ExecuteResultAsync(ActionContext context)
{
var settings = new ODataMessageWriterSettings()
{
BaseUri = _odataUri.ServiceRoot,
EnableMessageStreamDisposal = false,
ODataUri = _odataUri,
Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
var requestHeaders = OeRequestHeaders.Parse(context.HttpContext.Request.Headers["Accept"], context.HttpContext.Request.Headers["Prefer"]);
_metadataLevel = requestHeaders.MetadataLevel;
if (requestHeaders.MaxPageSize > 0 && PageSize == 0)
{
PageSize = requestHeaders.MaxPageSize;
}
IODataResponseMessage responseMessage = new OeInMemoryMessage(context.HttpContext.Response.Body, context.HttpContext.Request.ContentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, _edmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
IEdmEntitySet edmEntitySet = null;
IEdmEntityType edmEntityType = null;
foreach (IEdmEntitySet element in _edmModel.EntityContainer.EntitySets())
{
edmEntityType = element.EntityType();
if (edmEntityType.FullName() == typeof(T).FullName)
{
edmEntitySet = element;
break;
}
}
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(edmEntitySet, edmEntityType);
await SerializeAsync(writer);
}
}
private IAsyncEnumerable <Object> GetAsyncEnumerator(IQueryable?source = null)
{
_httpContext.Response.RegisterForDispose(this);
ODataUri odataUri = OeParser.ParseUri(_edmModel, UriHelper.GetBaseUri(_httpContext.Request), UriHelper.GetUri(_httpContext.Request));
IEdmModel refModel = _edmModel.GetEdmModel(odataUri.Path);
_dataAdapter = refModel.GetDataAdapter(refModel.EntityContainer);
if (_dataContext == null)
{
_dataContext = _dataAdapter.CreateDataContext();
}
OeRequestHeaders headers = GetRequestHeaders(_httpContext.Request.Headers, _httpContext.Response);
if (odataUri.Path.LastSegment is OperationImportSegment)
{
return(ExecutePost(refModel, odataUri, headers, _httpContext.Request.Body, _httpContext.RequestAborted));
}
else
{
return(ExecuteGet(refModel, odataUri, headers, source));
}
}
public OeHttpRequestHeaders(OeRequestHeaders headers, HttpResponse response) : base(headers)
{
_response = response;
_response.ContentType = base.ContentType;
}
