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})"); } }); }