/// <summary> /// Converts a new post's text into speech, uploads audio to S3 and updates post record with S3 URL /// </summary> /// <param name="ddbEvent"></param> /// <param name="lambdaContext"></param> /// <returns></returns> public async Task ConvertToAudio(DynamoDBEvent ddbEvent, ILambdaContext lambdaContext) { lambdaContext.Logger.LogLine("Executing from DynamoDB."); foreach (var record in ddbEvent.Records) { if (record.Dynamodb.OldImage.Count <= 0) { string id = record.Dynamodb.Keys["Id"].S; var post = await Context.LoadAsync <Post>(id); AudioConverter converter = new AudioConverter(); post.Url = await converter.ConvertAsync(id, post.Voice, post.Text); post.Status = "UPDATED"; try { await Context.SaveAsync <Post>(post); } catch (Exception ex) { lambdaContext.Logger.LogLine($"Couldn't update post with ID {post.Id}: {ex.Message}"); } } else { lambdaContext.Logger.LogLine("Record already updated."); } } }
public async Task Process(DynamoDBEvent dynamoDbEvent) { foreach (var record in dynamoDbEvent.Records) { Event @event = null; try { if (!record.Dynamodb.NewImage.ContainsKey("Data")) { await MarkAsDeadLetter(null, "DataStreamProcessor", new Exception("DynamoDB record contains no Data column")); continue; } var recordImage = record.Dynamodb.NewImage; @event = JsonConvert.DeserializeObject <Event>(recordImage["Data"].S.ToUncompressedString()); await subscriptionProcessor.Process(@event); } catch (Exception e) { await MarkAsDeadLetter(@event, "DataStreamProcessor", e); } } ; }
/// <summary> /// A simple function that takes a string and does a ToUpper /// </summary> /// <param name="input"></param> /// <param name="context"></param> /// <returns></returns> public async Task FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { var client = new AmazonStepFunctionsClient(); var sfnArn = Environment.GetEnvironmentVariable("STEP_FUNCTION_ARN"); LambdaLogger.Log($"Processing {dynamoEvent.Records.Count()}"); LambdaLogger.Log($"ARN {sfnArn}"); IList <DynamoDBEvent.DynamodbStreamRecord> r = dynamoEvent.Records; foreach (DynamoDBEvent.DynamodbStreamRecord record in dynamoEvent.Records) { if (record.EventName == OperationType.INSERT) { var incoming = record.Dynamodb.NewImage.ToDynamoEntity <PurchaseOrder>(); LambdaLogger.Log($"ID {incoming.PurchaseId}"); LambdaLogger.Log($"Color {incoming.ColorName}"); var request = new StartExecutionRequest() { Input = JsonSerializer.Serialize(new { PurchasedInventory = new object[] { incoming } }), Name = Guid.NewGuid().ToString(), StateMachineArn = sfnArn, }; var resp = await client.StartExecutionAsync(request); if (resp.HttpStatusCode != System.Net.HttpStatusCode.OK) { throw new Exception($"Failed with code {resp.HttpStatusCode}: {JsonSerializer.Serialize(resp.ResponseMetadata)}"); } } } }
public async Task TestFunction() { DynamoDBEvent evnt = new DynamoDBEvent { Records = new List <DynamoDBEvent.DynamodbStreamRecord> { new DynamoDBEvent.DynamodbStreamRecord { AwsRegion = "us-west-2", Dynamodb = JsonConvert.DeserializeObject <StreamRecord>(File.ReadAllText("actor.json")) } } }; _output.WriteLine(JsonConvert.SerializeObject(evnt, new JsonSerializerSettings { ContractResolver = new IgnoreEmptyValuesResolver() })); var function = new ActorsFunction(_sqsWriterMock.Object, _dynamoDbWriterMock.Object, _loggerMock.Object); await function.ActorsFunctionHandler(evnt, _context); var testLogger = _context.Logger as TestLambdaLogger; Assert.Contains("Stream processing complete", testLogger.Buffer.ToString()); _sqsWriterMock.Verify(x => x.WriteLogEntryAsync(It.Is <LogEntry>(y => y.Message == "Actor 'TestFirstName TestLastName' processed by lambda"))); _dynamoDbWriterMock.Verify(x => x.SerializeStreamRecord(It.IsAny <StreamRecord>())); _dynamoDbWriterMock.Verify(x => x.PutLogEntryAsync(It.IsAny <LogEntry>())); }
public void FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records..."); foreach (var record in dynamoEvent.Records) { var oldImage = Document.FromAttributeMap(record.Dynamodb.OldImage); var newImage = Document.FromAttributeMap(record.Dynamodb.NewImage); var oldState = _dynamoDbContext.FromDocument <Lightbulb>(oldImage); var newState = _dynamoDbContext.FromDocument <Lightbulb>(newImage); var changes = _changeProcessor.GetChanges(oldState, newState); if (changes.success) { PublishResponse publishResponse = _snsClient.PublishAsync(_snsArn, changes.message, "Lightbulb").Result; context.Logger.LogLine($"Sent Message '{changes.message}' with SNS MessageId: {publishResponse.MessageId}"); } else { context.Logger.LogLine("No useful changes detected"); } } context.Logger.LogLine("Stream processing complete."); }
public void FunctionHandler(DynamoDBEvent dynamoEvent) { foreach (var record in dynamoEvent.Records) { // TODO: Write DynamoDB update expression for each field to aggregate timeseries data var image = record.Dynamodb.NewImage; var timestamp = long.Parse(image["Timestamp"].N); var timebucket = image["TimeBucket"]; var energyDay = GetDouble(image["EnergyDay"]); // Use MAX var gridPower = GetDouble(image["GridPower"]); // Use MIN, MAX, AVERAGE, and SUM var selfConsumption = GetDouble(image["SelfConsumption"]); // Use MAX and SUM var accumulatorPower = GetDouble(image["AccumulatorPower"]); // Use MIN, MAX, AVERAGE, and SUM var energyYear = GetDouble(image["EnergyYear"]); // Use MAX var energyTotal = GetDouble(image["EnergyTotal"]); // Use MAX var arrayPower = GetDouble(image["ArrayPower"]); // Use MIN, MAX, AVERAGE, and SUM var autonomy = GetDouble(image["Autonomy"]); // Use MIN, MAX, AVERAGE, and SUM var loadPower = GetDouble(image["LoadPower"]); // Use MIN, MAX, AVERAGE, and SUM Console.WriteLine($@"Parsed: Timestamp: {timestamp}, TimeBucket: {timebucket}, EnergyDay: {energyDay}, GridPower: {gridPower}, SelfConsumption: {selfConsumption}, AccumulatorPower: {accumulatorPower}, EnergyYear: {energyYear}, EnergyTotal: {energyTotal}, ArrayPower: {arrayPower}, Autonomy: {autonomy}, LoadPower: {loadPower} "); } }
public async Task MoviesFunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records..."); foreach (var record in dynamoEvent.Records) { context.Logger.LogLine($"Event ID: {record.EventID}"); context.Logger.LogLine($"Event Name: {record.EventName}"); var streamRecordJson = _dynamoDbWriter.SerializeStreamRecord(record.Dynamodb); context.Logger.LogLine($"DynamoDB Record:{streamRecordJson}"); context.Logger.LogLine(streamRecordJson); var title = record.Dynamodb.NewImage["Title"].S; var logEntry = new LogEntry { Message = $"Movie '{title}' processed by lambda", DateTime = DateTime.Now }; _logger.LogInformation("MoviesFunctionHandler invoked with {Title}", title); await _sqsWriter.WriteLogEntryAsync(logEntry); await _dynamoDbWriter.PutLogEntryAsync(logEntry); } context.Logger.LogLine("Stream processing complete."); }
public void FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { try { if (dynamoEvent.Records == null) { throw new Exception("Empty record!"); } context.Logger.LogLine($"Beginning to process {dynamoEvent.Records?.Count} records..."); foreach (var record in dynamoEvent.Records) { context.Logger.LogLine($"Event ID: {record.EventID}"); context.Logger.LogLine($"Event Name: {record.EventName}"); context.Logger.LogLine($"Updated entries"); foreach (var itm in record.Dynamodb.Keys) { context.Logger.LogLine($"Entry: {itm.Key}"); } } context.Logger.LogLine("Stream processing complete."); } catch (Exception ex) { context.Logger.LogLine(ex.Message); } }
/// <summary> /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used /// to respond to S3 notifications. /// </summary> /// <param name="evnt"></param> /// <param name="context"></param> /// <returns></returns> public async Task SurveySimDynLambdaFunctionHandler(DynamoDBEvent evnt, ILambdaContext context) { JObject preference = new Preference().preference; var dynamoDBEvent = evnt.Records[0]?.Dynamodb; if (dynamoDBEvent == null) { return; } try { var entry = dynamoDBEvent.Keys; JObject apiBody = new JObject(); apiBody["code"] = entry["code"].S; await CreatePostResponse(input : apiBody, context : context); } catch (Exception e) { context.Logger.LogLine(e.Message); context.Logger.LogLine(e.StackTrace); } }
public void FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records..."); IServiceProvider sp = DI.ServiceProvider; IBaseRepository <Message> messageRepo = sp.GetService <IBaseRepository <Message> >(); ISmsWorker smsWorker = sp.GetService <ISmsWorker>(); foreach (var record in dynamoEvent.Records) { //because the stream parser strategy seems an overkill //to be introduced of all object long Id = Convert.ToInt64(record.Dynamodb.Keys.First().Value.N); context.Logger.LogLine($"Requesting record Id : {Id}"); Message msg = messageRepo.Get(Id); context.Logger.LogLine(JsonConvert.SerializeObject(msg)); if (msg.Phone != null) { SmsResponse smsResponse = smsWorker.SendSMS(msg.Phone, msg.Content); string log = smsResponse.success ? $"SMS Message send : {msg.Phone}" : "SMS Message was unable to be sent"; context.Logger.LogLine(log); } } context.Logger.LogLine("Stream processing complete."); }
public void FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records..."); foreach (var record in dynamoEvent.Records) { var source = record.EventSourceArn.Split(':')[5].Split('/')[1]; //context.Logger.LogLine($"Event ID: {record.EventID}"); //context.Logger.LogLine($"Event Name: {record.EventName}"); //context.Logger.LogLine($"Event Table: {source}"); switch (source) { case "Matches": var tf = new TaskFactory(CancellationToken.None, TaskCreationOptions.None, TaskContinuationOptions.None, TaskScheduler.Default); tf.StartNew(() => _statsAggregation.ProcessStreamRecordAsync(record, context)) .Unwrap().GetAwaiter().GetResult(); break; default: context.Logger.LogLine($"No action for table: {source}"); break; } } context.Logger.LogLine("Stream processing complete."); }
public async Task ProcessDDBEvent(DynamoDBEvent evnt, ILambdaContext context) { foreach (var record in evnt.Records) { var pollId = record.Dynamodb.Keys["Id"].S; context.Logger.LogLine($"Processing poll {pollId}"); var poll = await this._manager.GetPollByIdAsync(pollId); if (poll == null) { context.Logger.LogLine($"Failed to find poll for id {pollId}"); continue; } if (poll.State != PollDefinition.POLL_STATE_UNSCHEDULE) { context.Logger.LogLine($"Poll {poll.Title} is already scheduled"); continue; } context.Logger.LogLine($"Starting state machine execution"); await this._stepClient.StartExecutionAsync(new StartExecutionRequest { Name = Guid.NewGuid().ToString(), StateMachineArn = this._stateMachine, Input = "{\"PollId\" : \"" + poll.Id + "\"}" }); } }
// LambdaTest::LambdaTest.LambdaHandler::handleRequest // PublishToAisleDevice::PublishToAisleDevice.Function::FunctionHandler public void FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { context.Logger.LogLine($"Beginning to process customer updates for {dynamoEvent.Records.Count} record(s)..."); foreach (var record in dynamoEvent.Records) { context.Logger.LogLine($"---------------------------------------------"); context.Logger.LogLine($"User information updated;"); switch (record.EventName) { case "INSERT": // Do we need to do anything here for new customer registration? // Handle new customer registration. May be he entered the store and registered break; case "MODIFY": SendUpdatesToStore(record, context); break; case "DELETE": // Do we need to do anything here for new customer un-registration? default: break; } // TODO: Add business logic processing the record.Dynamodb object. } context.Logger.LogLine($"---------------------------------------------"); context.Logger.LogLine("Stream processing complete."); }
public void FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { foreach (var record in dynamoEvent.Records) { Console.WriteLine($"Updated record Id: {record.EventID}"); } }
public async Task Trigger_Function() { var dynamoDbEvent = new DynamoDBEvent() { Records = new List <DynamodbStreamRecord>() { new DynamodbStreamRecord() { EventID = "ID", EventName = "Name", Dynamodb = new Amazon.DynamoDBv2.Model.StreamRecord() { NewImage = new Dictionary <string, Amazon.DynamoDBv2.Model.AttributeValue>() { { "ParentTraceId", new Amazon.DynamoDBv2.Model.AttributeValue() { S = "00-6354617bdf314d4ebd3fb4cffb641aab-719b9c4acd868142-01" } } } } } } }; var function = new MyLambda.Function(); await function.FunctionHandler(dynamoDbEvent, _mockLambdaContext.Object); }
public void ProcessDynamoEvent(DynamoDBEvent dynamoDBEvent, ILambdaContext context) { AmazonApiGatewayManagementApiClient client = new AmazonApiGatewayManagementApiClient(new AmazonApiGatewayManagementApiConfig() { ServiceURL = "https://g49fepw5h8.execute-api.us-west-2.amazonaws.com/Test" }); AmazonDynamoDBClient amazonDynamoDbClient = new AmazonDynamoDBClient(); Console.WriteLine("Voy a empezar"); Console.WriteLine(dynamoDBEvent.Records); foreach (var dynamoRecord in dynamoDBEvent.Records) { MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(dynamoRecord.Dynamodb.NewImage))); String[] connections = GetConnections(amazonDynamoDbClient, dynamoRecord.Dynamodb.NewImage); foreach (string connection in connections) { PostToConnectionRequest postRequest = new PostToConnectionRequest() { ConnectionId = connection, Data = stream }; var result = client.PostToConnectionAsync(postRequest); result.Wait(); } } }
public async Task FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { foreach (var record in dynamoEvent.Records) { if (record.EventName == "INSERT") { var pedido = record.Dynamodb.NewImage.ToObject <Pedido>(); pedido.Status = StatusDoPedido.Coletado; try { await ProcessarValorDoPedido(pedido); await AmazonUtil.EnviarParaFila(EnumFilasSQS.pedido, pedido); context.Logger.LogLine($"Sucesso na coleta do pedido: '{pedido.Id}'"); } catch (Exception ex) { context.Logger.LogLine($"Erro: '{ex.Message}'"); pedido.JustificativaDeCancelamento = ex.Message; pedido.Cancelado = true; await AmazonUtil.EnviarParaFila(EnumFilasSNS.falha, pedido); } await pedido.SalvarAsync(); } } }
/// <summary> /// Does the invoke. /// </summary> /// <param name="theEvent">The event.</param> /// <param name="context">The context.</param> /// <returns> /// The result of the invoke operation /// </returns> protected string Invoke(DynamoDBEvent theEvent, ILambdaContext context) { foreach (var record in theEvent.Records) { var document = Document.FromAttributeMap(record.Dynamodb.NewImage); var itemToIndex = this.dynamoDbContext.FromDocument <InventoryItem>(document); if (record.EventName == OperationType.INSERT) { return(this.indexer.InsertIndex(itemToIndex).Result.ToString()); } if (record.EventName == OperationType.MODIFY) { return(this.indexer.UpdateIndex(itemToIndex, new Id(itemToIndex.VIN)).Result.ToString()); } if (record.EventName == OperationType.REMOVE) { return(this.indexer.DeleteIndex(new Id(itemToIndex.VIN)).Result.ToString()); } } return("nothing processed"); }
public async Task FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { if (dynamoEvent?.Records == null) { context.Logger.LogLine("No dynamo stream record to process"); return; } context.Logger.LogLine($"Beginning to process {dynamoEvent?.Records.Count} records..."); var paymentBatch = dynamoEvent.Records.Where(x => x.EventName.Value != "REMOVE") /* filter for different entities && x.Dynamodb.Keys["Type"].S == "Payment"*/ .Select(record => { var doc = Document.FromAttributeMap(record.Dynamodb.NewImage); var jsonDoc = doc.ToJson(); var chargeRequested = JsonConvert.DeserializeObject <AlgoliaChargeRequested>(jsonDoc); context.Logger.LogLine($"DynamoDB Record of type {record.EventName}:"); context.Logger.LogLine(SerializeStreamRecord(record.Dynamodb)); context.Logger.LogLine(jsonDoc); return(chargeRequested); }).ToList(); var client = new SearchClient(new SearchConfig("FDPS0J74WQ", "e4e69e7bc80a5cf2f1ba429c1d058553")); var index = client.InitIndex("test"); var response = await index.SaveObjectsAsync(paymentBatch); var count = response.Responses.Sum(r => r.ObjectIDs.Count()); context.Logger.LogLine($"Algolia added {count} records"); context.Logger.LogLine($"Stream processing complete. Added {paymentBatch.Count} records"); }
public void Update(DynamoDBEvent request, ILambdaContext context) { string content = JsonConvert.SerializeObject(request.Records); // Log entries show up in CloudWatch Console.WriteLine("Dynamo Example\n"); Console.WriteLine(content); }
public async Task MessageUpdated(DynamoDBEvent streamEvent) { await _serviceProvider.GetService <IMediator>() .Send(new SendWebSocketMessagesCommand { DynamoEvent = streamEvent, EventDataMapper = Message.FromMessageStreamRecord }); }
public async Task FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records..."); foreach (var record in dynamoEvent.Records) { try { context.Logger.LogLine($"Event ID: {record.EventID}"); context.Logger.LogLine($"Event Name: {record.EventName}"); var oldVersion = ConvertToTODOList(record.Dynamodb.OldImage); var newVersion = ConvertToTODOList(record.Dynamodb.NewImage); var emailsToTasks = CompareVersions(oldVersion, newVersion); foreach (var kvp in emailsToTasks) { var emailBody = CreateEmailBody(kvp.Value); var request = new SendEmailRequest { Source = fromEmail, Destination = new Destination { ToAddresses = new List <string> { kvp.Key } }, Message = new Message { Subject = new Content { Data = "New tasks have been assigned to you." }, Body = new Body { Text = new Content { Data = emailBody } } } }; await this.SESClient.SendEmailAsync(request); context.Logger.LogLine($"Sent email to {request.Destination.ToAddresses[0]} from {request.Source}"); context.Logger.LogLine(emailBody); } } catch (Exception e) { context.Logger.LogLine($"Error processing record: {e.Message}"); context.Logger.LogLine(e.StackTrace); } } context.Logger.LogLine("Stream processing complete."); }
public async Task EventHandlerAsync(DynamoDBEvent dynamoEvent) { var snsClient = new AmazonSimpleNotificationServiceClient(RegionEndpoint.USWest2); Logger.Log($"Beginning to process {dynamoEvent.Records.Count} records..."); foreach (var record in dynamoEvent.Records) { Logger.Log($"Event ID: {record.EventID}"); Logger.Log($"Event Name: {record.EventName}"); string streamRecordJson = SerializeObject(record.Dynamodb); Logger.Log($"DynamoDB Record:"); Logger.Log(streamRecordJson); // Determine SNS topic from EventName string eventName = null; string @event = null; Logger.Log($"Count: {record.Dynamodb.NewImage.Values.Count}"); foreach (var s in record.Dynamodb.NewImage) { if (s.Key == "Event") { Logger.Log($" Key: {s.Key}"); Logger.Log($" Value: {s.Value.S}"); @event = s.Value.S; } if (s.Key == "EventName") { Logger.Log($" Key: {s.Key}"); Logger.Log($" Value: {s.Value.S}"); eventName = s.Value.S.Replace(@"""", ""); } } // Publish event to SNS Topic try { var eventCreatedTopic = Environment.GetEnvironmentVariable($"{eventName}Topic"); Logger.Log("Sending event to SNS for further processing"); await snsClient.PublishAsync(eventCreatedTopic, @event); Logger.Log("Successfully sent event to SNS for further processing"); } catch (Exception ex) { Logger.Log($"ERROR: {ex.Message}"); } } Logger.Log("Stream processing complete."); }
private static void Handle(DynamoDBEvent ddbEvent) { foreach (var record in ddbEvent.Records) { var ddbRecord = record.Dynamodb; var keys = string.Join(", ", ddbRecord.Keys.Keys); Console.WriteLine($"{record.EventID} - Keys = [{keys}], Size = {ddbRecord.SizeBytes} bytes"); } Console.WriteLine($"Successfully processed {ddbEvent.Records.Count} records."); }
public void FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { Console.WriteLine($"Incoming Event: {JsonConvert.SerializeObject(dynamoEvent)}"); // Process records and send SQS messages asynchronously IEnumerable <Task <SendMessageResponse> > tasks = dynamoEvent.Records.Select(r => ProcessRecord(r)); // Wait for everything to finish, then exit Task.WhenAll(tasks).Wait(); }
public async Task FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records..."); foreach (var record in dynamoEvent.Records) { await _dynamoDbItemService.DoSomethingAsync(record, context.Logger); } context.Logger.LogLine("Stream processing complete."); }
public async Task TestFunction_WithDynamoStreamRecord() { var @event = new DynamoDBEvent { Records = new List <DynamoDBEvent.DynamodbStreamRecord> { new DynamoDBEvent.DynamodbStreamRecord { AwsRegion = "eu-central-1", Dynamodb = new StreamRecord { ApproximateCreationDateTime = DateTime.Now, Keys = new Dictionary <string, AttributeValue> { { "pk", new AttributeValue { S = "MyId" } }, { "sk", new AttributeValue { S = "MySortKey" } } }, NewImage = new Dictionary <string, AttributeValue> { { "pk", new AttributeValue { S = "NewValue" } }, { "sk", new AttributeValue { S = "AnotherNewValue" } } }, OldImage = new Dictionary <string, AttributeValue> { { "pk", new AttributeValue { S = "OldValue" } }, { "sk", new AttributeValue { S = "AnotherOldValue" } } }, StreamViewType = StreamViewType.NEW_AND_OLD_IMAGES } } } }; var context = new TestLambdaContext(); var function = new Function(); await function.FunctionHandler(@event, context); var testLogger = (TestLambdaLogger)context.Logger; Assert.Contains("Stream processing complete", testLogger.Buffer.ToString()); }
public async Task <List <CompaniesMerging> > FunctionHandler(DynamoDBEvent input, ILambdaContext context) { Table table = Table.LoadTable(client, "RatingsByType"); List <CompaniesMerging> books = new List <CompaniesMerging>(); List <DynamoDBEvent.DynamodbStreamRecord> records = (List <DynamoDBEvent.DynamodbStreamRecord>)input.Records; #region Single Record if (records.Count > 0) { DynamoDBEvent.DynamodbStreamRecord record = records[0]; if (record.EventName.Equals("INSERT")) { Document myDoc = Document.FromAttributeMap(record.Dynamodb.NewImage); CompaniesMerging myBook = JsonConvert.DeserializeObject <CompaniesMerging>(myDoc.ToJson()); var request = new UpdateItemRequest { TableName = "RatingsByType", Key = new Dictionary <string, AttributeValue> { { "type", new AttributeValue { S = myBook.type } } }, AttributeUpdates = new Dictionary <string, AttributeValueUpdate>() { { "count", new AttributeValueUpdate { Action = "ADD", Value = new AttributeValue { N = "1" } } }, { "totalRating", new AttributeValueUpdate { Action = "ADD", Value = new AttributeValue { N = myBook.rating.ToString() } } },/* * { * "averageRating", * new AttributeValueUpdate{ Action = "ADD", Value = new AttributeValue{ N = ""} } * }, */ }, }; await client.UpdateItemAsync(request); } } #endregion return(books); }
public void FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records..."); foreach (DynamoDBEvent.DynamodbStreamRecord record in dynamoEvent.Records) { context.Logger.LogLine($"Event ID: {record.EventID}"); context.Logger.LogLine($"Record Id: {record.Dynamodb.Keys["Id"].S}"); } context.Logger.LogLine("Stream processing complete."); }
public async Task TestFunction() { DynamoDBEvent evnt = new DynamoDBEvent { Records = new List <DynamoDBEvent.DynamodbStreamRecord> { new DynamoDBEvent.DynamodbStreamRecord { AwsRegion = "us-west-2", Dynamodb = new StreamRecord { ApproximateCreationDateTime = DateTime.Now, Keys = new Dictionary <string, AttributeValue> { { "Title", new AttributeValue { S = "Die Hard" } } }, NewImage = new Dictionary <string, AttributeValue> { { "Title", new AttributeValue { S = "Title" } }, { "Genre", new AttributeValue { S = "0" } } }, SequenceNumber = "25567400000000000393411126", SizeBytes = 54, StreamViewType = StreamViewType.NEW_AND_OLD_IMAGES } } } }; _output.WriteLine(JsonConvert.SerializeObject(evnt, new JsonSerializerSettings { ContractResolver = new IgnoreEmptyValuesResolver() })); var function = new MoviesFunction(_sqsWriterMock.Object, _dynamoDbWriterMock.Object, _loggerMock.Object); await function.MoviesFunctionHandler(evnt, _context); var testLogger = _context.Logger as TestLambdaLogger; Assert.Contains("Stream processing complete", testLogger.Buffer.ToString()); _sqsWriterMock.Verify(x => x.WriteLogEntryAsync(It.Is <LogEntry>(y => y.Message == $"Movie '{evnt.Records[0].Dynamodb.NewImage["Title"].S}' processed by lambda"))); _dynamoDbWriterMock.Verify(x => x.SerializeStreamRecord(It.IsAny <StreamRecord>())); _dynamoDbWriterMock.Verify(x => x.PutLogEntryAsync(It.IsAny <LogEntry>())); }