public APIGatewayHttpApiV2ProxyResponse Update(APIGatewayHttpApiV2ProxyRequest request)
{
var notes = getNotes();
var noteId = request.PathParameters["id"];
if (notes.ContainsKey(noteId))
{
Console.WriteLine(request.Body);
var body = JsonSerializer.Deserialize <Dictionary <string, string> >(request.Body);
var note = notes[noteId];
note.Content = body["content"];
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = JsonSerializer.Serialize <Note>(note, jsonSerializeOptions),
});
}
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.NotFound,
Body = JsonSerializer.Serialize <Dictionary <string, bool> >(new Dictionary <string, bool> {
["error"] = true
}),
});
}
public async Task<APIGatewayHttpApiV2ProxyResponse> InvokeAPIGatewayHttpApiV2ProxyAsync(
Func<APIGatewayHttpApiV2ProxyRequest, ILambdaContext, Task<APIGatewayHttpApiV2ProxyResponse>> asyncHandler,
APIGatewayHttpApiV2ProxyRequest request,
ILambdaContext context,
string operationName = null,
IDictionary<string, string> tags = null)
{
using (var tracker = new TelemetryTracker(context, operationName, tags, request.Headers))
{
try
{
APIGatewayHttpApiV2ProxyResponse apiGatewayProxyResponse = await asyncHandler(request, context);
if (!apiGatewayProxyResponse.IsSuccessStatusCode())
{
tracker.SetErrorCounter();
// Preserve the legacy logging.
LambdaLogger.Log($"[ERR] Invoking lambda function. Http status code: {apiGatewayProxyResponse.StatusCode}. Response body: {apiGatewayProxyResponse.Body}{Environment.NewLine}");
}
return apiGatewayProxyResponse;
}
catch (Exception e)
{
tracker.SetException(e);
throw;
}
}
}
public async Task <APIGatewayHttpApiV2ProxyResponse> FunctionHandler(APIGatewayHttpApiV2ProxyRequest eventTrigger)
{
Console.WriteLine(JsonSerializer.Serialize(eventTrigger));
var body = eventTrigger.Body;
if (eventTrigger.IsBase64Encoded)
{
body = Encoding.UTF8.GetString(Convert.FromBase64String(body));
}
// Add "id" from path parameters to JSON body
var data = JsonSerializer.Deserialize <Dictionary <string, dynamic> >(body);
data["id"] = eventTrigger.PathParameters["id"];
var dataJSON = JsonSerializer.Serialize(data);
var client = new AmazonDynamoDBClient();
var table = Table.LoadTable(client, Environment.GetEnvironmentVariable("TABLE_NAME"));
await table.PutItemAsync(Document.FromJson(dataJSON));
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = 204
});
}
/// <summary>
/// A Lambda function that returns the blog identified by blogId
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <APIGatewayHttpApiV2ProxyResponse> GetBlogAsync(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext context)
{
string blogId = null;
if (request.PathParameters != null && request.PathParameters.ContainsKey(ID_QUERY_STRING_NAME))
{
blogId = request.PathParameters[ID_QUERY_STRING_NAME];
}
else if (request.QueryStringParameters != null && request.QueryStringParameters.ContainsKey(ID_QUERY_STRING_NAME))
{
blogId = request.QueryStringParameters[ID_QUERY_STRING_NAME];
}
if (string.IsNullOrEmpty(blogId))
{
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.BadRequest,
Body = $"Missing required parameter {ID_QUERY_STRING_NAME}"
});
}
context.Logger.LogLine($"Getting the blog {blogId}");
var response = new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = $"Fetched blog {blogId}",
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
}
};
return(response);
}
public APIGatewayHttpApiV2ProxyResponse List(APIGatewayHttpApiV2ProxyRequest request)
{
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = JsonSerializer.Serialize <Dictionary <string, Note> >(getNotes(), jsonSerializeOptions),
});
}
/// <summary>
/// The Handler function triggered by the AWS APIGateway.
/// </summary>
/// <param name="gwEvent">Data passed from the APIGateway to the handler. The Handler only checks for one QueryParameter withe the name "d" and then tries to decode its value.</param>
/// <returns>The response that will beconverted to a HTTP response by the API Gateway</returns>
/// <example>Parameter d structure: content of the parameter is aes encrypted and base62 encoded. Format: "[optional salt];[validuntil ISO 8601];[target url urlencoded];[target ip];[salt]*"</example>
public async Task <APIGatewayHttpApiV2ProxyResponse> Handler(APIGatewayHttpApiV2ProxyRequest gwEvent)
{
var key = Environment.GetEnvironmentVariable("ENCRYPTION_KEY");
var dataok = gwEvent.QueryStringParameters.TryGetValue("d", out var data);
if (!dataok)
{
return(new APIGatewayHttpApiV2ProxyResponse()
{
StatusCode = 400, Body = "Missing Data"
});
}
try
{
var prd = ProxyRequestDataDecoder.CreateFromEncodedAndEncrypted(data, key);
var body = $"ValidUntil: {prd.ValidUntil:O} - SourceIP: {prd.IP} - Url: {prd.Url}";
if (prd.ValidUntil < DateTime.Now)
{
LambdaLogger.Log($"Token outdated : {body}");
return(new APIGatewayHttpApiV2ProxyResponse()
{
StatusCode = 400, Body = "Token not valid anymore."
});
}
if (!prd.Debug)
{
var cli = new HttpClient();
LambdaLogger.Log($"Triggering Request: {body}");
var result = await cli.SendAsync(CreateRequest(prd));
LambdaLogger.Log($"Request result: {result.StatusCode}");
return(new APIGatewayHttpApiV2ProxyResponse()
{
StatusCode = 200, Body = "MyFunc"
});
}
else
{
LambdaLogger.Log($"Debug Request: {body}");
return(new APIGatewayHttpApiV2ProxyResponse()
{
StatusCode = 200, Body = body
});
}
}
catch (Exception ex)
{
LambdaLogger.Log($"Exception while processing: {ex.Message}");
LambdaLogger.Log(ex.StackTrace);
return(new APIGatewayHttpApiV2ProxyResponse()
{
StatusCode = 400, Body = ex.Message
});
}
}
public APIGatewayHttpApiV2ProxyResponse Handler(APIGatewayHttpApiV2ProxyRequest request)
{
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = $"Hello, World! Your request was received at {request.RequestContext.Time}.",
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
}
});
}
public APIGatewayHttpApiV2ProxyResponse Handler(APIGatewayHttpApiV2ProxyRequest request)
{
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = "Hello World!",
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
}
});
}
public async Task <APIGatewayHttpApiV2ProxyResponse> Handle(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext context)
{
var inner = JsonConvert.DeserializeObject <S3Event>(request.Body);
var result = await FunctionHandler(inner, context);
var response = new APIGatewayHttpApiV2ProxyResponse
{
Body = JsonConvert.SerializeObject(result)
};
return(response);
}
public async Task <APIGatewayHttpApiV2ProxyResponse> Handle(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext context)
{
var json = UTF8Encoding.UTF8.GetBytes(request.Body);
var inner = JsonSerializer.Deserialize <S3Event>(json);
var result = await FunctionHandler(inner, context);
var response = new APIGatewayHttpApiV2ProxyResponse
{
Body = JsonSerializer.Serialize(result)
};
return(response);
}
public APIGatewayProxyResponse FunctionHandler(APIGatewayHttpApiV2ProxyRequest apigProxyEvent, ILambdaContext context)
{
Console.WriteLine($"Processing request data for request {apigProxyEvent.RequestContext.RequestId}.");
Console.WriteLine($"Body size = {apigProxyEvent.Body.Length}.");
var headerNames = string.Join(", ", apigProxyEvent.Headers.Keys);
Console.WriteLine($"Specified headers = {headerNames}.");
return(new APIGatewayProxyResponse
{
Body = apigProxyEvent.Body,
StatusCode = 200,
});
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public bool FunctionHandler(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext context)
{
var input = JsonSerializer.Serialize(request);
context.Logger.LogLine($"req: {input}");
var options = new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
};
var user = JsonSerializer.Deserialize <User>(request.Body, options);
var isAuthorized = false;
if (user.Roles.Contains("admin"))
{
isAuthorized = true;
}
context.Logger.LogLine($"User: {user.Name}, authorized: {isAuthorized}");
return(isAuthorized);
}
public APIGatewayHttpApiV2ProxyResponse Get(APIGatewayHttpApiV2ProxyRequest request)
{
var notes = getNotes();
var noteId = request.PathParameters["id"];
if (notes.ContainsKey(noteId))
{
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = JsonSerializer.Serialize <Note>(notes[noteId], jsonSerializeOptions),
});
}
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.NotFound,
Body = JsonSerializer.Serialize <Dictionary <string, bool> >(new Dictionary <string, bool> {
["error"] = true
}),
});
}
public Tuple <double, double> Add([FromBody] string complexNumbers, ILambdaContext context, APIGatewayHttpApiV2ProxyRequest request)
{
context.Logger.Log($"Request {JsonSerializer.Serialize(request)}");
var components = complexNumbers.Split(";");
if (components.Length != 2)
{
throw new ArgumentException(@$ "Complex numbers must be in format " "1,2;3,4" ", but found " "{complexNumbers}" "");
}
var firstComponent = components[0].Split(",");
if (firstComponent.Count() != 2)
{
throw new ArgumentException(@$ "Complex number must be in format " "1,2" ", but found " "{firstComponent}" "");
}
var secondComponent = components[1].Split(",");
if (secondComponent.Count() != 2)
{
throw new ArgumentException(@$ "Complex number must be in format " "1,2" ", but found " "{secondComponent}" "");
}
var c1 = new Complex(int.Parse(firstComponent[0]), int.Parse(firstComponent[1]));
var c2 = new Complex(int.Parse(secondComponent[0]), int.Parse(secondComponent[1]));
var result = c1 + c2;
return(new Tuple <double, double>(result.Real, result.Imaginary));
}
/// <inheritdoc />
/// <summary>
/// This overriding method is what the Lambda function handler points to.
/// </summary>
public override async Task <APIGatewayHttpApiV2ProxyResponse> FunctionHandlerAsync(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext lambdaContext)
{
if (!TelemetryConfiguration.TracingEnabled && !TelemetryConfiguration.MetricsEnabled)
{
return(await base.FunctionHandlerAsync(request, lambdaContext).ConfigureAwait(false));
}
return(await s_functionWrapper.InvokeAPIGatewayHttpApiV2ProxyAsync(
base.FunctionHandlerAsync,
request,
lambdaContext).ConfigureAwait(false));
}
/// <summary>
/// Amazon EventBridge event schedule rule to keep the Lambda/s warm
/// Payload: { "RouteKey": "WarmingLambda", "Body": "3" }
/// </summary>
/// <param name="request"></param>
/// <param name="lambdaContext"></param>
/// <returns></returns>
public override async Task <APIGatewayHttpApiV2ProxyResponse> FunctionHandlerAsync(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext lambdaContext)
{
LambdaLogger.Log("In overridden FunctionHandlerAsync...");
if (request.RouteKey == "WarmingLambda")
{
int.TryParse(request.Body, out var concurrencyCount);
if (concurrencyCount > 1)
{
LambdaLogger.Log($"Warming instance {concurrencyCount}.");
var client = new AmazonLambdaClient();
await client.InvokeAsync(new InvokeRequest
{
FunctionName = lambdaContext.FunctionName,
InvocationType = InvocationType.RequestResponse,
Payload = JsonSerializer.Serialize(new APIGatewayHttpApiV2ProxyRequest
{
RouteKey = request.RouteKey,
Body = (concurrencyCount - 1).ToString()
})
});
}
return(new APIGatewayHttpApiV2ProxyResponse());
}
return(await base.FunctionHandlerAsync(request, lambdaContext));
}
public async Task <APIGatewayHttpApiV2ProxyResponse> InboundParse(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext context)
{
APIGatewayHttpApiV2ProxyResponse response;
var getParameterResponse = await _ssmClient.GetParameterAsync(new GetParameterRequest
{
Name = AuthenticationKeyParameterName,
WithDecryption = true
});
var authenticationKey = getParameterResponse?.Parameter?.Value;
string authenticationKeyPresented = null;
request.QueryStringParameters?.TryGetValue(AuthenticationQueryParameterKey, out authenticationKeyPresented);
if (string.IsNullOrEmpty(authenticationKeyPresented) || string.IsNullOrEmpty(authenticationKey) ||
authenticationKeyPresented != authenticationKey)
{
context.Logger.LogLine($"Failed to authenticate.");
return(new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.Unauthorized
});
}
try
{
context.Logger.LogLine("Request Headers:");
foreach (var header in request.Headers)
{
context.Logger.LogLine($"{header.Key}: {header.Value}");
}
context.Logger.LogLine($"Request IsBase64Encoded:\n{request.IsBase64Encoded}");
context.Logger.LogLine($"Request Body:\n{request.Body}");
var requestBody = new MemoryStream(Convert.FromBase64String(request.Body));
var parser = new WebhookParser();
var inboundEmail = parser.ParseInboundEmailWebhook(requestBody);
context.Logger.LogLine($"InboundEmail Subject:\n{inboundEmail.Subject}");
context.Logger.LogLine($"InboundEmail To:\n{inboundEmail.To[0].Email}");
context.Logger.LogLine($"InboundEmail From:\n{inboundEmail.From.Email}");
context.Logger.LogLine($"InboundEmail DKIM:\n{inboundEmail.Dkim}");
context.Logger.LogLine($"InboundEmail SPF:\n{inboundEmail.Spf}");
context.Logger.LogLine($"InboundEmail Envelope.From:\n{inboundEmail.Envelope.From}");
response = new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = "Success",
Headers = new Dictionary <string, string> {
{ "Content-Type", "text/plain" }
}
};
}
catch (Exception ex)
{
var exception = ex.ToString();
context.Logger.LogLine($"Exception occurred:\n{exception}");
response = new APIGatewayHttpApiV2ProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = ex.Message,
Headers = new Dictionary <string, string> {
{ "Content-Type", "text/plain" }
}
};
}
return(response);
}
