public EventStoreProjectionManagementClient(EventStoreClientSettings?settings) : base(settings,
                                                                                       new Dictionary <string, Func <RpcException, Exception> >())
 {
     _client = new Projections.Projections.ProjectionsClient(CallInvoker);
     _log    = settings?.LoggerFactory?.CreateLogger <EventStoreProjectionManagementClient>() ??
               new NullLogger <EventStoreProjectionManagementClient>();
 }
Esempio n. 2
0
 public async Task EnableAsync(string name, UserCredentials?userCredentials = null,
                               CancellationToken cancellationToken          = default)
 {
     using var call = new Projections.Projections.ProjectionsClient(
               await SelectCallInvoker(cancellationToken).ConfigureAwait(false)).EnableAsync(new EnableReq {
         Options = new EnableReq.Types.Options {
             Name = name
         }
     }, EventStoreCallOptions.Create(Settings, Settings.OperationOptions, userCredentials, cancellationToken));
     await call.ResponseAsync.ConfigureAwait(false);
 }
Esempio n. 3
0
 private async Task DisableInternalAsync(string name, bool writeCheckpoint, UserCredentials?userCredentials,
                                         CancellationToken cancellationToken)
 {
     using var call = new Projections.Projections.ProjectionsClient(
               await SelectCallInvoker(cancellationToken).ConfigureAwait(false)).DisableAsync(new DisableReq {
         Options = new DisableReq.Types.Options {
             Name            = name,
             WriteCheckpoint = writeCheckpoint
         }
     }, EventStoreCallOptions.Create(Settings, Settings.OperationOptions, userCredentials, cancellationToken));
     await call.ResponseAsync.ConfigureAwait(false);
 }
 public async Task CreateOneTimeAsync(string query, UserCredentials?userCredentials = null,
                                      CancellationToken cancellationToken           = default)
 {
     using var call = new Projections.Projections.ProjectionsClient(
               await SelectCallInvoker(cancellationToken).ConfigureAwait(false)).CreateAsync(new CreateReq {
         Options = new CreateReq.Types.Options {
             OneTime = new Empty(),
             Query   = query
         }
     }, EventStoreCallOptions.Create(Settings, Settings.OperationOptions, userCredentials, cancellationToken));
     await call.ResponseAsync.ConfigureAwait(false);
 }
 public async Task CreateContinuousAsync(string name, string query, bool trackEmittedStreams = false,
                                         UserCredentials?userCredentials = null, CancellationToken cancellationToken = default)
 {
     using var call = new Projections.Projections.ProjectionsClient(
               await SelectCallInvoker(cancellationToken).ConfigureAwait(false)).CreateAsync(new CreateReq {
         Options = new CreateReq.Types.Options {
             Continuous = new CreateReq.Types.Options.Types.Continuous {
                 Name = name,
                 TrackEmittedStreams = trackEmittedStreams
             },
             Query = query
         }
     }, EventStoreCallOptions.Create(Settings, Settings.OperationOptions, userCredentials, cancellationToken));
     await call.ResponseAsync.ConfigureAwait(false);
 }
Esempio n. 6
0
        private async ValueTask <Value> GetResultInternalAsync(string name, string?partition,
                                                               UserCredentials?userCredentials,
                                                               CancellationToken cancellationToken)
        {
            using var call = new Projections.Projections.ProjectionsClient(
                      await SelectCallInvoker(cancellationToken).ConfigureAwait(false)).ResultAsync(new ResultReq {
                Options = new ResultReq.Types.Options {
                    Name      = name,
                    Partition = partition ?? string.Empty
                }
            }, EventStoreCallOptions.Create(Settings, Settings.OperationOptions, userCredentials, cancellationToken));

            var response = await call.ResponseAsync.ConfigureAwait(false);

            return(response.Result);
        }
        private async IAsyncEnumerable <ProjectionDetails> ListInternalAsync(StatisticsReq.Types.Options options,
                                                                             UserCredentials?userCredentials,
                                                                             [EnumeratorCancellation] CancellationToken cancellationToken)
        {
            using var call = new Projections.Projections.ProjectionsClient(
                      await SelectCallInvoker(cancellationToken).ConfigureAwait(false)).Statistics(new StatisticsReq {
                Options = options
            }, EventStoreCallOptions.Create(Settings, Settings.OperationOptions, userCredentials, cancellationToken));

            await foreach (var projectionDetails in call.ResponseStream
                           .ReadAllAsync(cancellationToken)
                           .Select(ConvertToProjectionDetails)
                           .WithCancellation(cancellationToken)
                           .ConfigureAwait(false))
            {
                yield return(projectionDetails);
            }
        }
Esempio n. 8
0
        public async Task UpdateAsync(string name, string query, bool?emitEnabled = null,
                                      UserCredentials?userCredentials             = null, CancellationToken cancellationToken = default)
        {
            var options = new UpdateReq.Types.Options {
                Name  = name,
                Query = query
            };

            if (emitEnabled.HasValue)
            {
                options.EmitEnabled = emitEnabled.Value;
            }
            else
            {
                options.NoEmitOptions = new Empty();
            }

            using var call = new Projections.Projections.ProjectionsClient(
                      await SelectCallInvoker(cancellationToken).ConfigureAwait(false)).UpdateAsync(new UpdateReq {
                Options = options
            }, EventStoreCallOptions.Create(Settings, Settings.OperationOptions, userCredentials, cancellationToken));

            await call.ResponseAsync.ConfigureAwait(false);
        }