/// <summary> /// Add um ouvinte pra quando os dados da plataforma estiverem prontos para serem lidos /// </summary> /// <param name="__callbackRequestCompleted">__callback request completed.</param> public void AddListener(RequestHandlerDelegate __callbackRequestCompleted) { if(_platformDataReceived != null) __callbackRequestCompleted.Invoke(); callbackRequestCompleted += __callbackRequestCompleted; }
internal void Start(RequestHandlerDelegate dispatch) { requestDelegate = dispatch; Log.Info("Starting HTTP server"); try { //Start listening for connections _listener.Start(); } catch (Exception e) { Log.Critical("Unable to start HttpListener.", e, true); } //Create a thread for handling and dispatching incoming requests new Thread(ProcessRequests).Start(); }
protected override async Task <TResponse> Process(EntityModelCommand <TEntityModel, TResponse> request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { if (request is null) { throw new ArgumentNullException(nameof(request)); } if (next is null) { throw new ArgumentNullException(nameof(next)); } await SetTenantId(request).ConfigureAwait(false); // continue pipeline return(await next().ConfigureAwait(false)); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { await _writer.WriteLineAsync("-- Handling Request"); var response = await next(); await _writer.WriteLineAsync("-- Finished Request"); return(response); }
public Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var errors = _validators .Select(v => v.Validate(request)) .SelectMany(result => result.Errors) .Where(error => error != null) .ToList(); if (errors.Any()) { var errorBuilder = new StringBuilder(); errorBuilder.AppendLine("Invalid command, reason: "); foreach (var error in errors) { errorBuilder.AppendLine(error.ErrorMessage); } throw new InvalidCommandException(errorBuilder.ToString(), null); } return(next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { if (_validators.Any()) { var context = new ValidationContext <TRequest>(request); var validationResults = await Task.WhenAll(_validators.Select(v => v.ValidateAsync(context, cancellationToken))); var failures = validationResults.SelectMany(r => r.Errors).Where(f => f != null).ToList(); if (failures.Count != 0) { throw new ValidationException(failures); } } return(await next()); }
/// <summary> /// Handles the request. /// </summary> /// <param name="request">The request</param> /// <param name="cancellation">A cancellation token</param> /// <param name="next"></param> /// <returns></returns> public async Task <TResponse> Handle(TRequest request, CancellationToken cancellation, RequestHandlerDelegate <TResponse> next) { _timer.Start(); var response = await next(); _timer.Stop(); if (_timer.ElapsedMilliseconds > 500) { var name = typeof(TRequest).Name; _logger.LogWarning($"EventsCore Long Running Request: {name} ({_timer.ElapsedMilliseconds} milliseconds) {_currentUserService.UserId} {request}"); } return(response); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var authorizeAttributes = request.GetType().GetCustomAttributes <AuthorizeAttribute>(); if (authorizeAttributes.Any()) { // Must be authenticated user if (_currentUserService.UserId == null) { throw new UnauthorizedAccessException(); } // Role-based authorization var authorizeAttributesWithRoles = authorizeAttributes.Where(a => !string.IsNullOrWhiteSpace(a.Roles)); if (authorizeAttributesWithRoles.Any()) { foreach (var roles in authorizeAttributesWithRoles.Select(a => a.Roles.Split(','))) { var authorized = false; foreach (var role in roles) { var isInRole = await _identityService.IsInRoleAsync(_currentUserService.UserId, role.Trim()); if (isInRole) { authorized = true; break; } } // Must be a member of at least one role in roles if (!authorized) { throw new ForbiddenAccessException(); } } } // Policy-based authorization var authorizeAttributesWithPolicies = authorizeAttributes.Where(a => !string.IsNullOrWhiteSpace(a.Policy)); if (authorizeAttributesWithPolicies.Any()) { foreach (var policy in authorizeAttributesWithPolicies.Select(a => a.Policy)) { var authorized = await _identityService.AuthorizeAsync(_currentUserService.UserId, policy); if (!authorized) { throw new ForbiddenAccessException(); } } } } // User is authorized / authorization not required return(await next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { if (!((EntityBase)request).Valid) { var response = (TResponse) new Response(request.Notifications, true); return(response); } var result = await next(); return(result); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var response = default(TResponse); var typeName = request.GetGenericTypeName(); try { if (_dbContext.HasActiveTransaction) { return(await next()); } var strategy = _dbContext.Database.CreateExecutionStrategy(); await strategy.ExecuteAsync(async() => { Guid transactionId; using (var transaction = await _dbContext.BeginTransactionAsync()) using (LogContext.PushProperty("TransactionContext", transaction)) { _logger.LogInformation("----- Begin transaction {TransactionId} for {CommandName} ({@Command})", transaction.TransactionId, typeName, JsonFormatting.Formated(request)); response = await next(); _logger.LogInformation("----- Commit transaction {TransactionId} for {CommandName}", transaction.TransactionId, typeName); await _dbContext.CommitTransactionAsync(transaction); transactionId = transaction.TransactionId; } await _posServiceIntegrationEventService.PublishEventsThroughEventBusAsync(transactionId); }); return(response); } catch (Exception ex) { _logger.LogError(ex, "ERROR Handling transaction for {CommandName} ({@Command})", typeName, request); throw; } }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { if (!(request is IApplicationRequest <object> appRequest)) { throw new ArgumentNullException($"{nameof(appRequest)} app request must implement {nameof(IApplicationRequest<object>)}"); } var requestType = appRequest.Data?.GetType(); ProcessOnlyUserItselfPermission(appRequest, requestType); ProcessRequirePermissionAttribute(appRequest, requestType); return(await next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { if (request is SemanticTokensParams semanticTokensParams) { var response = await next().ConfigureAwait(false); if (GetResponse(semanticTokensParams, response, out var result) && string.IsNullOrEmpty(result.ResultId)) { result.ResultId = Guid.NewGuid().ToString(); } return(response); } if (request is SemanticTokensDeltaParams semanticTokensDeltaParams) { var response = await next().ConfigureAwait(false); if (GetResponse(semanticTokensDeltaParams, response, out var result)) { if (result?.IsFull == true && string.IsNullOrEmpty(result.Value.Full.ResultId)) { result.Value.Full.ResultId = semanticTokensDeltaParams.PreviousResultId; } if (result?.IsDelta == true && string.IsNullOrEmpty(result.Value.Delta.ResultId)) { result.Value.Delta.ResultId = semanticTokensDeltaParams.PreviousResultId; } } return(response); } return(await next().ConfigureAwait(false)); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { _logger.Log(LogLevel.Information, $"Handling {typeof(TRequest).Name}"); var response = await next(); _logger.Log(LogLevel.Information, $"Handled {typeof(TRequest).Name}"); return(response); }
public Task <SearchTransactionResult> Handle(SearchTransaction request, CancellationToken cancellationToken, RequestHandlerDelegate <SearchTransactionResult> next) { if (!request.Filter.Accounts.Any()) { var accounts = accountRepository .Query .Where(a => a.UserId == request.UserId) .Select(a => a.Id) .ToList(); request.Filter.Accounts.AddRange(accounts); } return(next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext <TRequest>(request); var failures = _validators .Select(async(x) => await x.ValidateAsync(context, cancellationToken)) .SelectMany(x => x.Result.Errors) .Where(x => x is not null) .ToList(); if (failures.Any()) { throw new ValidationException(failures); } return(await next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { LogRequest(request); var response = await next(); LogResponse(response); return(response); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var transactionOptions = new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted, Timeout = TransactionManager.MaximumTimeout }; using (var transaction = new TransactionScope(TransactionScopeOption.Required, transactionOptions, TransactionScopeAsyncFlowOption.Enabled)) { TResponse response = await next(); transaction.Complete(); return(response); } }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext <TRequest>(request); var failures = validators.Select(x => x.Validate(context)).SelectMany(x => x.Errors).Where(x => x != null).ToList(); if (failures.Count != 0) { throw new ValidationException(failures); } return(await next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { _timer.Start(); var response = await next(); _timer.Stop(); if (_timer.ElapsedMilliseconds > 500) { var name = typeof(TRequest).Name; _logger.LogWarning("Long Running Request: {Name} ({ElapsedMilliseconds} milliseconds) {@Request}", name, _timer.ElapsedMilliseconds, request); } return(response); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { if (request is ICacheableQuery cacheableQuery) { TResponse response; async Task <TResponse> GetResponseAndAddToCache() { response = await next(); var options = cacheableQuery.SlidingExpiration != null ? new DistributedCacheEntryOptions { SlidingExpiration = cacheableQuery.SlidingExpiration } : defaultCacheOptions; await cache.SetAsync(cacheableQuery.CacheKey, byteSerializer.Serialize(response), options, cancellationToken); return(response); } if (cacheableQuery.ReplaceCachedEntry) { logger.LogInformation($"Replacing cache entry for key '{cacheableQuery.CacheKey}'."); response = await GetResponseAndAddToCache(); } else { var cachedResponse = await cache.GetAsync(cacheableQuery.CacheKey, cancellationToken); if (cachedResponse != null) { logger.LogInformation($"Cache hit for key '{cacheableQuery.CacheKey}'."); response = byteSerializer.Deserialize <TResponse>(cachedResponse); } else { logger.LogInformation($"Cache miss for key '{cacheableQuery.CacheKey}'. Adding to cache."); response = await GetResponseAndAddToCache(); } } if (cacheableQuery.RefreshCachedEntry) { logger.LogInformation($"Cache refreshed for key '{cacheableQuery.CacheKey}'."); await cache.RefreshAsync(cacheableQuery.CacheKey, cancellationToken); } return(response); } else { return(await next()); } }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext(request); var failures = validators .Select(async v => (await v.ValidateAsync(context, cancellationToken))) .SelectMany(result => result.Result.Errors) .Where(f => f != null) .ToList(); if (failures.Count == 0) { return(await next()); } if (typeof(TResponse).IsAssignableFrom(typeof(UseCaseResult))) { return((TResponse)Activator.CreateInstance(typeof(TResponse), failures, ResultCategory.ValidationFailed)); } throw new ValidationException(failures); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { if (_authorisers.Any()) { foreach (var authoriser in _authorisers) { var authorised = await authoriser.Authorise(request, cancellationToken); if (!authorised) { throw new UnauthorisedApplicationException("Current user is not authorised to perform this action"); } } } return(await next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { TResponse response = await next(); string requestName = request.ToString(); // Commands convention if (requestName.EndsWith("Command")) { Type requestType = request.GetType(); string commandName = requestType.Name; var data = new Dictionary <string, object> { { "request", request }, { "response", response } }; string jsonData = JsonConvert.SerializeObject(data); byte[] dataBytes = Encoding.UTF8.GetBytes(jsonData); EventData eventData = new EventData(eventId: Guid.NewGuid(), type: commandName, isJson: true, data: dataBytes, metadata: null); await _eventStoreDbContext.AppendToStreamAsync(eventData); } return(response); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var typeName = request.GetGenericTypeName(); _logger.LogInformation("----- Validating command {CommandType}", typeName); var failures = _validators .Select(v => v.Validate(request)) .SelectMany(result => result.Errors) .Where(error => error != null) .ToList(); if (failures.Any()) { _logger.LogWarning("Validation errors - {CommandType} - Command: {@Command} - Errors: {@ValidationErrors}", typeName, request, failures); throw new ValidationException("Validation errors", failures); } return(await next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { try { return(await next()); } catch (Exception ex) { var requestName = typeof(TRequest).Name; _logger.LogError(ex, "BeerTracker Request: Unhandled Exception for Request {Name} {@Request}", requestName, request); throw; } }
public Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext(request); var failures = _validators .Select(v => v.Validate(context)) .SelectMany(result => result.Errors) .Where(f => f != null) .ToList(); if (failures.Count != 0) { throw new ValidationException(failures); } return(next()); }
internal void Stop() { _listener.Stop(); _listener.Close(); requestDelegate = null; }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var validator = (IValidator <TRequest>)_serviceProvider.GetService(typeof(IValidator <TRequest>)); if (validator != null) { _logger.LogInformation("Validating command {CommandType}", request.GetType().Name); var failures = (await validator.ValidateAsync(request, cancellationToken)).Errors; if (failures.Any()) { _logger.LogWarning("Validation errors - {CommandType} - Command: {@Command} - Errors: {@ValidationErrors}", request.GetType().Name, request, failures); var validationErrors = failures.Select(er => new ValidationError { FieldName = er.PropertyName, Message = er.ErrorMessage, AttemptedValue = er.AttemptedValue, }).ToList(); throw new CommandValidationException(validationErrors); } } return(await next()); }
/// <summary> /// Remove o listener da callback da request /// </summary> /// <param name="__callbackRequestCompleted">__callback request completed.</param> public void RemoveListener(RequestHandlerDelegate __callbackRequestCompleted) { callbackRequestCompleted -= __callbackRequestCompleted; }
public Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { return(default);
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { try { _logger.Information( "Executing command/query {Command}", typeof(TRequest).GetType().Name); var result = await next(); _logger.Information("Command/Query {Command} processed successful", typeof(TRequest).GetType().Name); return(result); } catch (Exception exception) { _logger.Error(exception, "Command/Query {Command} processing failed", typeof(TRequest).GetType().Name); throw; } }
public Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext <TRequest>(request); var failures = _validators .Select(validator => validator.Validate(context)) .SelectMany(validationResult => validationResult.Errors) .Where(validationFailure => validationFailure != null) .ToList(); return(failures.Count != 0 ? throw new ValidationException(failures) : next()); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext(request); var failures = _validators .Select(v => v.Validate(context)) .SelectMany(result => result.Errors) .Where(f => f != null) .ToList(); if (failures.Any()) { var errors = string.Join(",", failures.Select(x => x.ErrorMessage).ToArray()); throw new ApplicationException( $"Request {typeof(TRequest).Name} => {errors}", new ValidationException("Validation exception", failures)); } var response = await next(); return(response); }
public static Uri GetUri (RequestHandlerDelegate dlg) { var handler = instance.handlerByMethod [dlg.Method]; if (handler == null) throw new InvalidOperationException (); return GetUri (handler); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { try { return(await next()); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); var resultType = typeof(TResponse); if (resultType.IsGenericType) { var genericResultType = resultType.GetGenericArguments()[0]; var failureResultType = typeof(FailureResult <>).MakeGenericType(genericResultType); return(Activator.CreateInstance(failureResultType, ex) as TResponse); } return(new FailureResult(ex) as TResponse); } }