public async Task <APIGatewayProxyResponse> Handler(APIGatewayProxyRequest input, ILambdaContext context) { var client = new AmazonDynamoDBClient(); var attributes = new Dictionary <string, AttributeValue>(); try { attributes["connectionId"] = new AttributeValue { S = input.RequestContext.ConnectionId }; } catch (Exception e) { return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.InternalServerError, Body = e.Message, Headers = new Dictionary <string, string> { { "Content-Type", "text/plain" } }, }); } var request = new PutItemRequest { TableName = Environment.ExpandEnvironmentVariables("%TABLE_NAME%"), Item = attributes }; var result = await client.PutItemAsync(request); return(new APIGatewayProxyResponse { StatusCode = (int)result.HttpStatusCode, Body = (result.HttpStatusCode == HttpStatusCode.OK) ? "connected" : "failed to connect", Headers = new Dictionary <string, string> { { "Content-Type", "text/plain" } }, }); }
public APIGatewayProxyResponse Handler(APIGatewayProxyRequest input, ILambdaContext context) { var config = new AmazonSimpleNotificationServiceConfig(); config.ServiceURL = Environment.ExpandEnvironmentVariables("%SNSENDPOINT%"); var client = new AmazonSimpleNotificationServiceClient(config); var request = new PublishRequest { TopicArn = Environment.ExpandEnvironmentVariables("%TOPICARN%"), Message = input.Body, }; try { client.PublishAsync(request).Wait(); } catch (Exception e) { return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.InternalServerError, Body = e.Message, Headers = new Dictionary <string, string> { { "Content-Type", "text/plain" } }, }); } context.Logger.LogLine("PublishAsync completed\n"); return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.OK, Body = input.Body, Headers = new Dictionary <string, string> { { "Content-Type", "text/plain" } }, }); }
/// <summary> /// Populates the OwinContext with values from the proxy request. /// </summary> /// <param name="owinContext"></param> /// <param name="proxyRequest"></param> protected virtual async Task MarshalRequest(OwinContext owinContext, APIGatewayProxyRequest proxyRequest) { // The scheme is not available on the proxy request. If needed, it should be transported over custom header // and this MarshalRequest overridden. owinContext.Set(APIGatewayProxyRequestKey, proxyRequest); owinContext.Request.Scheme = "http"; owinContext.Request.Method = proxyRequest.HttpMethod; owinContext.Request.Body = _memoryStreamManager.GetStream(proxyRequest.Body); var writer = new StreamWriter(owinContext.Request.Body) { AutoFlush = true }; await writer.WriteAsync(proxyRequest.Body); owinContext.Request.Body.Position = 0; if (proxyRequest.Headers != null) { foreach (var header in proxyRequest.Headers) { owinContext.Request.Headers.AppendCommaSeparatedValues(header.Key, header.Value.Split(',')); } } owinContext.Request.Path = new PathString(proxyRequest.Path); if (proxyRequest.QueryStringParameters != null) { var sb = new StringBuilder(); var encoder = UrlEncoder.Default; foreach (var kvp in proxyRequest.QueryStringParameters) { if (sb.Length > 1) { sb.Append("&"); } sb.Append($"{encoder.Encode(kvp.Key)}={encoder.Encode(kvp.Value)}"); } owinContext.Request.QueryString = new QueryString(sb.ToString()); } owinContext.Response.Body = _memoryStreamManager.GetStream(); }
public override async Task <APIGatewayProxyResponse> FunctionHandlerAsync(APIGatewayProxyRequest request, ILambdaContext lambdaContext) { if (string.IsNullOrEmpty(request.HttpMethod)) // For backward compatibility { if (request.Headers != null) { if (request.Headers.ContainsKey(Concurrency)) { var concurrency = int.Parse(request.Headers[Concurrency]); await KeepAlive(concurrency - 1, KeepAliveInvocation); } if (request.Headers.ContainsKey(KeepAliveInvocation)) { Thread.Sleep(75); // To mitigate lambda reuse } if (!Warm && !request.Headers.Keys.Any(key => key == Concurrency || key == KeepAliveInvocation)) { LambdaLogger.Log($"[Info] Customer affected by coldstart"); } } lambdaContext.Logger.Log(JsonConvert.SerializeObject(request)); if (Warm) { lambdaContext.Logger.Log("ping"); return(new APIGatewayProxyResponse()); } request.HttpMethod = "GET"; request.Path = "/ping"; request.Headers = new Dictionary <string, string> { { "Host", "localhost" } }; request.RequestContext = new APIGatewayProxyRequest.ProxyRequestContext(); lambdaContext.Logger.LogLine("Keep-alive invocation"); } Warm = true; return(await base.FunctionHandlerAsync(request, lambdaContext)); }
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context) { VehicleRegistration vehicleRegistration = JsonConvert.DeserializeObject <VehicleRegistration>(request.Body); return(this.qldbDriver.Execute(transactionExecutor => { context.Logger.Log($"Looking for person document ID {vehicleRegistration.Owners?.PrimaryOwner?.PersonId}."); string primaryOwnerPersonDocumentId = this.tableMetadataService.GetDocumentId(transactionExecutor, PersonTableName, "GovId", vehicleRegistration.Owners?.PrimaryOwner?.PersonId); if (string.IsNullOrWhiteSpace(primaryOwnerPersonDocumentId)) { context.Logger.Log($"No person found with GovId {vehicleRegistration.Owners?.PrimaryOwner?.PersonId}, returning not found."); return new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.NotFound }; } context.Logger.Log($"Checking vehicle registration already exists for VIN {vehicleRegistration.Vin}."); if (CheckIfVinAlreadyExists(transactionExecutor, vehicleRegistration.Vin)) { context.Logger.Log($"Vehicle registration does exist for VIN {vehicleRegistration.Vin}, returning not modified."); return new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.NotModified }; } context.Logger.Log($"Inserting vehicle registration for VIN {vehicleRegistration.Vin}."); vehicleRegistration.Owners.PrimaryOwner.PersonId = primaryOwnerPersonDocumentId; IIonValue ionVehicleRegistration = ConvertObjectToIonValue(vehicleRegistration); transactionExecutor.Execute($"INSERT INTO VehicleRegistration ?", ionVehicleRegistration); context.Logger.Log($"Inserted vehicle registration for VIN {vehicleRegistration.Vin}, returning OK."); return new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.OK }; })); }
/// <summary> Internal executing (extract parameters and workaround code) </summary> private async Task <APIGatewayProxyResponse> InternalExecute(APIGatewayProxyRequest request, Func <string, Task <BasketEditResult> > executeFunc, ILogger?logger) { try { this.Basket.SetLogger(logger); if (request.PathParameters != null && request.PathParameters.ContainsKey("word") ) { var word = request.PathParameters["word"]; await this.Basket.SaveStat(word, new TimeSpan()); var result = await executeFunc(word); return(new APIGatewayProxyResponse { StatusCode = result.Result == BasketEditResult.EnumResult.Ok ? (int)HttpStatusCode.OK : (int)HttpStatusCode.InternalServerError, Body = JsonConvert.SerializeObject(result) }); } return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.InternalServerError, Body = "'word' path not found" }); } catch (Exception e) { return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.InternalServerError, Body = "Exception " + e.Message + "\n" + e.ToString() }); } }
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context) { var clientDomain = "https://www.primordial-software.com"; var response = new APIGatewayProxyResponse { Headers = new Dictionary <string, string> { { "access-control-allow-origin", clientDomain }, { "Access-Control-Allow-Credentials", "true" } }, StatusCode = 200 }; try { List <IRoute> routes = new List <IRoute> { }; var matchedRoute = routes.FirstOrDefault(route => string.Equals(request.HttpMethod, route.HttpMethod, StringComparison.OrdinalIgnoreCase) && string.Equals(request.Path, route.Path, StringComparison.OrdinalIgnoreCase)); if (matchedRoute != null) { matchedRoute.Run(request, response); } else { response.StatusCode = 404; response.Body = PropertyRentalManagement.Constants.JSON_EMPTY; } } catch (Exception exception) { Console.WriteLine(exception); response.StatusCode = 500; response.Body = new JObject { { "error", exception.ToString() } }.ToString(); } return(response); }
public async Task HandleRequestAsync_ValidRequest_InvokesVehicleDataServiceImportVehicleDataAsyncWithExpectedArgs() { // Arrange const int expectedCustomerId = 1; const string expectedVIN = "VIN"; var fakeValidateVIN = A.Fake <IValidateVIN>(); A.CallTo(() => fakeValidateVIN.IsValid(expectedVIN)).Returns(true); var fakeVehicleDataService = A.Fake <IVehicleDataService>(); IServiceProvider sp = new ServiceCollection() .AddSingleton(fakeValidateVIN) .AddSingleton(fakeVehicleDataService) .BuildServiceProvider(); var context = A.Fake <ILambdaContext>(); A.CallTo(() => context.Logger).Returns(A.Fake <ILambdaLogger>()); var importRequest = new ImportRequest { CustomerId = expectedCustomerId, VIN = expectedVIN }; APIGatewayProxyRequest dummyRequestEvent = new APIGatewayProxyRequest { Body = JsonConvert.SerializeObject(importRequest) }; var sut = new ImportHandler(sp); // Act await sut.HandleRequestAsync(dummyRequestEvent, context); // Assert A.CallTo(() => fakeVehicleDataService.ImportVehicleDataAsync(expectedCustomerId, expectedVIN)).MustHaveHappenedOnceExactly(); }
/// <summary> /// A Lambda function that returns the bid identified by bidId /// </summary> /// <param name="request"></param> /// <returns></returns> public async Task <APIGatewayProxyResponse> GetBidsByProductIdAsync(APIGatewayProxyRequest request, ILambdaContext context) { string productId = null; if (request.PathParameters != null && request.PathParameters.ContainsKey(PRODUCT_ID_QUERY_STRING_NAME)) { productId = request.PathParameters[PRODUCT_ID_QUERY_STRING_NAME]; } else if (request.QueryStringParameters != null && request.QueryStringParameters.ContainsKey(PRODUCT_ID_QUERY_STRING_NAME)) { productId = request.QueryStringParameters[PRODUCT_ID_QUERY_STRING_NAME]; } if (string.IsNullOrEmpty(productId)) { return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.BadRequest, Body = $"Missing required parameter {ID_QUERY_STRING_NAME}" }); } context.Logger.LogLine($"Getting bids {productId}"); var conditions = new List <ScanCondition>(); conditions.Add(new ScanCondition("ProductId", Amazon.DynamoDBv2.DocumentModel.ScanOperator.Equal, productId)); var search = this.DDBContext.ScanAsync <Bid>(conditions); var page = await search.GetNextSetAsync(); context.Logger.LogLine($"Found {page.Count} bids"); var response = new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.OK, Body = JsonConvert.SerializeObject(page), Headers = HeaderHelper.GetHeaderAttributes() }; return(response); }
public APIGatewayProxyResponse CreateOrder(APIGatewayProxyRequest request, ILambdaContext context) { context.Logger.LogLine("CreateOrder Request\n"); var createOrderRequest = CreateOrderRequest.FromJson(request.Body); using ServiceProvider serviceProvider = _services.BuildServiceProvider(); var createOrderService = serviceProvider.GetService <ICreateOrderService>(); var mapper = serviceProvider.GetService <IMapper>(); try { var order = mapper.Map <OrderModel>(createOrderRequest.Order); var createdOrder = createOrderService.CreateOrderAsync(order) .GetAwaiter() .GetResult(); var responseOrder = mapper.Map <Order>(createdOrder); var body = responseOrder.ToJson(); var response = new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.Created, Body = body, Headers = new Dictionary <string, string> { { "Content-Type", "application/json" } } }; return(response); } catch (FluentValidation.ValidationException exception) { return(exception.CreateResponse()); } catch (Exception exception) { return(exception.CreateResponse()); } }
/// <summary> /// A Lambda function that downloads the image from S3 Bucket by s3ObjectKey. /// path for http request: download/{s3ObjectKey} /// </summary> /// <param name="request"></param> /// <param name="context"></param> /// <returns></returns> public async Task <APIGatewayProxyResponse> GetImageAsync(APIGatewayProxyRequest request, ILambdaContext context) { string s3ObjectKey = GetRequestParams(request); if (string.IsNullOrEmpty(s3ObjectKey)) { return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.BadRequest, Body = $"Missing required parameter {ID_QUERY_STRING_NAME}" }); } context.Logger.LogLine($"Getting object {s3ObjectKey}"); try { using GetObjectResponse objectResponse = await _S3Client.GetObjectAsync("conqlimabucket", s3ObjectKey); context.Logger.LogLine($"Found object: {s3ObjectKey != null}"); var response = new APIGatewayProxyResponse { IsBase64Encoded = true, StatusCode = (int)HttpStatusCode.OK, Body = Convert.ToBase64String(ReadStream(objectResponse.ResponseStream)), Headers = new Dictionary <string, string> { { "Content-Type", "*/*" } } }; return(response); } catch (Exception e) { return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.NotFound, Body = e.Message }); } }
public AuthenticationResult Authenticate(APIGatewayProxyRequest input) { if (!input.Headers.TryGetValue(XHubSignatureHeaderKey, out var signature) || string.IsNullOrWhiteSpace(signature)) { if (!bool.TryParse( Environment.GetEnvironmentVariable(RequireSignatureEnvironmentVariableName), out var requireSignature)) { // Require signature by default requireSignature = true; } return requireSignature ? AuthenticationResult.InvalidSignature : AuthenticationResult.SignatureNotRequired; } var secretToken = Environment.GetEnvironmentVariable(SecretTokenEnvironmentVariableName); if (string.IsNullOrWhiteSpace(secretToken)) { return AuthenticationResult.HasSignatureButMissingSecretToken; } if (!signature.StartsWith(SignaturePrefix)) { return AuthenticationResult.InvalidSignature; } if (string.IsNullOrWhiteSpace(input.Body)) { return AuthenticationResult.InvalidPayload; } if (!GenerateAndCompareSignature(secretToken, signature, input.Body)) { return AuthenticationResult.MismatchedSignature; } return AuthenticationResult.Success; }
public async Task <bool> SendAlerts(APIGatewayProxyRequest request, string guid) { var fields = await ParseAlert(request); foreach (var alert in _alerts) { var sourceIp = request.RequestContext.Identity.SourceIp; var res = await alert.SendAlert(fields, sourceIp, request.Path, guid); if (fields.Item1 != null) { await alert.StoreLogs(fields.Item1, res); } else { await alert.StoreLogs(sourceIp, res); } } return(fields.Item1 == null); }
public async Task <APIGatewayProxyResponse> FunctionHandler(APIGatewayProxyRequest apigProxyEvent, ILambdaContext context) { IBitcoinPriceCheck price = new BitcoinPriceCheck(); ITwitterProvider twitter = new TwitterProvider(); var res = await twitter.SendTweet(await price.Execute()); var body = new Dictionary <string, string> { { "tweet", res.Url }, }; return(new APIGatewayProxyResponse { Body = JsonConvert.SerializeObject(body), StatusCode = 204, Headers = new Dictionary <string, string> { { "Content-Type", "application/json" } } }); }
public APIGatewayProxyResponse Get(APIGatewayProxyRequest request, ILambdaContext context) { LambdaLogger.Log("body " + request.Body); if (request.Resource == "KeepWarm") { LambdaLogger.Log("Keeping warm run"); var response = new APIGatewayProxyResponse { StatusCode = 200 }; return(response); } else { LambdaLogger.Log("Regular run"); } var result = processor.CurrentTimeUTC(); return(CreateResponse(result)); }
public APIGatewayProxyResponse Hello(APIGatewayProxyRequest request, ILambdaContext context) { try{ context.Logger.LogLine("START"); context.Logger.LogLine("STOP"); } catch (Exception ex) { context.Logger.LogLine(ex.Message); } return(new APIGatewayProxyResponse() { StatusCode = 200, Body = JsonConvert.SerializeObject(new { msg = "Hello World!" }), Headers = new Dictionary <string, string> { { "Content-Type", "application/json" } } }); }
public async Task <APIGatewayProxyResponse> Scrape(APIGatewayProxyRequest request, ILambdaContext context) { Scraper Scraper = JsonConvert.DeserializeObject <Scraper>(request.Body); Scraper.Start(); var body = new Dictionary <string, string>() { { "title", Scraper.title }, { "body", Scraper.body } }; return(new APIGatewayProxyResponse { StatusCode = 200, Body = JsonConvert.SerializeObject(body), Headers = new Dictionary <string, string>() { { "Content-Type", "application/json" }, { "Access-Control-Allow-Origin", "*" } } }); }
public void TestGetMethod() { TestLambdaContext context; APIGatewayProxyRequest request; APIGatewayProxyResponse response; Functions functions = new Functions(); var car = new Model.Car() { Model = "Passat", Mileage = 150000, Make = "VW", Year = 1999 }; request = new APIGatewayProxyRequest(); context = new TestLambdaContext(); response = functions.Get(request, context); Assert.Equal(200, response.StatusCode); string result = JsonConvert.SerializeObject(car); Assert.Equal(result, response.Body); }
public async Task <APIGatewayProxyResponse> EventGet(APIGatewayProxyRequest request, ILambdaContext context) { var logger = context.Logger; logger.Log(JsonConvert.SerializeObject(request)); var messageId = request.PathParameters.ContainsKey("messageId") ? request.PathParameters["messageId"] : throw new HttpRequestException("Bad Request"); var businessEventStore = GetContainer(context).Resolve <IBusinessEventStore>(); var item = await businessEventStore.QueryByMessageId(messageId, 1); return(new APIGatewayProxyResponse() { StatusCode = 200, Headers = new Dictionary <string, string>() { { "Context-Type", "application/json" } }, Body = JsonConvert.SerializeObject(item) }); }
public void ListTransaction() { var function = new FunctionListTransaction(); var context = new TestLambdaContext(); var apiGateway = new APIGatewayProxyRequest { HttpMethod = "GET", Path = "list-transaction", Resource = "/dev/", Headers = new Dictionary <string, string>() { { "Content-Type", "application/json" } }, QueryStringParameters = new Dictionary <string, string> { { "id", "fgbOPGsBfKkxXf3E4Z5y" } } }; var _return = function.FunctionHandler(apiGateway, context); Assert.Equal(200, _return.StatusCode); }
public void GetMessage() { var function = new FunctionGetMessage(); var context = new TestLambdaContext(); var apiGateway = new APIGatewayProxyRequest { HttpMethod = "GET", Path = "get-message", Resource = "/dev/", Headers = new Dictionary <string, string>() { { "Content-Type", "application/json" } }, QueryStringParameters = new Dictionary <string, string> { { "id", "bwZ2NGsBfKkxXf3Ebp6g" } } }; var _return = function.FunctionHandler(apiGateway, context); Assert.Equal(200, _return.StatusCode); }
public APIGatewayProxyResponse GetStatusTraining(APIGatewayProxyRequest request, ILambdaContext context) { context.Logger.LogLine("Get Request\n"); var resp = request.Body; if (string.IsNullOrEmpty(resp)) { return(RetornaBadRequest("Debe enviar contenido en el Body")); } GetStatusTrainingReq createTrainingJobReq = JsonConvert.DeserializeObject <GetStatusTrainingReq>(resp); context.Logger.LogLine("Req " + resp); GetStatusTrainingRes createTrainingJobRes = new GetStatusTrainingRes(); createTrainingJobRes.Status = "COMPLETED"; //return RetornaOk<CreateTrainingJobRes>(createTrainingJobRes); return(RetornaOk(createTrainingJobRes)); }
public APIGatewayProxyResponse ValidateUser(APIGatewayProxyRequest request, ILambdaContext context) { context.Logger.LogLine("Get Request\n"); var resp = request.Body; if (string.IsNullOrEmpty(resp)) { return(RetornaBadRequest("Debe enviar contenido en el Body")); } ValidateUserReq createTrainingJobReq = JsonConvert.DeserializeObject <ValidateUserReq>(resp); context.Logger.LogLine("Req " + resp); ValidateUserRes createTrainingJobRes = new ValidateUserRes(); createTrainingJobRes.Token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI3MWNlNWUwYi1kMzViLTQ5NDUtYWNhNy1hMzA4Y2I5MzhjNGUiLCJ1c2VybmFtZSI6InRlc3QiLCJ0b2tlbl91c2UiOiJhY2Nlc3MiLCJpc3MiOiJodHRwczovL2NvZ25pdG8taWRwLnVzLWVhc3QtMS5hbWF6b25hd3MuY29tL3VzLWVhc3QtMV9lWEY2T1B3NDUiLCJpYXQiOjE1MzcxOTgzNjAsIm5iZiI6MTUzNzE5ODM2MCwiZXhwIjoxNTM3MjAxOTYwLCJqdGkiOiI2ZGUyNzA5ZjlmNGQ0MmZkYTFiOTE5Y2JlZDBkNjA4NCJ9.QMddu_77AUR7kn0TBwpDKJoVH7QOcLCOR9nlbRledNma7zSIqISFWHQsDXg0IaLnhkruCUsILwxg4fg9KFSyIckk_xb75YgOdVcgbR1CV_kHRiNJcRn42HmORFqf_AzFCOqTGSpjMWTtAOqRfFLr0sIIu8tHx5ogj6_sT-1I7L8urTNgDRlsd1SGn_Xt1UVQkSgQ-PUCnxf7sdFSOq6jvOpH44uTTLsP3g9TxAQyMkpJGWLwcMqXQlS1N8SlG-xzlTIoKN7Kz5TA73F7C9z1Wifg_A2SrOKY1OdN6F6K-hQK2t2D4fMXQWyhXUqoXEaWq_dROgfL1oi0Mlm2LGFPDw"; //return RetornaOk<CreateTrainingJobRes>(createTrainingJobRes); return(RetornaOk(createTrainingJobRes)); }
/// <summary> /// A Lambda function to respond to HTTP Get methods from API Gateway /// </summary> /// <param name="request"></param> /// <returns>The list of blogs</returns> public APIGatewayProxyResponse CreateTrainingJob(APIGatewayProxyRequest request, ILambdaContext context) { context.Logger.LogLine("Get Request\n"); var resp = request.Body; if (string.IsNullOrEmpty(resp)) { return(RetornaBadRequest("Debe enviar contenido en el Body CreateTrainingJob")); } CreateTrainingJobReq createTrainingJobReq = JsonConvert.DeserializeObject <CreateTrainingJobReq>(resp); context.Logger.LogLine("Req " + resp); CreateTrainingJobRes createTrainingJobRes = new CreateTrainingJobRes(); createTrainingJobRes.BankId = createTrainingJobReq.BankId; //return RetornaOk<CreateTrainingJobRes>(createTrainingJobRes); return(RetornaOk(createTrainingJobRes)); }
public async Task Register_Valid_Test() { var handler = new Function(_MockSP.Object); var request = new APIGatewayProxyRequest() { HttpMethod = "POST", Body = JsonConvert.SerializeObject(new Models.Endpoint() { UserId = "Test", EndpointUrl = "google.com", Token = "123456" }) }; var response = await handler.RegisterHandler(request, _MockContext.Object); Assert.AreEqual(200, response.StatusCode); _MockSP.Verify(f => f.GetService(typeof(IEndpointService)), Times.Once); _MockEndpoint.Verify(f => f.SaveEndpoint(It.IsAny <Models.Endpoint>()), Times.Once); }
public async Task <APIGatewayProxyResponse> Handle(APIGatewayProxyRequest request) { var idStr = request.PathParameters["id"]; if (!Guid.TryParse(idStr, out var id)) { return(Response.CreateError(HttpStatusCode.BadRequest, "Invalid photograph id")); } var photographTable = Table.LoadTable(_dynamoDb, TableNames.Photograph); var document = await photographTable.GetItemAsync(id); if (document == null) { return(Response.CreateError(HttpStatusCode.NotFound, "No photograph with the requested id was found")); } var model = PhotographSerialization.FromDocument(document); return(BuildResponseFromModel(model)); }
/// <summary> /// A Lambda function to respond to HTTP Get methods from API Gateway /// </summary> /// <param name="request"></param> /// <returns>The list of blogs</returns> public APIGatewayProxyResponse Handler(APIGatewayProxyRequest apigProxyEvent, ILambdaContext apigProxyContext) { try { var users = new List <User>(); int counter = 0; while (counter < 25) { users.Add(GetUser()); counter++; } return(JsonResponse.Send(true, "Success", users)); } catch (Exception e) { LambdaLogger.Log("Handler Error - " + e.Message); return(JsonResponse.Send(false, e.Message)); } }