public virtual async Task ExecuteResultAsync(ActionContext context)
{
HttpContext httpContext = context.HttpContext;
OeEntryFactory entryFactoryFromTuple = _queryContext.EntryFactory.GetEntryFactoryFromTuple(_queryContext.EdmModel, _queryContext.ODataUri.OrderBy);
await Writers.OeGetWriter.SerializeAsync(_queryContext, (IAsyncEnumerator <Object>) _entities,
httpContext.Request.ContentType, httpContext.Response.Body, entryFactoryFromTuple, httpContext.RequestAborted);
}
private static Object CreateNestedEntity(OeEntryFactory entryFactory, Object value)
{
Object navigationValue = entryFactory.GetValue(value, out int?dummy);
if (navigationValue == null)
{
return(null);
}
if (entryFactory.ResourceInfo.IsCollection.GetValueOrDefault())
{
foreach (Object entity in (IEnumerable)navigationValue)
{
foreach (OeEntryFactory navigationLink in entryFactory.NavigationLinks)
{
SetNavigationProperty(navigationLink, value, entity);
}
}
}
else
{
foreach (OeEntryFactory navigationLink in entryFactory.NavigationLinks)
{
SetNavigationProperty(navigationLink, value, navigationValue);
}
}
return(navigationValue);
}
public static async Task SerializeAsync(Uri baseUri, OeParseUriContext parseUriContext, Db.OeEntityAsyncEnumerator asyncEnumerator, Stream stream)
{
IEdmModel edmModel = parseUriContext.EdmModel;
OeEntryFactory entryFactory = parseUriContext.EntryFactory;
String contentType = parseUriContext.Headers.ContentType;
var settings = new ODataMessageWriterSettings()
{
BaseUri = baseUri,
EnableMessageStreamDisposal = false,
ODataUri = parseUriContext.ODataUri,
Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, contentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, edmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(entryFactory.EntitySet, entryFactory.EntityType);
var getWriter = new GetWriter(baseUri, parseUriContext.Headers.MetadataLevel, writer);
await getWriter.SerializeAsync(entryFactory, asyncEnumerator, stream);
}
}
public static async Task SerializeAsync(OeQueryContext queryContext, IAsyncEnumerator <Object> asyncEnumerator,
String contentType, Stream stream, OeEntryFactory entryFactory, IServiceProvider?serviceProvider, CancellationToken cancellationToken)
{
var settings = new ODataMessageWriterSettings()
{
BaseUri = queryContext.ODataUri.ServiceRoot,
EnableMessageStreamDisposal = false,
ODataUri = queryContext.ODataUri,
Validations = ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
if (serviceProvider != null)
{
serviceProvider = new ServiceProvider(serviceProvider, settings);
}
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(stream, contentType, serviceProvider);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, queryContext.EdmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
ODataWriter writer = await messageWriter.CreateODataResourceSetWriterAsync(entryFactory.EntitySet, entryFactory.EdmEntityType);
var odataWriter = new OeODataWriter(queryContext, writer, cancellationToken);
await odataWriter.WriteAsync(entryFactory, asyncEnumerator).ConfigureAwait(false);
}
}
public OeGraphqlAsyncEnumerator(Db.OeAsyncEnumerator asyncEnumerator, OeEntryFactory entryFactory, OeQueryContext queryContext)
{
_dispose = asyncEnumerator;
_dbEnumerator = new Db.OeDbEnumerator(asyncEnumerator, entryFactory);
_queryContext = queryContext;
_isFirstMoveNext = true;
}
public async Task SerializeAsync(OeEntryFactory entryFactory, Db.OeAsyncEnumerator asyncEnumerator, OeQueryContext queryContext)
{
var resourceSet = new ODataResourceSet()
{
Count = asyncEnumerator.Count
};
_writer.WriteStart(resourceSet);
Object buffer = null;
int count = 0;
var dbEnumerator = entryFactory.IsTuple ?
(Db.IOeDbEnumerator) new Db.OeDbEnumerator(asyncEnumerator, entryFactory) : new Db.OeEntityDbEnumerator(asyncEnumerator, entryFactory);
while (await dbEnumerator.MoveNextAsync().ConfigureAwait(false))
{
Object value = dbEnumerator.Current;
await WriteEntry(dbEnumerator, value, _queryContext.NavigationNextLink).ConfigureAwait(false);
count++;
buffer = dbEnumerator.ClearBuffer();
}
if (queryContext.PageSize > 0 && count > 0 && (asyncEnumerator.Count ?? Int32.MaxValue) > count)
{
resourceSet.NextPageLink = BuildNextPageLink(queryContext, buffer);
}
_writer.WriteEnd();
}
private async Task SerializeBuffered(OeEntryFactory entryFactory, Db.OeEntityAsyncEnumerator asyncEnumerator, Stream stream)
{
var values = new List <Object>();
while (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false))
{
values.Add(asyncEnumerator.Current);
}
var resourceSet = new ODataResourceSet();
resourceSet.Count = values.Count;
Writer.WriteStart(resourceSet);
foreach (Object value in values)
{
int? dummy;
ODataResource entry = CreateEntry(entryFactory, entryFactory.GetValue(value, out dummy));
Writer.WriteStart(entry);
foreach (OeEntryFactory navigationLink in entryFactory.NavigationLinks)
{
WriteNavigationLink(value, navigationLink);
}
Writer.WriteEnd();
}
Writer.WriteEnd();
}
private static void SetNavigationProperty(OeEntryFactory navigationLink, Object value, Object ownerEntry)
{
Object navigationValue = CreateNestedEntity(navigationLink, value);
PropertyInfo propertyInfo = ownerEntry.GetType().GetProperty(navigationLink.ResourceInfo.Name);
propertyInfo.SetValue(ownerEntry, navigationValue);
}
public async Task WriteAsync(OeEntryFactory entryFactory, IAsyncEnumerator <Object> asyncEnumerator)
{
var resourceSet = new ODataResourceSet()
{
Count = _queryContext.TotalCountOfItems
};
await _writer.WriteStartAsync(resourceSet).ConfigureAwait(false);
Object?rawValue = null;
int readCount = 0;
Db.IOeDbEnumerator dbEnumerator = entryFactory.IsTuple ?
(Db.IOeDbEnumerator) new Db.OeDbEnumerator(asyncEnumerator, entryFactory) : new Db.OeEntityDbEnumerator(asyncEnumerator, entryFactory);
while (await dbEnumerator.MoveNextAsync().ConfigureAwait(false))
{
await WriteEntry(dbEnumerator, dbEnumerator.Current).ConfigureAwait(false);
readCount++;
rawValue = dbEnumerator.RawValue;
dbEnumerator.ClearBuffer();
}
if (rawValue != null)
{
var nextPageLinkBuilder = new OeNextPageLinkBuilder(_queryContext);
resourceSet.NextPageLink = nextPageLinkBuilder.GetNextPageLinkRoot(entryFactory, readCount, _queryContext.TotalCountOfItems, rawValue);
}
await _writer.WriteEndAsync().ConfigureAwait(false);
}
public OeQueryCacheItem(Object query, MethodCallExpression countExpression, OeEntryFactory entryFactory, OePropertyAccessor[] skipTokenAccessors)
{
Query = query;
CountExpression = countExpression;
EntryFactory = entryFactory;
SkipTokenAccessors = skipTokenAccessors;
}
public OeGraphqlAsyncEnumerator(IAsyncEnumerator <Object> asyncEnumerator, OeEntryFactory entryFactory, CancellationToken cancellationToken)
{
_dbEnumerator = new Db.OeDbEnumerator(asyncEnumerator, entryFactory);
_cancellationToken = cancellationToken;
_isFirstMoveNext = true;
Current = NullCurrent;
}
public Uri GetNextPageLinkRoot(OeEntryFactory entryFactory, int readCount, int?totalCount, Object value)
{
if (readCount == 0)
{
return(null);
}
int pageSize = GetPageSizeRoot();
if (pageSize == 0)
{
return(null);
}
int restCount = GetRestCountRoot(readCount, totalCount);
if (restCount == 0)
{
return(null);
}
ODataUri nextOdataUri = _queryContext.ODataUri.Clone();
nextOdataUri.SelectAndExpand = _queryContext.ODataUri.SelectAndExpand;
nextOdataUri.ServiceRoot = null;
nextOdataUri.QueryCount = null;
nextOdataUri.Top = pageSize;
nextOdataUri.Skip = null;
nextOdataUri.SkipToken = OeSkipTokenParser.GetSkipToken(_queryContext.EdmModel, entryFactory.SkipTokenAccessors, value, restCount);
return(nextOdataUri.BuildUri(ODataUrlKeyDelimiter.Parentheses));
}
public OeEntityAsyncEnumerator(OeEntryFactory entryFactory, Db.OeAsyncEnumerator asyncEnumerator)
{
_entryFactory = entryFactory;
_asyncEnumerator = asyncEnumerator;
_isFirstMoveNext = true;
}
private static void SetOrderByProperties(OeEntryFactory entryFactory, OrderByClause?orderByClause, Object entity, Object?value)
{
int i = 0;
while (orderByClause != null)
{
var propertyAccessNode = (SingleValuePropertyAccessNode)orderByClause.Expression;
var properties = new List <IEdmProperty>()
{
propertyAccessNode.Property
};
if (propertyAccessNode.Source is SingleNavigationNode navigationNode)
{
properties.Add(navigationNode.NavigationProperty);
while (navigationNode.Source is SingleNavigationNode node)
{
navigationNode = node;
properties.Add(navigationNode.NavigationProperty);
}
}
Object?orderValue = entryFactory.SkipTokenAccessors[i++].GetValue(value);
SetPropertyValue(entity, properties, orderValue);
orderByClause = orderByClause.ThenBy;
}
}
public OeDbEnumerator(IAsyncEnumerator <Object> asyncEnumerator, OeEntryFactory entryFactory)
{
Context = new DataContext(asyncEnumerator);
EntryFactory = entryFactory;
_bufferPosition = -1;
}
public Expression Build(Expression source, OeQueryContext queryContext)
{
bool isBuild = false;
if (queryContext.ODataUri.Skip != null || queryContext.ODataUri.Top != null)
{
isBuild = true;
source = BuildSkipTakeSource(source, queryContext, _navigationItem);
}
if (queryContext.ODataUri.SelectAndExpand != null)
{
isBuild = true;
source = BuildSelect(queryContext.ODataUri.SelectAndExpand, source, queryContext.NavigationNextLink, false);
}
if (queryContext.ODataUri.Compute != null)
{
isBuild = true;
BuildCompute(queryContext.ODataUri.Compute);
}
source = BuildOrderBy(source, queryContext.ODataUri.OrderBy);
if (isBuild)
{
source = SelectStructuralProperties(source, _navigationItem);
source = CreateSelectExpression(source, _joinBuilder);
_entryFactory = CreateEntryFactory(_navigationItem, source);
}
return(source);
}
public Expression Build(Expression source, ApplyClause applyClause)
{
_aggProperties.Clear();
if (applyClause == null)
{
return(source);
}
foreach (TransformationNode transformation in applyClause.Transformations)
{
if (transformation is GroupByTransformationNode groupTransformation)
{
source = ApplyGroupBy(source, groupTransformation);
}
else if (transformation is FilterTransformationNode filterTransformation)
{
source = ApplyFilter(source, filterTransformation);
}
else if (transformation is ComputeTransformationNode computeTransformation)
{
source = ApplyCompute(source, computeTransformation);
}
else if (transformation is AggregateTransformationNode)
{
throw new NotSupportedException();
}
else
{
throw new NotSupportedException();
}
}
_entryFactory = CreateEntryFactory(_visitor.EdmModel, source, _visitor.Parameter.Type, _aggProperties);
return(source);
}
public QueryCacheItem(Object query, Expression countExpression, OeEntryFactory entryFactory, OePropertyAccessor[] skipTokenAccessors)
{
_query = query;
_countExpression = countExpression;
_entryFactory = entryFactory;
_skipTokenAccessors = skipTokenAccessors;
}
private async Task WriteNavigationNextLink(OeEntryFactory parentEntryFactory, ExpandedNavigationSelectItem item, Object value)
{
Uri?nextPageLink = new OeNextPageLinkBuilder(_queryContext).GetNavigationUri(parentEntryFactory, item, value);
if (nextPageLink == null)
{
return;
}
var segment = (NavigationPropertySegment)item.PathToNavigationProperty.LastSegment;
bool isCollection = segment.NavigationProperty.Type.IsCollection();
var resourceInfo = new ODataNestedResourceInfo()
{
IsCollection = isCollection,
Name = segment.NavigationProperty.Name
};
await _writer.WriteStartAsync(resourceInfo).ConfigureAwait(false);
if (isCollection)
{
var resourceSet = new ODataResourceSet()
{
NextPageLink = nextPageLink
};
await _writer.WriteStartAsync(resourceSet).ConfigureAwait(false);
await _writer.WriteEndAsync().ConfigureAwait(false);
}
else
{
resourceInfo.Url = nextPageLink;
}
await _writer.WriteEndAsync().ConfigureAwait(false);
}
private static OeEntryFactory CreateEntryFactory(IEdmModel edmModel, OeSelectItem root, Type clrType)
{
ParameterExpression parameter = Expression.Parameter(typeof(Object));
UnaryExpression typedParameter = Expression.Convert(parameter, clrType);
if (root.HasNavigationItems)
{
List <OeSelectItem> navigationItems = FlattenNavigationItems(root, false);
IReadOnlyList <MemberExpression> navigationProperties = OeExpressionHelper.GetPropertyExpressions(typedParameter);
for (int i = navigationItems.Count - 1; i >= 0; i--)
{
OeSelectItem navigationItem = navigationItems[i];
OeEntryFactory[] nestedNavigationLinks = GetNestedNavigationLinks(navigationItem);
OeEntryFactory entryFactory;
Type clrEntityType = edmModel.GetClrType(navigationItem.EntitySet);
OePropertyAccessor[] accessors = GetAccessors(navigationProperties[i].Type, navigationItem.EntitySet, navigationItem.SelectItems);
LambdaExpression linkAccessor = Expression.Lambda(navigationProperties[i], parameter);
if (i == 0)
{
entryFactory = OeEntryFactory.CreateEntryFactoryParent(clrEntityType, navigationItem.EntitySet, accessors, nestedNavigationLinks, linkAccessor);
}
else
{
var resourceInfo = new ODataNestedResourceInfo()
{
IsCollection = navigationItem.EdmProperty.Type.Definition is EdmCollectionType,
Name = navigationItem.EdmProperty.Name
};
entryFactory = OeEntryFactory.CreateEntryFactoryNested(clrEntityType, navigationItem.EntitySet, accessors, nestedNavigationLinks, linkAccessor, resourceInfo);
entryFactory.CountOption = navigationItem.ExpandedNavigationSelectItem.CountOption;
}
navigationItem.EntryFactory = entryFactory;
}
}
else
{
IReadOnlyList <MemberExpression> propertyExpressions = OeExpressionHelper.GetPropertyExpressions(typedParameter);
OePropertyAccessor[] accessors;
if (root.SelectItems.Count == 0)
{
accessors = OePropertyAccessor.CreateFromType(typedParameter.Type, root.EntitySet);
}
else
{
var accessorList = new List <OePropertyAccessor>(root.SelectItems.Count);
for (int i = 0; i < root.SelectItems.Count; i++)
{
OeSelectItem selectItem = root.SelectItems[i];
accessorList.Add(OePropertyAccessor.CreatePropertyAccessor(selectItem.EdmProperty, propertyExpressions[i], parameter, selectItem.SkipToken));
}
accessors = accessorList.ToArray();
}
Type clrEntityType = edmModel.GetClrType(root.EntitySet);
root.EntryFactory = OeEntryFactory.CreateEntryFactory(clrEntityType, root.EntitySet, accessors);
}
return(root.EntryFactory);
}
private OeEntityAsyncEnumeratorAdapter(OeAsyncEnumerator asyncEnumerator, OeEntryFactory entryFactory, OeQueryContext queryContext)
: base(asyncEnumerator.CancellationToken)
{
_asyncEnumerator = asyncEnumerator;
_dbEnumerator = new OeDbEnumerator(asyncEnumerator, entryFactory);
_queryContext = queryContext;
_isFirstMoveNext = true;
base.Count = asyncEnumerator.Count;
}
private ODataResource CreateEntry(OeEntryFactory entryFactory, Object entity)
{
ODataResource entry = entryFactory.CreateEntry(entity);
if (MetadataLevel == OeMetadataLevel.Full)
{
entry.Id = OeUriHelper.ComputeId(BaseUri, entryFactory.EntitySet, entry);
}
return(entry);
}
private ODataResource CreateEntry(OeEntryFactory entryFactory, Object entity)
{
ODataResource entry = entryFactory.CreateEntry(entity);
if (QueryContext.MetadataLevel == OeMetadataLevel.Full)
{
entry.Id = OeUriHelper.ComputeId(QueryContext.ODataUri.ServiceRoot, entryFactory.EntitySet, entry);
}
return(entry);
}
public async Task SerializeAsync(OeEntryFactory entryFactory, Db.OeEntityAsyncEnumerator asyncEnumerator, Stream stream)
{
if (entryFactory.CountOption.GetValueOrDefault())
{
await SerializeBuffered(entryFactory, asyncEnumerator, stream);
}
else
{
await SerializeUnbuffered(entryFactory, asyncEnumerator, stream);
}
}
private void WriteNavigationLink(Object value, OeEntryFactory entryFactory, ODataResource parentEntry, IEdmEntitySet parentEntitySet)
{
Writer.WriteStart(entryFactory.ResourceInfo);
Object navigationValue = entryFactory.GetValue(value, out int?count);
if (navigationValue == null)
{
Writer.WriteStart((ODataResource)null);
Writer.WriteEnd();
}
else
{
if (entryFactory.ResourceInfo.IsCollection.GetValueOrDefault())
{
Writer.WriteStart(new ODataResourceSet()
{
Count = count
});
foreach (Object entity in (IEnumerable)navigationValue)
{
ODataResource navigationEntry = CreateEntry(entryFactory, entity);
Writer.WriteStart(navigationEntry);
foreach (OeEntryFactory navigationLink in entryFactory.NavigationLinks)
{
WriteNavigationLink(entity, navigationLink, navigationEntry, navigationLink.EntitySet);
}
Writer.WriteEnd();
}
Writer.WriteEnd();
}
else
{
ODataResource navigationEntry = CreateEntry(entryFactory, navigationValue);
if (IsNullEntry(navigationEntry))
{
Writer.WriteStart((ODataResource)null);
Writer.WriteEnd();
}
else
{
Writer.WriteStart(navigationEntry);
foreach (OeEntryFactory navigationLink in entryFactory.NavigationLinks)
{
WriteNavigationLink(navigationValue, navigationLink, navigationEntry, navigationLink.EntitySet);
}
Writer.WriteEnd();
}
}
}
Writer.WriteEnd();
}
private OeDbEnumerator(OeDbEnumerator parentEnumerator, OeEntryFactory entryFactory)
{
ParentEnumerator = parentEnumerator;
Context = parentEnumerator.Context;
EntryFactory = entryFactory;
if (entryFactory.ResourceInfo.IsCollection.GetValueOrDefault())
{
_uniqueConstraint = new HashSet <Object>(entryFactory.EqualityComparer);
}
Initialize();
}
private OeDbEnumerator(OeDbEnumerator parentEnumerator, OeEntryFactory entryFactory)
{
ParentEnumerator = parentEnumerator;
Context = parentEnumerator.Context;
EntryFactory = entryFactory;
if (entryFactory.EdmNavigationProperty.Type.Definition is EdmCollectionType)
{
_uniqueConstraint = new HashSet <Object>(entryFactory.EqualityComparer);
}
Initialize();
}
private static KeyValuePair <String, Object>[] GetNavigationSkipTokenKeys(OeEntryFactory entryFactory, OrderByClause orderByClause, Object value)
{
IEdmStructuralProperty[] keyProperties = OeSkipTokenParser.GetEdmProperies(orderByClause);
var keys = new KeyValuePair <String, Object> [keyProperties.Length];
for (int i = 0; i < keys.Length; i++)
{
String propertyName = OeSkipTokenParser.GetPropertyName(keyProperties[i]);
OePropertyAccessor accessor = entryFactory.GetAccessorByName(keyProperties[i].Name);
keys[i] = new KeyValuePair <String, Object>(propertyName, accessor.GetValue(value));
}
return(keys);
}
public OeDbEnumerator GetFromPool(OeDbEnumerator parentEnumerator, OeEntryFactory entryFactory)
{
if (_pool.TryGetValue(entryFactory, out OeDbEnumerator dbEnumerator))
{
dbEnumerator.Initialize();
}
else
{
dbEnumerator = new OeDbEnumerator(parentEnumerator, entryFactory);
_pool.Add(entryFactory, dbEnumerator);
}
return(dbEnumerator);
}
private static bool IsEquals(OeEntryFactory entryFactory, Object?value1, Object?value2)
{
if (Object.ReferenceEquals(value1, value2))
{
return(true);
}
if (value1 == null || value2 == null)
{
return(false);
}
return(entryFactory.EqualityComparer.Equals(value1, value2));
}
