public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var options = request.Options; var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, UpdateOperation, context.CancellationToken).ConfigureAwait(false)) { throw AccessDenied(); } var updateSource = new TaskCompletionSource <bool>(); var envelope = new CallbackEnvelope(OnMessage); _publisher.Publish(new UserManagementMessage.Update(envelope, user, options.LoginName, options.FullName, options.Groups.ToArray())); await updateSource.Task.ConfigureAwait(false); return(new UpdateResp()); void OnMessage(Message message) { if (HandleErrors(options.LoginName, message, updateSource)) { return; } updateSource.TrySetResult(true); } }
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var options = request.Options; var user = await GetUser(_authenticationProvider, context.RequestHeaders); var updateSource = new TaskCompletionSource <bool>(); var envelope = new CallbackEnvelope(OnMessage); _queue.Publish(new UserManagementMessage.Update(envelope, user, options.LoginName, options.FullName, options.Groups.ToArray())); await updateSource.Task; return(new UpdateResp()); void OnMessage(Message message) { if (HandleErrors(options.LoginName, message, updateSource)) { return; } updateSource.TrySetResult(true); } }
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var updatePersistentSubscriptionSource = new TaskCompletionSource <UpdateResp>(); var settings = request.Options.Settings; var correlationId = Guid.NewGuid(); var user = context.GetHttpContext().User; _queue.Publish(new ClientMessage.UpdatePersistentSubscription( correlationId, correlationId, new CallbackEnvelope(HandleUpdatePersistentSubscriptionCompleted), request.Options.StreamName, request.Options.GroupName, settings.ResolveLinks, new StreamRevision(settings.Revision).ToInt64(), (int)TimeSpan.FromTicks(settings.MessageTimeout).TotalMilliseconds, settings.ExtraStatistics, settings.MaxRetryCount, settings.HistoryBufferSize, settings.LiveBufferSize, settings.ReadBatchSize, (int)TimeSpan.FromTicks(settings.CheckpointAfter).TotalMilliseconds, settings.MinCheckpointCount, settings.MaxCheckpointCount, settings.MaxSubscriberCount, settings.NamedConsumerStrategy.ToString(), user,
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var updatePersistentSubscriptionSource = new TaskCompletionSource <UpdateResp>(); var settings = request.Options.Settings; var correlationId = Guid.NewGuid(); var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, UpdateOperation, context.CancellationToken).ConfigureAwait(false)) { throw AccessDenied(); } _publisher.Publish(new ClientMessage.UpdatePersistentSubscription( correlationId, correlationId, new CallbackEnvelope(HandleUpdatePersistentSubscriptionCompleted), request.Options.StreamIdentifier, request.Options.GroupName, settings.ResolveLinks, new StreamRevision(settings.Revision).ToInt64(), settings.MessageTimeoutCase switch { UpdateReq.Types.Settings.MessageTimeoutOneofCase.MessageTimeoutMs => settings.MessageTimeoutMs, UpdateReq.Types.Settings.MessageTimeoutOneofCase.MessageTimeoutTicks => (int)TimeSpan .FromTicks(settings.MessageTimeoutTicks).TotalMilliseconds, _ => 0 },
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var updatedSource = new TaskCompletionSource <bool>(); var options = request.Options; var user = await GetUser(_authenticationProvider, context.RequestHeaders).ConfigureAwait(false); const string handlerType = "JS"; var name = options.Name; var query = options.Query; bool? emitEnabled = (options.EmitOptionCase, options.EmitEnabled) switch { (EmitOptionOneofCase.EmitEnabled, true) => true, (EmitOptionOneofCase.EmitEnabled, false) => false, (EmitOptionOneofCase.NoEmitOptions, _) => default,
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var updatedSource = new TaskCompletionSource <bool>(); var options = request.Options; var user = context.GetHttpContext().User; const string handlerType = "JS"; var name = options.Name; var query = options.Query; bool? emitEnabled = (options.EmitOptionCase, options.EmitEnabled) switch { (EmitOptionOneofCase.EmitEnabled, true) => true, (EmitOptionOneofCase.EmitEnabled, false) => false, (EmitOptionOneofCase.NoEmitOptions, _) => default,
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var updatedSource = new TaskCompletionSource <bool>(); var options = request.Options; var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, UpdateOperation, context.CancellationToken) .ConfigureAwait(false)) { throw AccessDenied(); } const string handlerType = "JS"; var name = options.Name; var query = options.Query; bool? emitEnabled = (options.EmitOptionCase, options.EmitEnabled) switch { (EmitOptionOneofCase.EmitEnabled, true) => true, (EmitOptionOneofCase.EmitEnabled, false) => false, (EmitOptionOneofCase.NoEmitOptions, _) => default,
protected bool IsUserRegistred(UpdateReq msg) { if (msg.type == 0) { QuerySelectClientByEmailNick query = new QuerySelectClientByEmailNick("", msg.email, DBUtils.GetDBConnection(), null); query.Execute(); return(query.clients.Count != 0); } else { QuerySelectSalerByEmailNick query = new QuerySelectSalerByEmailNick("", msg.email, DBUtils.GetDBConnection(), null); query.Execute(); return(query.salers.Count != 0); } }
public UpdateAck OnUpdateStart(UpdateReq msg) { if (!IsValidEmail(msg.email)) { return(new UpdateAck(UpdateAck.Result.FAIL_INCORRECT_EMAIL)); } DropExpiredCodes(); UpdateRequest req = GetRequestByEmail(msg.email); if (req != null) { req.createdTime = DateTime.Now; } else if (!IsUserRegistred(msg)) { return(new UpdateAck(UpdateAck.Result.FAIL_UNREGISTER_USER)); } else { req = new UpdateRequest(); req.createdTime = DateTime.Now; req.code = GenerateCode(); req.msg = msg; requests.Add(req); } if (req != null) { try { SendCode(req.msg.email, req.code); } catch { return(new UpdateAck(UpdateAck.Result.FAIL_INCORRECT_EMAIL)); } return(new UpdateAck(UpdateAck.Result.SUCCESS)); } return(new UpdateAck(UpdateAck.Result.UNKNOWN_ERROR)); }
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var updatePersistentSubscriptionSource = new TaskCompletionSource <UpdateResp>(); var settings = request.Options.Settings; var correlationId = Guid.NewGuid(); var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, UpdateOperation, context.CancellationToken).ConfigureAwait(false)) { throw AccessDenied(); } string streamId = null; switch (request.Options.StreamOptionCase) { case StreamOptionOneofCase.Stream: case StreamOptionOneofCase.None: /*for backwards compatibility*/ { StreamRevision startRevision; if (request.Options.StreamOptionCase == StreamOptionOneofCase.Stream) { streamId = request.Options.Stream.StreamIdentifier; startRevision = request.Options.Stream.RevisionOptionCase switch { RevisionOptionOneofCase.Revision => new StreamRevision(request.Options.Stream.Revision), RevisionOptionOneofCase.Start => StreamRevision.Start, RevisionOptionOneofCase.End => StreamRevision.End, _ => throw new InvalidOperationException() }; } else /*for backwards compatibility*/ { #pragma warning disable 612 streamId = request.Options.StreamIdentifier; startRevision = new StreamRevision(request.Options.Settings.Revision); #pragma warning restore 612 } _publisher.Publish(new ClientMessage.UpdatePersistentSubscriptionToStream( correlationId, correlationId, new CallbackEnvelope(HandleUpdatePersistentSubscriptionCompleted), streamId, request.Options.GroupName, settings.ResolveLinks, startRevision.ToInt64(), settings.MessageTimeoutCase switch { UpdateReq.Types.Settings.MessageTimeoutOneofCase.MessageTimeoutMs => settings.MessageTimeoutMs, UpdateReq.Types.Settings.MessageTimeoutOneofCase.MessageTimeoutTicks => (int)TimeSpan .FromTicks(settings.MessageTimeoutTicks).TotalMilliseconds, _ => 0 }, settings.ExtraStatistics, settings.MaxRetryCount, settings.HistoryBufferSize, settings.LiveBufferSize, settings.ReadBatchSize, settings.CheckpointAfterCase switch { UpdateReq.Types.Settings.CheckpointAfterOneofCase.CheckpointAfterMs => settings.CheckpointAfterMs, UpdateReq.Types.Settings.CheckpointAfterOneofCase.CheckpointAfterTicks => (int)TimeSpan .FromTicks(settings.CheckpointAfterTicks).TotalMilliseconds, _ => 0 },
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var updatePersistentSubscriptionSource = new TaskCompletionSource <UpdateResp>(); var settings = request.Options.Settings; var correlationId = Guid.NewGuid(); var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, UpdateOperation, context.CancellationToken).ConfigureAwait(false)) { throw AccessDenied(); } _publisher.Publish(new ClientMessage.UpdatePersistentSubscription( correlationId, correlationId, new CallbackEnvelope(HandleUpdatePersistentSubscriptionCompleted), request.Options.StreamName, request.Options.GroupName, settings.ResolveLinks, new StreamRevision(settings.Revision).ToInt64(), (int)TimeSpan.FromTicks(settings.MessageTimeout).TotalMilliseconds, settings.ExtraStatistics, settings.MaxRetryCount, settings.HistoryBufferSize, settings.LiveBufferSize, settings.ReadBatchSize, (int)TimeSpan.FromTicks(settings.CheckpointAfter).TotalMilliseconds, settings.MinCheckpointCount, settings.MaxCheckpointCount, settings.MaxSubscriberCount, settings.NamedConsumerStrategy.ToString(), user)); return(await updatePersistentSubscriptionSource.Task.ConfigureAwait(false)); void HandleUpdatePersistentSubscriptionCompleted(Message message) { if (message is ClientMessage.NotHandled notHandled && RpcExceptions.TryHandleNotHandled(notHandled, out var ex)) { updatePersistentSubscriptionSource.TrySetException(ex); return; } if (!(message is ClientMessage.UpdatePersistentSubscriptionCompleted completed)) { updatePersistentSubscriptionSource.TrySetException( RpcExceptions.UnknownMessage <ClientMessage.UpdatePersistentSubscriptionCompleted>(message)); return; } switch (completed.Result) { case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.Success: updatePersistentSubscriptionSource.TrySetResult(new UpdateResp()); return; case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.Fail: updatePersistentSubscriptionSource.TrySetException(RpcExceptions.PersistentSubscriptionFailed(request.Options.StreamName, request.Options.GroupName, completed.Reason)); return; case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult .AccessDenied: updatePersistentSubscriptionSource.TrySetException(RpcExceptions.AccessDenied()); return; default: updatePersistentSubscriptionSource.TrySetException(RpcExceptions.UnknownError(completed.Result)); return; } } }
public UpdateAck Post([FromBody] UpdateReq request) { return(eEngine.GetUpdateCardControl().OnUpdateStart(request)); }