public async Task <ODataRequest> GetRequestAsync(bool scalarResult, CancellationToken cancellationToken)
        {
            await _session.ResolveAdapterAsync(cancellationToken).ConfigureAwait(false);

            if (cancellationToken.IsCancellationRequested)
            {
                cancellationToken.ThrowIfCancellationRequested();
            }

            return(await _session.Adapter.GetRequestWriter(_lazyBatchWriter)
                   .CreateGetRequestAsync(_commandText ?? _command.Format(), scalarResult, GetHeaders()).ConfigureAwait(false));
        }
Example #2
0
        private async Task <int> IterateEntriesAsync(ResolvedCommand command,
                                                     Func <string, IDictionary <string, object>, Task> funcAsync, CancellationToken cancellationToken)
        {
            var collectionName = command.QualifiedEntityCollectionName;

            var result  = 0;
            var client  = new ODataClient(_settings);
            var entries = await client.FindEntriesAsync(command.Format(), cancellationToken).ConfigureAwait(false);

            if (entries != null)
            {
                var entryList = entries.ToList();
                foreach (var entry in entryList)
                {
                    await funcAsync(collectionName, entry).ConfigureAwait(false);

                    if (cancellationToken.IsCancellationRequested)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                    }
                    ++result;
                }
            }
            return(result);
        }
Example #3
0
        private async Task <IEnumerable <IDictionary <string, object> > > IterateEntriesAsync(
            ResolvedCommand command, bool resultRequired,
            Func <string, IDictionary <string, object>, IDictionary <string, object>, bool, Task <IDictionary <string, object> > > funcAsync, CancellationToken cancellationToken)
        {
            var collectionName = command.QualifiedEntityCollectionName;
            var entryData      = command.CommandData;

            IEnumerable <IDictionary <string, object> > result = null;
            var client  = new ODataClient(_settings);
            var entries = await client.FindEntriesAsync(command.Format(), cancellationToken).ConfigureAwait(false);

            if (entries != null)
            {
                var entryList  = entries.ToList();
                var resultList = new List <IDictionary <string, object> >();
                foreach (var entry in entryList)
                {
                    resultList.Add(await funcAsync(collectionName, entry, entryData, resultRequired).ConfigureAwait(false));
                    if (cancellationToken.IsCancellationRequested)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                    }
                }
                result = resultList;
            }

            return(result);
        }
        private string FormatEntryKey(ResolvedCommand command)
        {
            var entryIdent = command.Details.HasKey
                ? command.Format()
                : new FluentCommand(command).Key(command.FilterAsKey).Resolve(_session).Format();

            return(entryIdent);
        }
Example #5
0
        private async Task <IEnumerable <IDictionary <string, object> > > ExecuteFunctionAsync(ResolvedCommand command, CancellationToken cancellationToken)
        {
            var request = await _session.Adapter.GetRequestWriter(_lazyBatchWriter)
                          .CreateFunctionRequestAsync(command.Format(), command.Details.FunctionName, command.Details.Headers).ConfigureAwait(false);

            return(await ExecuteRequestWithResultAsync(request, cancellationToken,
                                                       x => x.AsEntries(_session.Settings.IncludeAnnotationsInResults),
                                                       () => Array.Empty <IDictionary <string, object> >()).ConfigureAwait(false));
        }
Example #6
0
        private async Task <IEnumerable <IDictionary <string, object> > > ExecuteActionAsync(ResolvedCommand command, CancellationToken cancellationToken)
        {
            var entityTypeName = command.EntityCollection != null
                ? _session.Metadata.GetQualifiedTypeName(command.EntityCollection.Name)
                : null;

            var request = await _session.Adapter.GetRequestWriter(_lazyBatchWriter)
                          .CreateActionRequestAsync(command.Format(), command.Details.ActionName, entityTypeName, command.CommandData, true, command.Details.Headers).ConfigureAwait(false);

            return(await ExecuteRequestWithResultAsync(request, cancellationToken,
                                                       x => x.AsEntries(_session.Settings.IncludeAnnotationsInResults),
                                                       () => Array.Empty <IDictionary <string, object> >()).ConfigureAwait(false));
        }