AWS examples in C# - introduction to Serverless framework

service: DynamoDbServerless

provider:
  name: aws
  runtime: dotnetcore2.1
  iamRoleStatements:
    - Effect: "Allow"
      Action:
        - dynamodb:Query
      Resource: ${env:actorsTableArn}
    - Effect: "Allow"
      Action:
        - dynamodb:DescribeTable
        - dynamodb:GetItem
      Resource: ${env:moviesTableArn}
  apiKeys:
    - aws-examples-csharp-api-key

package:
  individually: true
  artifact: bin/release/netcoreapp2.1/DynamoDbServerless.zip

functions:
  movies:
    handler: DynamoDbServerless::DynamoDbServerless.Handlers.MoviesHandler::GetMovie
    events:
      - http:
          path: movies/title/{title}
          method: get

  actors:
    handler: DynamoDbServerless::DynamoDbServerless.Handlers.ActorsHandler::QueryActors
    events:
      - http:
          path: actors/search
          method: post
          private: true
          authorizer: authorizer

  authorizer:
    handler: DynamoDbServerless::DynamoDbServerless.Handlers.AuthorizationHandler::Authorize

public async Task<APIGatewayProxyResponse> QueryActors(APIGatewayProxyRequest request, ILambdaContext context)
{
    context.Logger.LogLine($"Query request: {_jsonConverter.SerializeObject(request)}");

    var requestBody = _jsonConverter.DeserializeObject<ActorsSearchRequest>(request.Body);
    if (string.IsNullOrEmpty(requestBody.FirstName))
    {
        return new APIGatewayProxyResponse
        {
            StatusCode = (int)HttpStatusCode.BadRequest,
            Body = "FirstName is mandatory"
        };
    }
    var queryRequest = BuildQueryRequest(requestBody.FirstName, requestBody.LastName);

    var response = await _dynamoDbReader.QueryAsync(queryRequest);
    context.Logger.LogLine($"Query result: {_jsonConverter.SerializeObject(response)}");

    var queryResults = BuildActorsResponse(response);

    return new APIGatewayProxyResponse
    {
        StatusCode = (int)HttpStatusCode.OK,
        Body = _jsonConverter.SerializeObject(queryResults)
    };
}

public async Task<APIGatewayProxyResponse> GetMovie(APIGatewayProxyRequest request, ILambdaContext context)
{
    context.Logger.LogLine($"Query request: {_jsonConverter.SerializeObject(request)}");

    var title = WebUtility.UrlDecode(request.PathParameters["title"]);
    var document = await _dynamoDbReader.GetDocumentAsync(TableName, title);
    context.Logger.LogLine($"Query response: {_jsonConverter.SerializeObject(document)}");

    if (document == null)
    {
        return new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.NotFound };
    }

    var movie = new Movie
    {
        Title = document["Title"],
        Genre = (MovieGenre)int.Parse(document["Genre"])
    };
    return new APIGatewayProxyResponse
    {
        StatusCode = (int)HttpStatusCode.OK,
        Body = _jsonConverter.SerializeObject(movie)
    };
}

public async Task<APIGatewayCustomAuthorizerResponse> Authorize(APIGatewayCustomAuthorizerRequest request, ILambdaContext context)
{
    context.Logger.LogLine($"Query request: {_jsonConverter.SerializeObject(request)}");

    var userInfo = await _userManager.Authorize(request.AuthorizationToken?.Replace("Bearer ", string.Empty));

    return new APIGatewayCustomAuthorizerResponse
    {
        PrincipalID = userInfo.UserId,
        PolicyDocument = new APIGatewayCustomAuthorizerPolicy
        {
            Version = "2012-10-17",
            Statement = new List<APIGatewayCustomAuthorizerPolicy.IAMPolicyStatement>
            {
                new APIGatewayCustomAuthorizerPolicy.IAMPolicyStatement
                {
                    Action = new HashSet<string> {"execute-api:Invoke"},
                    Effect = userInfo.Effect.ToString(),
                    Resource = new HashSet<string> { request.MethodArn }
                }
            }
        }
    };
}

public interface IUserManager
{
    Task<UserInfo> Authorize(string token);
}

public class UserManager : IUserManager
{
    private const string ValidToken = "validToken";
    private const string UserId = "usedId";

    public async Task<UserInfo> Authorize(string token)
    {
        var userInfo = new UserInfo
        {
            UserId = UserId,
            Effect = token == ValidToken ? EffectType.Allow : EffectType.Deny
        };

        return userInfo;
    }
}