public async Task <bool> SendEmailToUsers(SendEmailToUsersRequest sendEmailToUsersRequest)
        {
            List <int> UserIds = new List <int>();

            if (sendEmailToUsersRequest.Recipients.ToUserIDs?.Count() > 0)
            {
                UserIds.AddRange(sendEmailToUsersRequest.Recipients.ToUserIDs);
            }

            if (sendEmailToUsersRequest.Recipients.CCUserIDs?.Count() > 0)
            {
                UserIds.AddRange(sendEmailToUsersRequest.Recipients.CCUserIDs);
            }

            if (sendEmailToUsersRequest.Recipients.BCCUserIDs?.Count() > 0)
            {
                UserIds.AddRange(sendEmailToUsersRequest.Recipients.BCCUserIDs);
            }


            var DistinctUsers = UserIds.Distinct().ToList();


            List <User> Users = _connectUserService
                                .PostUsersForListOfUserID(DistinctUsers)
                                .Result;

            return(await SendEmail(sendEmailToUsersRequest, Users));
        }
Ejemplo n.º 2
0
        public async Task <bool> SendEmailToUsersAsync(SendEmailToUsersRequest request, CancellationToken cancellationToken)
        {
            string path        = $"api/SendEmailToUsers";
            var    jsonContent = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");

            using (HttpResponseMessage response = await _httpClientWrapper.PostAsync(HttpClientConfigName.CommunicationService, path, jsonContent, cancellationToken).ConfigureAwait(false)){
                string jsonResponse = await response.Content.ReadAsStringAsync();

                var emailSentResponse = JsonConvert.DeserializeObject <ResponseWrapper <SendEmailResponse, CommunicationServiceErrorCode> >(jsonResponse);
                if (emailSentResponse.HasContent && emailSentResponse.IsSuccessful)
                {
                    return(emailSentResponse.Content.Success);;
                }
                return(false);
            }
        }
        public async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)]
            [RequestBodyType(typeof(SendEmailToUsersRequest), "Send Email To Users")] SendEmailToUsersRequest req,
            ILogger log)
        {
            try
            {
                NewRelic.Api.Agent.NewRelic.SetTransactionName("CommunicationService", "SendEmailToUsers");
                log.LogInformation("C# HTTP trigger function processed a request.");
                SendEmailResponse response = await _mediator.Send(req);

                return(new OkObjectResult(ResponseWrapper <SendEmailResponse, CommunicationServiceErrorCode> .CreateSuccessfulResponse(response)));
            }
            catch (Exception exc)
            {
                LogError.Log(log, exc, req);
                return(new ObjectResult(ResponseWrapper <SendEmailResponse, CommunicationServiceErrorCode> .CreateUnsuccessfulResponse(CommunicationServiceErrorCode.InternalServerError, "Internal Error"))
                {
                    StatusCode = StatusCodes.Status500InternalServerError
                });
            }
        }
        private async Task <bool> SendEmail(SendEmailToUsersRequest sendEmailToUsersRequest, List <User> Users)
        {
            var apiKey = _sendGridConfig.Value.ApiKey;

            if (apiKey == string.Empty)
            {
                throw new Exception("SendGrid Api Key missing.");
            }

            var client = new SendGridClient(apiKey);
            var eml    = new SendGridMessage()
            {
                From             = new EmailAddress(_sendGridConfig.Value.FromEmail, _sendGridConfig.Value.FromName),
                Subject          = sendEmailToUsersRequest.Subject,
                PlainTextContent = sendEmailToUsersRequest.BodyText,
                HtmlContent      = sendEmailToUsersRequest.BodyHTML
            };

            if (sendEmailToUsersRequest.Recipients.ToUserIDs?.Count() > 0)
            {
                foreach (int userId in sendEmailToUsersRequest.Recipients.ToUserIDs)
                {
                    var User = Users.Where(w => w.ID == userId).FirstOrDefault();
                    if (User != null && User.UserPersonalDetails != null)
                    {
                        eml.AddTo(new EmailAddress(User.UserPersonalDetails.EmailAddress, User.UserPersonalDetails.FirstName + " " + User.UserPersonalDetails.LastName));
                    }
                }
            }

            if (sendEmailToUsersRequest.Recipients.CCUserIDs?.Count() > 0)
            {
                foreach (int userId in sendEmailToUsersRequest.Recipients.CCUserIDs)
                {
                    var User = Users.Where(w => w.ID == userId).FirstOrDefault();
                    if (User != null && User.UserPersonalDetails != null)
                    {
                        eml.AddCc(new EmailAddress(User.UserPersonalDetails.EmailAddress, User.UserPersonalDetails.FirstName + " " + User.UserPersonalDetails.LastName));
                    }
                }
            }

            if (sendEmailToUsersRequest.Recipients.BCCUserIDs?.Count() > 0)
            {
                foreach (int userId in sendEmailToUsersRequest.Recipients.BCCUserIDs)
                {
                    var User = Users.Where(w => w.ID == userId).FirstOrDefault();
                    if (User != null && User.UserPersonalDetails != null)
                    {
                        eml.AddBcc(new EmailAddress(User.UserPersonalDetails.EmailAddress, User.UserPersonalDetails.FirstName + " " + User.UserPersonalDetails.LastName));
                    }
                }
            }

            Response response = await client.SendEmailAsync(eml);

            if (response.StatusCode == System.Net.HttpStatusCode.OK || response.StatusCode == System.Net.HttpStatusCode.Accepted)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }