/// <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>()));
}
