protected void LogDynamoException(ref Exception exception)
{
var message = exception?.Message;
var innerException = exception?.InnerException;
Logger?.LogError("Error performing the DynamoDB action: \"{message}\" | InnerException: \"{innerException}\"", message, innerException);
LambdaLogger?.Log($"Error performing the DynamoDB action:{message} {innerException}");
}
/// <summary>
/// A simple function that takes a IoTButton click event and sends to Kinesis Data Stream
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public void FunctionHandler(JObject input, ILambdaContext context)
{
LambdaLogger.Log(input.ToString());
byte[] byteArray = Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(input.ToString()) + Environment.NewLine);
var stream = new MemoryStream(byteArray);
using (var kinesisClient = new AmazonKinesisClient(Amazon.RegionEndpoint.USEast1))
{
Task.WaitAll(kinesisClient.PutRecordsAsync(new PutRecordsRequest()
{
StreamName = "MyButtonStream",
Records = new List <PutRecordsRequestEntry>()
{
new PutRecordsRequestEntry()
{
Data = stream, PartitionKey = "AAA"
}
}
}));
}
}
//--- Methods ---
public async Task FunctionHandler(S3Event uploadEvent, ILambdaContext context)
{
string bucket = uploadEvent.Records[0].S3.Bucket.Name;
string objectKey = uploadEvent.Records[0].S3.Object.Key;
using (var client = new AmazonS3Client(Amazon.RegionEndpoint.USEast1)) {
S3Model.GetObjectRequest request = new S3Model.GetObjectRequest {
BucketName = bucket,
Key = objectKey
};
using (S3Model.GetObjectResponse response = await client.GetObjectAsync(request))
using (Stream responseStream = response.ResponseStream)
using (StreamReader reader = new StreamReader(responseStream)) {
while (reader.Peek() >= 0)
{
LambdaLogger.Log($"{reader.ReadLine().Replace("\t", " | ")}");
}
}
}
}
public void ImportFromAPI(int pageStart, int pageEnd, int pageSize)
{
LambdaLogger.Log($"Entering: ImportCards({pageStart}, { pageEnd }, {pageSize})");
try
{
CardService service = new CardService();
for (int i = pageStart; i < pageEnd; i++)
{
ImportFromAPI(i, pageSize);
}
}
catch (Exception exp)
{
LambdaLogger.Log($"Error: { exp }");
throw;
}
LambdaLogger.Log($"Leaving: ImportCards({pageStart}, { pageEnd }, {pageSize})");
}
public async Task Respond(string url, CloudFormationResponse response)
{
try
{
var client = new HttpClient();
var jsonContent = new StringContent(JsonConvert.SerializeObject(response));
jsonContent.Headers.Remove("Content-Type");
var postResponse = await client.PutAsync(url, jsonContent);
postResponse.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
LambdaLogger.Log("Exception: " + ex);
response.Status = "FAILED";
response.Data = ex;
}
}
protected IActionResult ReturnResult(Action function, int responseCode = 200)
{
try {
function();
return(new StatusCodeResult(statusCode: responseCode));
}
catch (ArgumentException ex) {
return(BadRequest(ex.Message));
}
catch (KeyNotFoundException ex) {
return(StatusCode(404, ex.Message));
}
catch (UnauthorizedAccessException ex) {
var resp = StatusCode(401, ex.Message);
return(resp);
}
catch (Exception ex) {
LambdaLogger.Log(ex.Message);
return(StatusCode(500, ex.Message));
}
}
protected async Task <FieldValueDto> GetFieldValue(string token, DeviceDto device, string fieldName, string port)
{
FieldDescriptorDto field = GetFieldDescriptor(device, fieldName, port);
if (field == null)
{
LambdaLogger.Log("Did not find required field '" + fieldName + "' for device: " + device.DisplayName);
return(null);
}
LambdaLogger.Log("Getting field '" + fieldName + "' value from device: " + device.DisplayName);
var value = await _measurementsClient.GetFieldValueAsync(token, device.Id, field);
if (value == null)
{
LambdaLogger.Log("Did not find field '" + fieldName + "' value for device: " + device.DisplayName);
return(null);
}
return(value);
}
public async Task <TOutput> FunctionHandler(TInput input, ILambdaContext context)
{
var scope = ServiceProvider.CreateScope();
var name = typeof(TInput).Name;
try
{
var handler = scope.ServiceProvider.GetService <ILambdaEventHandler <TInput, TOutput> >();
if (handler == null)
{
var message = $"EventHandler<{name}> Not found. Please check the dependency injection declaration";
Logger.LogError("EventHandler<{name}> Not found. Please check the dependency injection declaration", name);
throw new InvalidOperationException(message);
}
Logger.LogInformation("Invoking handler {name}", name);
return(await handler.FunctionHandler(input, context).ConfigureAwait(false));
}
catch (Exception ex)
{
var lambdaMessage = $"Message '{name}': \"{ex?.Message}\" | InnerException: \"{ex?.InnerException}\"";
LambdaLogger.Log(lambdaMessage);
var message = ex?.Message;
var innerException = ex?.InnerException;
var stackTrace = ex?.StackTrace;
Logger.LogError("Message '{name}': \"{message}\" | InnerException: \"{innerException}\" | StackTrace: \"{stacktrace}\"", name, message, innerException, stackTrace);
throw;
}
finally
{
LambdaLogger.Log($"Disposing {name} function scope");
Logger.LogInformation("Disposing {name} function scope", name);
scope?.Dispose();
}
}
public override LexResponse Process(LexEvent lexEvent, ILambdaContext context)
{
IDictionary <string, string> sessionAttributes = lexEvent.SessionAttributes ?? new Dictionary <string, string>();
IDictionary <string, string> requestAttributes = lexEvent.RequestAttributes ?? new Dictionary <string, string>();
IDictionary <string, string> slots = lexEvent.CurrentIntent.Slots;
LambdaLogger.Log("Debug Intent Processor");
LambdaLogger.Log("Bot Name =" + lexEvent.Bot.Name);
LambdaLogger.Log("Bot Aliase =" + lexEvent.Bot.Alias);
LambdaLogger.Log("Bot Version =" + lexEvent.Bot.Version);
LambdaLogger.Log("user ID =" + lexEvent.UserId);
LambdaLogger.Log("Transcription =" + lexEvent.InputTranscript);
LambdaLogger.Log("Invocation Source =" + lexEvent.InvocationSource);
LambdaLogger.Log("Output Dialog Mode =" + lexEvent.OutputDialogMode);
foreach (KeyValuePair <string, string> entries in sessionAttributes)
{
LambdaLogger.Log(string.Format("Session Attribute = {0}, Value = {1}", entries.Key, entries.Value));
}
foreach (KeyValuePair <string, string> entries in requestAttributes)
{
LambdaLogger.Log(string.Format("Request Attribute = {0}, Value = {1}", entries.Key, entries.Value));
}
foreach (KeyValuePair <string, string> entries in slots)
{
LambdaLogger.Log(string.Format("Slot = {0}, Value = {1}", entries.Key, entries.Value));
}
return(Close(
sessionAttributes,
"Fulfilled",
new LexResponse.LexMessage
{
ContentType = MESSAGE_CONTENT_TYPE,
Content = String.Format("Norbot is responding. All debug messages written to log file.")
}
));
}
public async Task <APIGatewayProxyResponse> FunctionHandlerAsync(APIGatewayProxyRequest request, ILambdaContext context)
{
LambdaLogger.Log(request.Body);
var response = new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK
};
try
{
var webhookMessage = JsonConvert.DeserializeObject <WebhookMessage>(request.Body);
if (webhookMessage == null)
{
return(response);
}
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
var serviceProvider = serviceCollection.BuildServiceProvider();
var botService = serviceProvider.GetService <IBotService>();
if (webhookMessage.Message?.Location != null)
{
await botService.AskScaleAsync(webhookMessage.Message.Chat.Id, webhookMessage.Message.Location);
}
if (webhookMessage.CallbackQuery != null && webhookMessage.CallbackQuery.Message.Text == "Pafta ölçeğini seçiniz (1:___.000):" && int.TryParse(webhookMessage.CallbackQuery.Data, out int scale))
{
await botService.QuerySheetAsync(webhookMessage.CallbackQuery.Message.MessageId, webhookMessage.CallbackQuery.Id, webhookMessage.CallbackQuery.Message.Chat.Id, scale);
}
}
catch (Exception ex)
{
LambdaLogger.Log("Error: " + ex.Message);
}
return(response);
}
public async Task CreateFile(string userID, FilePath path)
{
// If CreateMasterEntry fails, just let the exception bubble out
var results = await Task.WhenAll(new[] { this.bucket.CheckObjectPresence(path), this.db.CreateMasterEntry(path) });
if (results.All(exists => exists))
{
throw new ConflictException("File already exists");
}
// If S3 object exists but the Master entry did not exist and was newly created
if (results[0] && !results[1])
{
try {
await this.db.DeleteMasterEntry(path);
}
catch (Exception e) {
LambdaLogger.Log($"Failed to delete master entry after detecting existing s3 object, with error: {e}");
throw new ServerException("Failed to create file");
}
throw new ServerException("File may still be in the process of being deleted, wait a few seconds and retry the request.");
}
// Master entry was successfully created and the s3 object was not present
try {
await bucket.CreateObject(path);
}
catch (Exception e) {
try {
await this.db.DeleteMasterEntry(path);
}
catch (ServerException dbErr) {
LambdaLogger.Log($"Failed to delete master entry with error: {dbErr} after the creation of S3 object failed with error: {e}");
throw new ServerException("Failed to create file");
}
LambdaLogger.Log($"Failed to create S3 object with error: {e}");
throw new ServerException("Failed to create file");
}
}
public async Task <string> HandleIncomingCall(TwilioIncomingCall twilioCallDetails, ILambdaContext context)
{
string stage = System.Environment.GetEnvironmentVariable("STAGE");
string region = System.Environment.GetEnvironmentVariable("AWS_REGION");
string functionName = $"telephonist-csharp-{stage}-GetDetailsForCurrentOnCallOperator";
LambdaLogger.Log($"REQUEST: {twilioCallDetails}");
LambdaLogger.Log($"PARAM: stage={stage}");
LambdaLogger.Log($"PARAM: region={region}");
LambdaLogger.Log($"functionName: {functionName}");
using (AmazonLambdaClient client = new AmazonLambdaClient(RegionEndpoint.GetBySystemName(region)))
{
InvokeRequest request = new InvokeRequest()
{
FunctionName = functionName
};
InvokeResponse response = await client.InvokeAsync(request);
using (StreamReader reader = new StreamReader(response.Payload))
{
string result = reader.ReadToEnd();
LambdaLogger.Log($"Lambda result: {result}");
OnCallOperatorDetails engineer = WebHelpers.ParseJSON <OnCallOperatorDetails>(result);
string justName = engineer.Name.Split(' ')[0];
TimeZoneInfo localTimeZone = WebHelpers.OlsonTimeZoneToTimeZoneInfo(engineer.TimeZone);
DateTime localTime = TimeZoneInfo.ConvertTime(DateTime.Now, localTimeZone);
string localTimeString = localTime.ToString("hh:mm tt", CultureInfo.InvariantCulture);
return(String.Format(CultureInfo.InvariantCulture, ResponseTwiML, justName, localTimeString, engineer.PhoneNumber));
}
}
}
public async Task <string> GetToken()
{
LambdaLogger.Log($"Entering: GetToken()");
string response = string.Empty;
try
{
S3GetFileResponse S3Response = await S3Helper.GetFile(new S3GetFileRequest
{
FilePath = MTGServiceConstants.AuthenticateJsonFilepath
});
if (S3Response.IsSuccess)
{
if (string.IsNullOrEmpty(S3Response.FileContent))
{
throw new Exception("S3 Response content is null or empty! ya bish!");
}
AuthenticateDto authenticateDto = JsonConvert.DeserializeObject <AuthenticateDto>(S3Response.FileContent);
if (authenticateDto == null)
{
throw new Exception("S3 Authenticate response content could not be deserialized!");
}
response = authenticateDto.AccessToken;
}
}
catch (Exception exp)
{
LambdaLogger.Log($"Error: {exp}");
throw;
}
LambdaLogger.Log($"Leaving: GetToken({response})");
return(response);
}
//TODO: Explore Query & Scan
/// <summary>
/// keyFilters format:
/// ['=', 'like', 'in']
/// if ('=') then assert list.count = 1
/// if ('in') then assert list.count >= 1
/// - Read as, return documents with property that is equal to a value in the list
///
/// </summary>
/// <param name="tableName"></param>
/// <param name="keyFilters"></param>
/// <returns></returns>
public static IEnumerable <Document> SearchDocuments(SearchDocumentsRequest request)
{
LambdaLogger.Log($"Entering: SearchDocuments({ JsonConvert.SerializeObject(request) }");
var documents = new List <Document>();
//TODO: Change tableName and keyFilters to be in request
//Validation of the request
try
{
var expressionFilterObject = BuildExpressionFilterObject(request.KeyFilters);
var keyConditionExpression = BuildKeyConditionExpression(expressionFilterObject.ExpressionGeneratorList);
QueryRequest queryRequest = new QueryRequest
{
TableName = request.TableName,
ExpressionAttributeNames = expressionFilterObject.ExpressionAttributeNames,
ExpressionAttributeValues = expressionFilterObject.ExpressionAttributeValues,
KeyConditionExpression = keyConditionExpression
};
Task <QueryResponse> queryTask = _client.QueryAsync(queryRequest);
LambdaLogger.Log($"About to run Query: { JsonConvert.SerializeObject(queryRequest) }");
var queryResponse = queryTask.Result;
LambdaLogger.Log($"Query Response: { JsonConvert.SerializeObject(queryResponse) }");
//TODO: Build out response
}
catch (Exception exp)
{
LambdaLogger.Log($"Error: { exp }");
throw;
}
LambdaLogger.Log($"Leaving: SearchDocuments({ JsonConvert.SerializeObject(documents) }");
return(documents);
}
/// <summary>
/// Get query results based on the entity
/// </summary>
/// <param name="companyId"></param>
/// <param name="query"></param>
/// <param name="queryJson"></param>
/// <returns>QueryModel</returns>
public QueryModel GetResults(int companyId, string query, string queryJson)
{
QueryModel queryModel = new QueryModel();
try
{
//Deserialize the query Json to get the results
QueryBuilderRequest queryBuilderRequest = JsonConvert.DeserializeObject <QueryBuilderRequest>(queryJson);
Dictionary <string, string> parameterList = ParameterHelper.Getparameters(queryBuilderRequest);
switch (queryBuilderRequest.EntityName.ToUpper())
{
case Constants.TASK:
TaskRepository taskRepository = new TaskRepository();
List <TaskModel> taskList = taskRepository.ReadTaskDetails(query, parameterList, queryBuilderRequest);
queryModel.Tasks = taskList;
break;
case Constants.WORKBOOK:
WorkbookRepository workbookRepository = new WorkbookRepository();
List <WorkbookModel> workbookList = workbookRepository.ReadWorkBookDetails(query, parameterList);
queryModel.Workbooks = workbookList;
break;
case Constants.EMPLOYEE:
EmployeeRepository employeeRepository = new EmployeeRepository();
List <EmployeeQueryModel> employeeList = employeeRepository.ReadEmployeeDetails(query, parameterList);
queryModel.Employee = employeeList;
break;
default:
break;
}
return(queryModel);
}
catch (Exception getResultsexception)
{
LambdaLogger.Log(getResultsexception.ToString());
return(queryModel);
}
}
public async Task <UpdateStatusResponse> UpdateStatus(string id, LetterStatusEnum newStatus)
{
var updateDoc = new Document
{
["InitialTimestamp"] = id,
["Status"] = newStatus.ToString(),
};
var oldAttributes = await _documentsTable.UpdateItemAsync(updateDoc, new UpdateItemOperationConfig { ReturnValues = ReturnValues.UpdatedOldAttributes });
var statusChange = oldAttributes["Status"].ToString() != newStatus.ToString();
if (statusChange)
{
await LogMessage(id, $"Status changed to {newStatus}");
}
LambdaLogger.Log($"Status change: {statusChange}. New status {newStatus}, old status {oldAttributes["Status"]}");
return(new UpdateStatusResponse
{
StatusUpdated = statusChange
});
}
private async Task <User> GetCurrentOnCallOperator(string subdomain, string apiToken, string scheduleId)
{
PagerDutyClient client = new PagerDutyClient(subdomain, apiToken);
string data = await client.GetCurrentOnCallOperator(scheduleId);
LambdaLogger.Log($"GetCurrentOnCallOperator: {data}");
if (data == null)
{
return(null);
}
dynamic response = WebHelpers.ParseJSON(data);
dynamic user = response.schedule.final_schedule.rendered_schedule_entries[0].user;
return(new User()
{
Id = user.id,
Name = user.name,
TimeZone = response.schedule.time_zone
});
}
public APIGatewayProxyResponse getTasks(APIGatewayProxyRequest request)
{
string userId = request.PathParameters["userId"];
LambdaLogger.Log("Getting tasks for:" + userId);
MySqlConnection connection = new MySqlConnection($"server={DB_HOST}; user id={DB_USER}; password={DB_PASSWORD}; port=3306; database={DB_NAME}");
connection.Open();
var cmd = connection.CreateCommand();
cmd.CommandText = @"SELECT * FROM task WHERE userId = @userId";
cmd.Parameters.AddWithValue("@userId", userId);
MySqlDataReader reader = cmd.ExecuteReader();
ArrayList tasks = new ArrayList();
while (reader.Read())
{
Task task = new Task(reader.GetString("taskId"), reader.GetString("description"), reader.GetBoolean("completed"));
tasks.Add(task);
}
connection.Close();
return(new APIGatewayProxyResponse
{
Body = JsonSerializer.Serialize(tasks),
Headers = new Dictionary <string, string>
{
{ "Content-Type", "application/json" },
{ "Access-Control-Allow-Origin", "*" },
},
StatusCode = 200,
});
}
public static async Task <S3CreateFileResponse> CreateFile(S3CreateFileRequest request)
{
LambdaLogger.Log($"Entering: CreateFolder({JsonConvert.SerializeObject(request)})");
S3CreateFileResponse response = new S3CreateFileResponse
{
S3FilePath = request.FilePath,
IsSuccess = true
};
try
{
PutObjectRequest S3Request = new PutObjectRequest
{
BucketName = S3Constants.BUCKET_NAME,
Key = request.FilePath,
ContentBody = request.Content
};
PutObjectResponse S3Response = await S3Client.PutObjectAsync(S3Request);
if (S3Response.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
response.IsSuccess = false;
response.ErrorMessage = string.Format("Status Code: {0}", S3Response.HttpStatusCode);
}
}
catch (Exception exp)
{
LambdaLogger.Log($"Error: {exp}");
response.IsSuccess = false;
response.ErrorMessage = string.Format("Error: {0}", exp.Message);
}
LambdaLogger.Log($"Leaving: CreateFolder({JsonConvert.SerializeObject(response)})");
return(response);
}
public Response DeleteDeliveryBatch(APIGatewayProxyRequest request, ILambdaContext context)
{
var deleteBatchGateway = new INeedHelpGateway(new Cv19SupportDbContext(_connectionString));
var driveHelper = new DriveHelper();
var deleteBatchObject = new DeliveryScheduleUseCase(deleteBatchGateway, driveHelper);
var requestParams = request.PathParameters;
int batchId;
try
{
batchId = Int32.Parse(requestParams["id"]);
}
catch
{
var response = new Response();
response.isBase64Encoded = true;
LambdaLogger.Log("No batch id specified.");
response.statusCode = "400";
return(response);
}
try
{
deleteBatchObject.DeleteDeliveryBatch(batchId);
var response = new Response();
response.isBase64Encoded = true;
LambdaLogger.Log("Batch successfully deleted.");
response.statusCode = "200";
return(response);
}
catch (Exception e)
{
LambdaLogger.Log("Error: " + e.Message);
var response = new Response();
response.isBase64Encoded = true;
response.statusCode = "500";
response.body = "Error processing request: " + ". Error Details: " + e.Message + e.StackTrace;
return(response);
}
}
public void FilterSongsToAdd()
{
var newSongsToAdd = new List <SongCsvModel>();
foreach (var newSong in NewSongs)
{
var found = false;
foreach (var oldSong in OldSongs)
{
if (newSong.SongNumber == oldSong.SongNumber && newSong.Artist == oldSong.Artist && newSong.Title == oldSong.Title)
{
found = true;
}
}
if (!found)
{
newSongsToAdd.Add(newSong);
}
}
LambdaLogger.Log($"***INFO: new songs marked for adding to database (newSongsToAdd): {JsonConvert.SerializeObject(newSongsToAdd)}");
SongsToAdd = newSongsToAdd;
}
public async Task <IActionResult> GetAuditByUser([FromQuery] string userEmail)
{
try
{
if (string.IsNullOrEmpty(userEmail))
{
throw new MissingQueryParameterException("Parameter useremail must be provided.");
}
var response = await _getAuditByUserUseCase.GetAuditByUser(userEmail);
return(Ok(response));
}
catch (MissingQueryParameterException ex)
{
return(StatusCode(400, ex.Message));
}
catch (Exception ex)
{
LambdaLogger.Log(ex.Message);
return(StatusCode(500, "There was a problem retrieving the audit data from the database."));
}
}
public void SaveCard(Card card)
{
LambdaLogger.Log($"Entering: SaveCard({ JsonConvert.SerializeObject(card) })");
try
{
var cardList = new List <Card>
{
card
};
SvcContext.Repository
.Cards
.Save(cardList);
}
catch (Exception exp)
{
LambdaLogger.Log($"Error: { exp }");
}
LambdaLogger.Log($"Leaving: SaveCard({ JsonConvert.SerializeObject(card) })");
}
private decimal GetPortCount(DeviceDto device)
{
var portCountTag = device
.MetaTags
.FirstOrDefault(x => x.Name.Equals("PortCount", StringComparison.InvariantCultureIgnoreCase));
if (portCountTag == null)
{
LambdaLogger.Log("Did not find PortCount MetaTag, not adding ports for device '" + device.DisplayName + "'");
return(0);
}
if (!portCountTag.NumericValue.HasValue)
{
LambdaLogger.Log("PortCount does not have a valid numeric value for device '" + device.DisplayName + "'");
return(0);
}
LambdaLogger.Log("Found PortCount of " + portCountTag.NumericValue.Value + " for device '" + device.DisplayName + "'");
return(portCountTag.NumericValue.Value);
}
public string CreateSpreadsheet(string name)
{
LambdaLogger.Log("Set up credentials");
var credential = GoogleCredential.FromStream(new MemoryStream(Encoding.UTF8.GetBytes(_authToken))).CreateScoped(Scopes);
LambdaLogger.Log("Creating spreadsheet");
// Create Google Drive API service.
try
{
var driveService = new DriveService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = _applicationName,
});
LambdaLogger.Log("Setting up template");
var sheetTemplate = new Google.Apis.Drive.v3.Data.File()
{
Name = name,
MimeType = "application/vnd.google-apps.spreadsheet",
Parents = new List <string>
{
_uploadFolder
}
};
var request = driveService.Files.Create(sheetTemplate);
request.Fields = "id";
request.SupportsAllDrives = true;
LambdaLogger.Log("Executing request.");
var file = request.Execute();
LambdaLogger.Log($"Spreadsheet created: {file.Id}");
return(file.Id);
}
catch (Exception e)
{
LambdaLogger.Log(e.Message);
LambdaLogger.Log(e.StackTrace);
}
return(null);
}
public async Task <ApiGatewayResponse> FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
LambdaLogger.Log("CONTEXT: " + JsonConvert.SerializeObject(request));
//byte[] data = Convert.FromBase64String(request.Body);
//string decodedString = Encoding.UTF8.GetString(data);
var pet = JsonConvert.DeserializeObject <Pet>(request.Body);
if (string.IsNullOrEmpty(pet.Id))
{
pet.Id = AlphanumericFactory.RandomString(5);
}
PetService _service = new PetService();
await _service.PutPet(pet);
ApiGatewayResponse response = new ApiGatewayResponse()
{
StatusCode = 200,
Body = JsonConvert.SerializeObject(pet)
};
return(response);
}
private async Task <MicrobItem> CreateItem(string title, string content)
{
var id = Guid.NewGuid().ToString();
var now = DateTime.Now.ToString("MM/dd/yyyy h:mm tt");
var item = new Document();
item["Id"] = id;
item["Title"] = title;
item["Content"] = content;
item["DateCreated"] = now;
await _table.PutItemAsync(item);
LambdaLogger.Log($"*** INFO: Created item {id}");
var response = new MicrobItem {
id = id,
title = title,
content = content,
date = now
};
return(response);
}
public void FilterSongsToDelete()
{
var oldSongsToDelete = new List <SongCsvModel>();
foreach (var oldSong in OldSongs)
{
var found = false;
foreach (var newSong in NewSongs)
{
if (newSong.SongNumber == oldSong.SongNumber && newSong.Artist == oldSong.Artist && newSong.Title == oldSong.Title)
{
found = true;
}
}
if (!found)
{
oldSongsToDelete.Add(oldSong);
}
}
LambdaLogger.Log($"***INFO: old songs marked for deleting from database (oldSongsToDelete): {JsonConvert.SerializeObject(oldSongsToDelete)}");
SongsToDelete = oldSongsToDelete;
}
public ChoiceViewSwitch()
{
try
{
// CHOICEVIEW_SERVICEURL must have trailing slash - https://cvnet.radishsystems.com/ivr/api/
var apiUrl = Environment.GetEnvironmentVariable("CHOICEVIEW_SERVICEURL");
if (string.IsNullOrWhiteSpace(apiUrl))
{
LambdaLogger.Log("ChoiceView service url not available from environment.");
Valid = false;
}
else
{
BaseUri = new Uri(apiUrl);
ApiClient = new HttpClient(new ChoiceViewClientHandler(
Environment.GetEnvironmentVariable("CHOICEVIEW_CLIENTID"),
Environment.GetEnvironmentVariable("CHOICEVIEW_CLIENTSECRET")))
{
BaseAddress = BaseUri
};
ApiClient.DefaultRequestHeaders.Clear();
ApiClient.DefaultRequestHeaders.ConnectionClose = false;
ApiClient.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
ApiClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer");
Valid = true;
}
return;
}
catch (ArgumentException ex)
{
LambdaLogger.Log("ChoiceView API credentials not available from environment - " + ex.Message);
}
catch (UriFormatException ex)
{
LambdaLogger.Log("Invalid ChoiceView service url - " + ex.Message);
}
Valid = false;
}
public async Task Execute()
{
var lettersToCheck = await _localDatabaseGateway.GetLettersWaitingForGovNotify();
lettersToCheck.ForEach(async letter =>
{
try{
LambdaLogger.Log($"Checking status for letter {letter.Id}, doc no {letter.CominoDocumentNumber} Notify ID: {letter.GovNotifyNotificationId}");
var govNotifyResponse = _govNotifyGateway.GetStatusForLetter(letter.Id, letter.GovNotifyNotificationId);
var updateStatusTask = _localDatabaseGateway.UpdateStatus(letter.Id, govNotifyResponse.Status);
updateStatusTask.Wait();
var updateResponse = updateStatusTask.Result;
LambdaLogger.Log($"Updated status in Local DB to {govNotifyResponse.Status}");
if (updateResponse.StatusUpdated)
{
_logger.LogMessage(letter.Id, $"Gov Notify status: {govNotifyResponse.Status.PrettierStatusName()}").Wait();
}
}catch (NotifyClientException e) {
LambdaLogger.Log($"Error checking status of document. ({e.Message})");
}
});
}
