public OeEntityAsyncEnumerator(OeEntryFactory entryFactory, Db.OeAsyncEnumerator asyncEnumerator)
{
_entryFactory = entryFactory;
_asyncEnumerator = asyncEnumerator;
_isFirstMoveNext = true;
}
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 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 IEnumerable <Dictionary <String, Object> > Resolve(ResolveFieldContext context)
{
var results = new List <Dictionary <String, Object> >();
var translator = new OeGraphqlAstToODataUri(_edmModel, context);
ODataUri odataUri = translator.Translate(context.Document.OriginalQuery);
IEdmModel refModel = _edmModel.GetEdmModel(odataUri.Path);
Db.OeDataAdapter dataAdapter = refModel.GetDataAdapter(refModel.EntityContainer);
context.UserContext = dataAdapter.CreateDataContext();
try
{
var parser = new Parsers.OeGetParser(refModel);
Parsers.OeQueryContext queryContext = parser.CreateQueryContext(odataUri, 0, false, OeMetadataLevel.Minimal);
Db.OeAsyncEnumerator asyncEnumerator = dataAdapter.ExecuteEnumerator(context.UserContext, queryContext, CancellationToken.None);
using (var entityAsyncEnumerator = new OeGraphqlAsyncEnumerator(asyncEnumerator, queryContext.EntryFactory, queryContext))
{
while (entityAsyncEnumerator.MoveNext().GetAwaiter().GetResult())
{
results.Add(entityAsyncEnumerator.Current);
}
}
}
finally
{
if (context.UserContext != null)
{
dataAdapter.CloseDataContext(context.UserContext);
}
}
return(results);
}
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();
}
public IEnumerable<T> Resolve(ResolveFieldContext context)
{
var zzz3 = context.ParentType.Fields.Single(f => f.Name == context.Document.Operations.Single().SelectionSet.Selections.OfType<Field>().Single().Name);
var zzz = context.Schema.FindType("order");
var zzz2 = context.Schema.Query.Fields.Single(f => f.Name == context.FieldAst.Name);
var barcode = context.GetArgument<string>("barcode");
var title = context.GetArgument<string>("title");
var sellingPrice = context.GetArgument<decimal>("sellingPrice");
var results = new List<T>();
var odataParser = new ODataUriParser(_edmModel, new Uri("http://dummy"), new Uri("http://dummy/Orders?$expand=Customer&$select=Name"));
odataParser.Resolver.EnableCaseInsensitive = true;
//ODataUri odataUri = odataParser.ParseUri();
var translator = new OeGraphQLAstToODataUri(_edmModel, context.Schema);
ODataUri odataUri = translator.Translate(context.Document.OriginalQuery);
var odataQuery = odataUri.BuildUri(ODataUrlKeyDelimiter.Parentheses);
var parser = new OeGetParser(_dataAdapter, _edmModel);
Parsers.OeQueryContext queryContext = parser.CreateQueryContext(odataUri, 0, false, OeMetadataLevel.Minimal);
Db.OeAsyncEnumerator asyncEnumerator = _dataAdapter.ExecuteEnumerator(context.UserContext, queryContext, CancellationToken.None);
using (var entityAsyncEnumerator = new OeEntityAsyncEnumerator<T>(queryContext.EntryFactory, asyncEnumerator, queryContext))
{
while (entityAsyncEnumerator.MoveNext().GetAwaiter().GetResult())
results.Add((T)entityAsyncEnumerator.Current);
}
return results;
}
public async Task SerializeAsync(OeEntryFactory entryFactory, Db.OeAsyncEnumerator asyncEnumerator, OeQueryContext queryContext)
{
var resourceSet = new ODataResourceSet()
{
Count = asyncEnumerator.Count
};
Writer.WriteStart(resourceSet);
Object value = null;
int count = 0;
while (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false))
{
value = asyncEnumerator.Current;
ODataResource entry = CreateEntry(entryFactory, entryFactory.GetValue(value, out _));
Writer.WriteStart(entry);
foreach (OeEntryFactory navigationLink in entryFactory.NavigationLinks)
{
WriteNavigationLink(value, navigationLink, entry, entryFactory.EntitySet);
}
if (QueryContext.NavigationNextLink)
{
foreach (ExpandedNavigationSelectItem item in QueryContext.GetExpandedNavigationSelectItems())
{
WriteNavigationNextLink(entry, item);
}
}
Writer.WriteEnd();
count++;
}
if (queryContext.PageSize > 0 && count > 0 && (asyncEnumerator.Count ?? Int32.MaxValue) > count)
{
resourceSet.NextPageLink = BuildNextPageLink(queryContext, value);
}
Writer.WriteEnd();
}
public static async Task SerializeAsync(OeQueryContext queryContext, Db.OeAsyncEnumerator asyncEnumerator, String contentType, Stream stream)
{
OeEntryFactory entryFactory = queryContext.EntryFactory;
var settings = new ODataMessageWriterSettings()
{
BaseUri = queryContext.ODataUri.ServiceRoot,
EnableMessageStreamDisposal = false,
ODataUri = queryContext.ODataUri,
Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, contentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, queryContext.EdmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(entryFactory.EntitySet, entryFactory.EntityType);
var getWriter = new GetWriter(queryContext, writer);
await getWriter.SerializeAsync(entryFactory, asyncEnumerator, queryContext).ConfigureAwait(false);
}
}
public static async Task WriteCollectionAsync(IEdmModel model, ODataUri odataUri, Db.OeAsyncEnumerator asyncEnumerator, Stream responseStream)
{
var importSegment = (OperationImportSegment)odataUri.Path.LastSegment;
IEdmOperationImport operationImport = importSegment.OperationImports.Single();
Type returnType = model.GetClrType(operationImport.Operation.ReturnType.Definition);
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(responseStream, null);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage,
new ODataMessageWriterSettings()
{
EnableMessageStreamDisposal = false, ODataUri = odataUri
}, model))
{
IEdmTypeReference typeRef = OeEdmClrHelper.GetEdmTypeReference(model, returnType);
ODataCollectionWriter writer = messageWriter.CreateODataCollectionWriter(typeRef);
writer.WriteStart(new ODataCollectionStart());
while (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false))
{
Object value = asyncEnumerator.Current;
if (value != null && value.GetType().IsEnum)
{
value = value.ToString();
}
writer.WriteItem(value);
}
writer.WriteEnd();
}
}
public OePrimitiveAsyncEnumerator(Db.OeAsyncEnumerator asyncEnumerator)
{
_asyncEnumerator = asyncEnumerator;
}
public ODataResult <Model.ManyColumns> Get()
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData <Model.ManyColumns>(asyncEnumerator));
}
public ODataResult <Model.Customer> Get(String country, String id)
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData <Model.Customer>(asyncEnumerator));
}
public OeEntityAsyncEnumerator(OeEntryFactory entryFactory, Db.OeAsyncEnumerator asyncEnumerator, OeQueryContext queryContext)
: this(entryFactory, asyncEnumerator)
{
_queryContext = queryContext;
}
public ODataResult <Model.Order> TableFunction()
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData <Model.Order>(asyncEnumerator));
}
public IActionResult TableFunctionWithParameters()
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData(asyncEnumerator));
}
public async Task <IActionResult> ScalarFunctionWithParameters()
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(await base.ODataScalar(asyncEnumerator));
}
public async Task <IActionResult> ResetManyColumns()
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(await base.ODataScalar(asyncEnumerator));
}
public ODataResult <Model.OrderItem> GetItems(int id)
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData <Model.OrderItem>(asyncEnumerator));
}
public OeEntityAsyncEnumerator(OeEntryFactory entryFactory, Db.OeAsyncEnumerator asyncEnumerator, OeSkipTokenParser skipTokenParser)
: this(entryFactory, asyncEnumerator)
{
_skipTokenParser = skipTokenParser;
}
public ODataResult <Model.Customer> OrderCustomer(int id)
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData <Model.Customer>(asyncEnumerator));
}
public ODataResult <Model.ShippingAddress> Get(int id)
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData <Model.ShippingAddress>(asyncEnumerator));
}
public ODataResult <Model.Order> TableFunctionWithParameters(String id, String name, String status)
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData <Model.Order>(asyncEnumerator));
}
public IActionResult Get()
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData(asyncEnumerator));
}
public ODataResult <Model.Category> Get(int id)
{
Db.OeAsyncEnumerator asyncEnumerator = base.GetAsyncEnumerator(base.HttpContext, base.HttpContext.Response.Body);
return(base.OData <Model.Category>(asyncEnumerator));
}
