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);
