private void CheckAuthHeader(IHttpFunctionContext context) { var request = context.Request; var authorization = (string)request.Headers["Authorization"]; if (authorization == null || authorization?.Split(' ').Length != 2 || HasInvalidAuthHeader(authorization)) { context.Response = new UnauthorizedObjectResult(string.Empty); return; } try { var token = authorization.Split(' ')[1]; var principal = ExtractClaimFromExternalJwt(token); AddCustomClaims(authorization, principal, request.HttpContext); acessor.HttpContext = context.Request.HttpContext; } catch (Exception e) { serverlessLogger.LogError(e, $"[{nameof(AuthenticationMiddleware)}] {e.Message}"); context.Response = GetForbiddenContent(e); return; } }
/// <inheritdoc/> public override async Task InvokeAsync(IHttpFunctionContext context) { SetHeaderWithCorrelationId(context); SetHeaderWithRequestId(context); await Next.InvokeAsync(context).ConfigureAwait(false); }
/// <inheritdoc /> public override async Task InvokeAsync(IHttpFunctionContext context) { if (string.Equals(context.Request.Method, "OPTIONS", StringComparison.OrdinalIgnoreCase)) { var actionResult = new OkObjectResult("OK"); if (context.Request.Headers.ContainsKey("Origin")) { context.Request.HttpContext.Response.Headers.Add("Access-Control-Allow-Credentials", "true"); context.Request.HttpContext.Response.Headers.Add("Access-Control-Allow-Origin", "*"); context.Request.HttpContext.Response.Headers.Add("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS, PUT, PATCH, POST, DELETE"); context.Request.HttpContext.Response.Headers.Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept"); } context.ActionResult = actionResult; } else { await Next?.InvokeAsync(context); if (context.ActionResult != null) { context.Request.HttpContext.Response.Headers.Add("Access-Control-Allow-Origin", "*"); } } }
public override async Task InvokeAsync(IHttpFunctionContext context) { try { await Next?.InvokeAsync(context); } catch (EntityNotFoundException entityNotFoundEx) { context.ActionResult = new NotFoundObjectResult(entityNotFoundEx.Message); } catch (ValidationException validationEx) { var errors = validationEx.Errors.Select(e => new { e.ErrorMessage, e.PropertyName }); var model = new { Description = "Entity validation errors. See 'errors' property for more details", Errors = errors }; context.ActionResult = new BadRequestObjectResult(JsonConvert.SerializeObject(model)); } catch (ConcurrencyException concurrencyEx) { context.ActionResult = new ConflictObjectResult(concurrencyEx.Message); } catch (RepositoryException repositoryEx) { context.Logger.LogError(repositoryEx, repositoryEx.Message); context.ActionResult = new InternalServerErrorResult(); } }
/// <inheritdoc/> public override async Task InvokeAsync(IHttpFunctionContext context) { var hasError = true; Exception exception = null; try { await Next.InvokeAsync(context).ConfigureAwait(false); hasError = false; } catch (UnauthorizedAccessException ex) { exception = ex; context.Response = new UnauthorizedResult(); } catch (Exception ex) { exception = ex; context.Response = GetUnpredictableResult(context.Request, ex); } finally { if (hasError) { serverlessLogger.LogError(exception, $"[{nameof(ExceptionMiddleware)}]"); } } }
public override async Task InvokeAsync(IHttpFunctionContext context) { if (context.ClaimsPrincipal == null) { context.Logger.LogDebug("Bearer Token or API Key must be provided"); context.ActionResult = new UnauthorizedResult(); return; } context.Request.Query.TryGetValue("vin", out StringValues vin); if (string.IsNullOrWhiteSpace(vin)) { context.ActionResult = new BadRequestObjectResult("vin is required"); return; } context.Logger.LogInformation( "Odometer request received for: {UserName}", context.ClaimsPrincipal.Identity.Name); var odometerDto = await _getOdometerReading.GetOdometerReadingAsync(vin); context.ActionResult = odometerDto == null ? (new NotFoundObjectResult("Odometor info not found") as IActionResult) : (new OkObjectResult(odometerDto) as IActionResult); }
public override async Task InvokeAsync(IHttpFunctionContext context) { context.Logger.LogInformation("Getting all streams..."); var models = await _streamService.GetAllStreamsAsync(); context.ActionResult = new OkObjectResult(models); }
public override async Task InvokeAsync(IHttpFunctionContext context) { context.Request.Query.TryGetValue("streamName", out StringValues streamName); await _streamService.DeleteSnapshotsAsync(streamName); context.ActionResult = new NoContentResult(); context.Logger.LogInformation("Deleted snapshots for stream {streamName}", streamName); }
public override async Task InvokeAsync(IHttpFunctionContext context) { context.Logger.LogInformation("Getting snapshots..."); context.Request.Query.TryGetValue("streamName", out StringValues streamName); var models = await _streamService.GetSnapshotsAsync(streamName); context.ActionResult = new OkObjectResult(models); }
/// <inheritdoc /> public override async Task InvokeAsync(IHttpFunctionContext context) { var headerKey = _apiKeyValidator.HeaderName; var header = context.Request.Headers.TryGetValue(headerKey, out StringValues apiKey); if (!string.IsNullOrWhiteSpace(apiKey)) { context.ClaimsPrincipal = await _apiKeyValidator.ValidateAsync(apiKey); } await Next?.InvokeAsync(context); }
public override async Task InvokeAsync(IHttpFunctionContext context) { context.Logger.LogInformation("Getting events..."); context.Request.Query.TryGetValue("streamName", out StringValues streamName); context.Request.Query.TryGetValue("startAtVersion", out StringValues startAtVersionAsString); int.TryParse(startAtVersionAsString, out int startAtVersion); var models = await _streamService.GetEventsAsync(streamName, startAtVersion); context.ActionResult = new OkObjectResult(models); }
public override async Task InvokeAsync(IHttpFunctionContext context) { context.Logger.LogInformation("Finding stream..."); context.Request.Query.TryGetValue("streamName", out StringValues streamName); var model = await _streamService.GetStreamAsync(streamName); if (model == null) { throw new EntityNotFoundException($"Stream with name '{streamName}' not found"); } context.ActionResult = new OkObjectResult(model); }
/// <inheritdoc /> public override async Task InvokeAsync(IHttpFunctionContext context) { var header = context.Request.Headers .FirstOrDefault(q => q.Key.Equals("Authorization") && q.Value.Count > 0); var bearerToken = header.Value.FirstOrDefault()?.Substring("Bearer ".Length).Trim() ?? string.Empty; if (!string.IsNullOrWhiteSpace(bearerToken)) { context.ClaimsPrincipal = await _bearerTokenValidator.ValidateAsync(bearerToken); } await Next?.InvokeAsync(context); }
/// <inheritdoc/> public override async Task InvokeAsync(IHttpFunctionContext context) { var start = DateTime.UtcNow; try { await Next.InvokeAsync(context).ConfigureAwait(false); } finally { var end = DateTime.UtcNow; await serverlessLogger .LogFunctionAsync(context.Request, context.Response, start, end) .ConfigureAwait(false); } }
public override async Task InvokeAsync(IHttpFunctionContext context) { try { await Next?.InvokeAsync(context); } catch (Exception e) { // Map each exception to appropriate HTTP status code/message... var message = $"ExceptionMiddleware: {e.Message}"; context.Logger.LogError(e, message); context.ActionResult = new BadRequestObjectResult(message); } }
private static void SetHeaderWithRequestId(IHttpFunctionContext context) { var request = context.Request; var requestId = Guid.NewGuid().ToString(); var containsKey = request.Headers.ContainsKey(Constants.HeaderNameRequestId); if (!containsKey) { request.Headers.Add(Constants.HeaderNameRequestId, requestId); return; } request.Headers.TryGetValue(Constants.HeaderNameRequestId, out var requestIdHeader); if (string.IsNullOrWhiteSpace(requestIdHeader.FirstOrDefault())) { request.Headers.Remove(Constants.HeaderNameRequestId); request.Headers.Add(Constants.HeaderNameRequestId, requestId); } }
/// <inheritdoc/> public override async Task InvokeAsync(IHttpFunctionContext context) { CheckAuthHeader(context); int?statusCode = null; if (context.Response is ContentResult) { statusCode = ((ContentResult)context.Response).StatusCode; } if (!statusCode.HasValue && context.Response is ObjectResult) { statusCode = ((ObjectResult)context.Response).StatusCode; } if (statusCode.GetValueOrDefault() != 401 && statusCode.GetValueOrDefault() != 403) { await Next.InvokeAsync(context).ConfigureAwait(false); } }
public override async Task InvokeAsync(IHttpFunctionContext context) { context.Logger.LogInformation("Appending events..."); using var reader = new StreamReader(context.Request.Body); var json = await reader.ReadToEndAsync(); var model = JsonConvert.DeserializeObject <AppendEvents>(json); if (model == null) { context.ActionResult = new BadRequestObjectResult("Invalid payload"); return; } await _streamService.AppendEventsAsync(model); context.ActionResult = new NoContentResult(); }
public override async Task InvokeAsync(IHttpFunctionContext context) { logger.LogInformation($"[{nameof(GetCustomerByIdFunctionMiddleware)}] HTTP function processing a request."); if (!ValidateRequest(id)) { context.Response = badRequestPresenter.ResponseModel; return; } var command = mapper.Map <GetCustomerByIdCommand>(Guid.Parse(id)); var result = await mediator .Send(command) .ConfigureAwait(false); presenter.Populate(result); context.Response = presenter.ResponseModel; logger.LogInformation($"[{nameof(GetCustomerByIdFunctionMiddleware)}] HTTP function processed a request."); }
/// <inheritdoc/> public async Task <IActionResult> ExecuteAsync(IHttpFunctionContext context) { try { if (pipeline.Any()) { await pipeline[0].InvokeAsync(context).ConfigureAwait(false); if (context.Response != null) { return(context.Response); } } throw new Exception(); } catch (Exception e) { serverlessLogger.LogError(e, $"[{nameof(MiddlewarePipeline)}] {e.Message}"); return(new StatusCodeResult((int)HttpStatusCode.InternalServerError)); throw; } }
public override async Task InvokeAsync(IHttpFunctionContext context) { logger.LogInformation($"[{nameof(CreateCustomerFunctionMiddleware)}] HTTP function processing a request."); var requestModel = await req.ExtractRequestBody <CreateCustomerRequestModel>() .ConfigureAwait(false); if (!ValidateRequest(requestModel)) { context.Response = badRequestPresenter.ResponseModel; return; } var command = mapper.Map <CreateCustomerCommand>(requestModel); var result = await mediator.Send(command) .ConfigureAwait(false); presenter.Populate(result); context.Response = presenter.ResponseModel; logger.LogInformation($"[{nameof(CreateCustomerFunctionMiddleware)}] HTTP function processed a request."); }
/// <summary> /// Execute middleware. /// </summary> /// <param name="context">Function context.</param> /// <returns>Task result.</returns> public abstract Task InvokeAsync(IHttpFunctionContext context);