static public async Task <bool> SendEmail(string to, string replyTo, string subject, string body) { Message msg = new Message(new Content(subject), new Body() { Html = new Content(body) }); SendEmailRequest req = new SendEmailRequest("*****@*****.**", new Destination(new List <string> { to }), msg) { ReturnPath = "*****@*****.**" }; if (!String.IsNullOrWhiteSpace(replyTo)) { req.ReplyToAddresses.Add(replyTo); } using (AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(new BasicAWSCredentials(Settings.SESAccessKey, Settings.SESSecret), RegionEndpoint.USWest2)) { try { var resp = await client.SendEmailAsync(req); return(true); } catch { return(false); } } }
public void GetEmailTemplate(string templateName) { using (AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(_regionEndpoint)) { try { GetTemplateResponse getTemplateResponse = client.GetTemplateAsync(new GetTemplateRequest { TemplateName = templateName }).Result; _logger.LogInformation($"GetTemplateResponse.HttpStatusCode = {getTemplateResponse.HttpStatusCode}"); _logger.LogInformation($"GetTemplateResponse.Template.TemplateName = {getTemplateResponse.Template.TemplateName}"); _logger.LogInformation($"GetTemplateResponse.Template.Subject = {getTemplateResponse.Template.SubjectPart}"); _logger.LogInformation($"GetTemplateResponse.Template.TextPart = {getTemplateResponse.Template.TextPart}"); } catch (Exception e) { _logger.LogError($"Failure while fetching template {templateName}, Error Message = " + e.Message); _logger.LogError($"Failure while fetching template {templateName}, e.InnerException.GetType() = {e.InnerException.GetType()}"); if (e.InnerException.GetType() == typeof(TemplateDoesNotExistException)) { _logger.LogError($"Failure while fetching template {templateName}, Template doesn't exist, Error Message = " + e.Message); throw e.InnerException; } throw e; } } }
public AmazonSesMailDeliveryService( GlobalSettings globalSettings, IWebHostEnvironment hostingEnvironment, ILogger <AmazonSesMailDeliveryService> logger) { if (string.IsNullOrWhiteSpace(globalSettings.Amazon?.AccessKeyId)) { throw new ArgumentNullException(nameof(globalSettings.Amazon.AccessKeyId)); } if (string.IsNullOrWhiteSpace(globalSettings.Amazon?.AccessKeySecret)) { throw new ArgumentNullException(nameof(globalSettings.Amazon.AccessKeySecret)); } if (string.IsNullOrWhiteSpace(globalSettings.Amazon?.Region)) { throw new ArgumentNullException(nameof(globalSettings.Amazon.Region)); } _globalSettings = globalSettings; _hostingEnvironment = hostingEnvironment; _logger = logger; _client = new AmazonSimpleEmailServiceClient(globalSettings.Amazon.AccessKeyId, globalSettings.Amazon.AccessKeySecret, RegionEndpoint.GetBySystemName(globalSettings.Amazon.Region)); _source = $"\"{globalSettings.SiteName}\" <{globalSettings.Mail.ReplyToEmail}>"; _senderTag = $"Server_{globalSettings.ProjectName}"; if (!string.IsNullOrWhiteSpace(_globalSettings.Mail.AmazonConfigSetName)) { _configSetName = _globalSettings.Mail.AmazonConfigSetName; } }
public async Task <EmailResult> SendEmail(EmailOptions options) { // Replace USWest2 with the AWS Region you're using for Amazon SES. // Acceptable values are EUWest1, USEast1, and USWest2. using (var client = new AmazonSimpleEmailServiceClient(Settings.Default.AccessKey.FromBase64(), Settings.Default.SecretKey.FromBase64(), RegionEndpoint.USEast1)) { var sendRequest = new SendRawEmailRequest { RawMessage = new RawMessage(GetMessageStream(options)) }; try { Console.WriteLine("Sending email using Amazon SES..."); var response = await client.SendRawEmailAsync(sendRequest); return(new EmailResult() { EmailId = response.MessageId, StatusCode = response.HttpStatusCode.ToString() }); } catch (Exception ex) { Console.WriteLine("The email was not sent. " + ex.ToString()); return(new EmailResult() { Error = ex.ToString(), StatusCode = "500" }); } } }
protected void SendMail(string url) { using (var sesClient = new AmazonSimpleEmailServiceClient(bucketRegion)) { var sendRequest = new SendEmailRequest { Source = "*****@*****.**", Destination = new Destination { ToAddresses = new List <string> { UserEmail } }, Message = new Message { Subject = new Amazon.SimpleEmail.Model.Content("Here's your file!"), Body = new Body { Text = new Amazon.SimpleEmail.Model.Content("Your download link!" + url) } } }; try { var response = sesClient.SendEmailAsync(sendRequest); Console.WriteLine("email sent to: " + UserEmail); } catch (Exception ex) { Console.WriteLine("error message: " + ex.Message); } } }
public void SendEmail() { if (_weatherEvaluators.Count == 0) { return; } string mainEmailMessage = this.buildBody(); string htmlBody = @"<html> <head></head> <body> " + mainEmailMessage + @" </body> </html>"; using (var client = new AmazonSimpleEmailServiceClient(RegionEndpoint.USEast1)) { var sendRequest = new SendEmailRequest { Source = senderAddress, Destination = new Destination { ToAddresses = _receiverAddresses }, Message = new Message { Subject = new Content(subject), Body = new Body { Html = new Content { Charset = "UTF-8", Data = htmlBody }, Text = new Content { Charset = "UTF-8", Data = textBody } } }, // If you are not using a configuration set, comment // or remove the following line //ConfigurationSetName = configSet }; try { Console.WriteLine("Sending email using Amazon SES..."); var response = client.SendEmailAsync(sendRequest); Console.WriteLine("The email was sent successfully."); } catch (Exception ex) { Console.WriteLine("The email was not sent."); Console.WriteLine("Error message: " + ex.Message); } } }
public async Task <MessageDispatchResult> SendAsync(IMessage message) { var mailMessage = EmailMessage.CreateFromMessage(message); var credentials = this.GetCredentials(); var client = new AmazonSimpleEmailServiceClient(credentials); var request = new SendRawEmailRequest { RawMessage = new RawMessage { Data = RawMailHelper.ConvertMailMessageToMemoryStream(mailMessage) } }; var response = await client.SendRawEmailAsync(request); if (response.HttpStatusCode == HttpStatusCode.OK && !string.IsNullOrEmpty(response.MessageId)) { return(new MessageDispatchResult { Succeeded = true, MessageId = response.MessageId }); } return(new MessageDispatchResult { Succeeded = false, MessageId = response.MessageId, Errors = $"{response.HttpStatusCode}: {StringifyMetaData(response.ResponseMetadata)}" }); }
public async Task <bool> SendEmail(List <string> to, string subject, string message, string link, string linkText) { var awsAccessKeyId = _config["AppSettings:AwsAccessKeyId"]; var awsSecretAccessKey = _config["AppSettings:AwsSecretAccessKey"]; var body = MailBody .CreateBody() .Paragraph("Hello,") .Paragraph(message) .Button("https://rankedtyping.com" + link, linkText) .Paragraph("- RankedTyping Team") .ToString(); using (var ses = new AmazonSimpleEmailServiceClient(awsAccessKeyId, awsSecretAccessKey, RegionEndpoint.USEast1)) { var sendResult = await ses.SendEmailAsync(new SendEmailRequest { Source = "*****@*****.**", Destination = new Destination(to), Message = new Message { Subject = new Content(subject), Body = new Body { Html = new Content(body) } } }); return(sendResult.HttpStatusCode == HttpStatusCode.OK); } }
public async Task SendAsync(MailMessageDTO message) { if (message.Attachments.Any()) { throw new NotSupportedException("Amazon SES API doesn't support e-mail attachments!"); } using (var client = new AmazonSimpleEmailServiceClient(awsAccessKeyId, awsSecretAccessKey)) { var sendRequest = new SendEmailRequest { Source = message.From.Address, Destination = new Destination { ToAddresses = message.To.Select(t => t.Address).ToList(), CcAddresses = message.Cc.Select(t => t.Address).ToList(), BccAddresses = message.Bcc.Select(t => t.Address).ToList() }, ReplyToAddresses = message.ReplyTo.Select(t => t.Address).ToList(), Message = new Message { Subject = new Content(message.Subject), Body = new Body { Text = new Content(message.BodyText), Html = new Content(message.BodyHtml) } } }; await client.SendEmailAsync(sendRequest); } }
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems) { AmazonSimpleEmailServiceConfig config = new AmazonSimpleEmailServiceConfig(); config.RegionEndpoint = region; ConfigureClient(config); AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(creds, config); ListCustomVerificationEmailTemplatesResponse resp = new ListCustomVerificationEmailTemplatesResponse(); do { ListCustomVerificationEmailTemplatesRequest req = new ListCustomVerificationEmailTemplatesRequest { NextToken = resp.NextToken , MaxResults = maxItems }; resp = client.ListCustomVerificationEmailTemplates(req); CheckError(resp.HttpStatusCode, "200"); foreach (var obj in resp.CustomVerificationEmailTemplates) { AddObject(obj); } }while (!string.IsNullOrEmpty(resp.NextToken)); }
public async Task AmazonEmailSendAsync(string userToaddress, string subject, string body) { try { var builder = new BodyBuilder(); string EmailConfirmationCode = RandomString(10, false); builder.HtmlBody = body; var oMessage = new MimeMessage(); oMessage.From.Add(new MailboxAddress("Autumn", "")); oMessage.To.Add(new MailboxAddress(userToaddress)); oMessage.Subject = subject; oMessage.Body = builder.ToMessageBody(); var stream = new MemoryStream(); oMessage.WriteTo(stream); var request = new SendRawEmailRequest { RawMessage = new RawMessage { Data = stream }, Source = "" }; using (var client = new AmazonSimpleEmailServiceClient()) { var response = await client.SendRawEmailAsync(request); } } catch (Exception ex) { throw; } }
static void Main(string[] args) { Console.WriteLine("Sending Email..."); // new Body(new Content("This is an email message sent from SES.")) using (var client = new AmazonSimpleEmailServiceClient(region: Amazon.RegionEndpoint.USEast1)) { var sendRequest = new SendEmailRequest { Source = "*****@*****.**", Destination = new Destination { ToAddresses = { "*****@*****.**" } }, Message = new Message { Subject = new Content("Hello from the Amazon Simple Email Service!"), Body = new Body { Html = new Content("<html><body><h2>Hello from Amazon SES</h2><ul><li>I'm a list item</li><li>So am I!</li></body></html>") } } }; try { var response = client.SendEmailAsync(sendRequest).Result; Console.WriteLine("Email sent! Message ID = {0}", response.MessageId); } catch (Exception ex) { Console.WriteLine("Send failed with exception: {0}", ex.Message); } } Console.Write("Press any key to continue..."); Console.ReadKey(); }
//verifica o status do e-mail na aws private void button2_Click(object sender, EventArgs e) { try { using (var client = new AmazonSimpleEmailServiceClient(awsAccessKeyId, awsSecretAccessKey, RegionEndpoint.SAEast1)) { var response = client.GetIdentityVerificationAttributes(new GetIdentityVerificationAttributesRequest { Identities = new List <string> { textBox1.Text } }); Dictionary <string, IdentityVerificationAttributes> verificationAttributes = response.VerificationAttributes; foreach (var i in verificationAttributes) { label1.Text = ""; label1.Text = "Status do E-mail: " + i.Value.VerificationStatus; label1.Visible = true; } } } catch (Exception err) { MessageBox.Show("Ocorreu um problema, verifique!: " + err.Message); } }
static async Task Main(string[] args) { using (var client = new AmazonSimpleEmailServiceClient(awsAccessKey, awsSecretKey, RegionEndpoint.USWest2)) { var watch = new System.Diagnostics.Stopwatch(); watch.Start(); int counter = 0; int sent = 10; Parallel.For(0, sent, new ParallelOptions { MaxDegreeOfParallelism = 4 }, count => { int progress = Interlocked.Increment(ref counter); var subject = "my subject " + counter.ToString(); SendEmailRequest sentEmailRequest = SendEmail(subject).Result; Console.WriteLine("Sending email using Amazon SES..."); var response = client.SendEmailAsync(sentEmailRequest); Console.WriteLine("The email was sent successfully."); }); watch.Stop(); TimeSpan ts = watch.Elapsed; Console.WriteLine($"It took {ts.Seconds} seconds"); Console.ReadKey(); } }
public static async Task <bool> SendEmail(string sender, string recipient, string subject, string body, string accedId, string accessKey) { try { using (AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(accedId, accessKey, RegionEndpoint.EUWest2)) { SendEmailRequest req = new SendEmailRequest(); req.Source = sender; req.Destination = new Destination(new List <string>() { recipient }); req.Message = new Message(); Content html = new Content(body); req.Message.Body = new Body(); req.Message.Body.Html = html; req.Message.Body.Text = new Content("Please enable html"); req.Message.Subject = new Content(subject); SendEmailResponse res = await client.SendEmailAsync(req).ConfigureAwait(false); return(true); } } catch { return(false); } }
public async Task <Object> Postman(string source, string destination, List <string> ccdestination, List <string> bccdestination, string subject, string body) { Console.WriteLine("Sending Email..."); using (var client = new AmazonSimpleEmailServiceClient(Amazon.RegionEndpoint.USEast1)) { var sendRequest = new SendEmailRequest { Source = source.ToString(), Destination = new Destination { ToAddresses = { destination }, CcAddresses = ccdestination, BccAddresses = bccdestination }, Message = new Message { Subject = new Content(subject.ToString()), Body = new Body { Html = new Content(body.ToString()) } } }; try { var response = client.SendEmailAsync(sendRequest).Result; Console.WriteLine("Email sent! Message ID = {0}", response.MessageId); return(new { response = response.MessageId }); } catch (Exception ex) { Console.WriteLine("Send failed with exception: {0}", ex.Message); return(new { error = ex.Message }); } } }
public void SendEmail(string fromAddress, string toAddress, string _subject, string _body) { Destination destination = new Destination(); destination.ToAddresses = (new List <string>() { toAddress }); Content subject = new Content(_subject); Content textBody = new Content(_body); Body body = new Body(textBody); Message message = new Message(subject, body); SendEmailRequest request = new SendEmailRequest(fromAddress, destination, message); Amazon.RegionEndpoint REGION = Amazon.RegionEndpoint.USEast1; // Instantiate an Amazon SES client, which will make the service call. AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(REGION); // Send the email. try { //("Attempting to send an email through Amazon SES by using the AWS SDK for .NET..."); client.SendEmail(request); //("Email sent!"); } catch (Exception ex) { //("Error message: " + ex.Message); } }
static void Main(string[] args) { //Remember to enter your (AWSAccessKeyID, AWSSecretAccessKey) if not using and IAM User with credentials assigned to your instance and your RegionEndpoint using (var client = new AmazonSimpleEmailServiceClient("YourAWSAccessKeyID", "YourAWSSecretAccessKey", RegionEndpoint.USEast1)) using (var messageStream = new MemoryStream()) { var message = new MimeMessage(); var builder = new BodyBuilder() { TextBody = "Hello World" }; message.From.Add(new MailboxAddress("*****@*****.**")); message.To.Add(new MailboxAddress("*****@*****.**")); message.Subject = "Hello World"; //I'm using the stream method, but you don't have to. using (FileStream stream = File.Open(@"Attachment1.pdf", FileMode.Open)) builder.Attachments.Add("Attachment1.pdf", stream); using (FileStream stream = File.Open(@"Attachment2.pdf", FileMode.Open)) builder.Attachments.Add("Attachment2.pdf", stream); message.Body = builder.ToMessageBody(); message.WriteTo(messageStream); var request = new SendRawEmailRequest() { RawMessage = new RawMessage() { Data = messageStream } }; client.SendRawEmail(request); } }
public AmazonSESProviderService(IOptions <ConfigOptions> emailProvidersConfig, ILogger <AmazonSESProviderService> logger) { _logger = logger; // TODO: Remove redundant method call _awsSES = new AmazonSimpleEmailServiceClient(emailProvidersConfig.Value.EmailProviders.AmazonSES.KeyId, emailProvidersConfig.Value.EmailProviders.AmazonSES.KeySecret, RegionEndpoint.EUWest1); }
/// <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(string input, ILambdaContext context) { IAmazonSQS sqsClient = new AmazonSQSClient(); ISqsAdapter sqsAdapter = new SqsAdapter(sqsClient, ""); IAmazonS3 s3Client = new AmazonS3Client(); IS3Adapter s3Adapter = new S3Adapter(s3Client); IEmailMessageRepository emailMessageRepository = new EmailMessageRepository(sqsAdapter, s3Adapter); IAmazonSimpleEmailService sesClient = new AmazonSimpleEmailServiceClient(); IEmailDeliveryConfig emailConfig = new EmailDeliveryConfig() { FromAddress = "" }; ISESAdapter sesAdapter = new SESAdapter(sesClient, emailConfig); IEmailMessageDelivery messageDelivery = new EmailMessageDelivery(sesAdapter); IEmailQueueProcessor emailProcessor = new EmailQueueProcessor(emailMessageRepository, messageDelivery); var emptyProcesses = 0; while (emptyProcesses <= 3 && context.RemainingTime > TimeSpan.FromSeconds(30)) { var count = await emailProcessor.ProcessEmailMessages(); if (count == 0) { emptyProcesses++; } } }
public void ConfigureDevelopmentServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); // Add S3 to the ASP.NET Core dependency injection framework. var settings = new LocalWindowsEnvironmentSettings(Configuration); services.AddSingleton <IEnvironmentSettings>(settings); var s3 = new Amazon.S3.AmazonS3Client(settings.AWSAccessKey, settings.AWSSecret, Amazon.RegionEndpoint.USWest2); services.AddSingleton <IAmazonS3>(s3); var emailService = new AmazonSimpleEmailServiceClient(settings.AWSAccessKey, settings.AWSSecret, Amazon.RegionEndpoint.USWest2); //var emailClient = new Mock<IAmazonSimpleEmailService>(); //emailClient.Setup(e => e.SendEmailAsync(It.IsAny<SendEmailRequest>(), new System.Threading.CancellationToken())) // .Callback<SendEmailRequest, System.Threading.CancellationToken>((req, token) => // { // Console.WriteLine("Email Sent:"); // Console.WriteLine(req.Message.Body); // }) // .Returns(Task.FromResult(new SendEmailResponse())); services.AddSingleton <IAmazonSimpleEmailService>(emailService); }
public async Task SendEmail(EmailDto email) { using var client = new AmazonSimpleEmailServiceClient(_key, _secret, RegionEndpoint.APSouth1); var sendRequest = new SendEmailRequest { Source = email.SenderAddress, Destination = new Destination { ToAddresses = new List <string> { email.ReceiverAddress } }, Message = new Message { Subject = new Content(email.Subject), Body = new Body { Text = new Content { Charset = "UTF-8", Data = email.TextBody } } } }; await client.SendEmailAsync(sendRequest); }
public AWSEmail() { var accessKey = ConfigurationManager.AppSettings["ses.accessKey"]; var secretKey = ConfigurationManager.AppSettings["ses.secretKey"]; _emailService = new AmazonSimpleEmailServiceClient(accessKey, secretKey); }
/// <summary> /// Asynchronously sends the provided IdentityMessage. /// </summary> /// <param name="message">The message to send.</param> /// <remarks> /// Sends the provided message using Amazon's Simple Email Service Client. /// /// If it is passed on ApplicationMessage, it will use it to populate /// both the HTML body and the plain text body. Otherwise, it will only /// populate the message body and let Amazon SES work out how to format /// it properly. /// /// Requires environment variable AWS_ACCESS_KEY_ID. /// </remarks> public Task SendAsync(IdentityMessage message) { var subject = new Content(message.Subject); var applicationMessage = message as ApplicationMessage; var body = new Body { Text = new Content(message.Body) }; if (applicationMessage != null) { body.Html = new Content(applicationMessage.HtmlBody); } var toEmail = new Destination(new List <string> { message.Destination }); var email = new Message(subject, body); var request = new SendEmailRequest(FromEmail, toEmail, email); var region = Amazon.RegionEndpoint.EUWest1; var client = new AmazonSimpleEmailServiceClient(region); client.SendEmail(request); return(Task.FromResult(0)); }
async static Task <List <SendDataPoint> > GetSesStatsForAccount(string Account) { string strRoleARN = "arn:aws:iam::" + Account + ":role/" + AssumedRoleName; Amazon.SecurityToken.AmazonSecurityTokenServiceClient stsClient = new Amazon.SecurityToken.AmazonSecurityTokenServiceClient(); var assumeRoleResponse = await stsClient.AssumeRoleAsync(new Amazon.SecurityToken.Model.AssumeRoleRequest { RoleArn = strRoleARN, RoleSessionName = "TempSession" }); SessionAWSCredentials sessionCredentials = new SessionAWSCredentials(assumeRoleResponse.Credentials.AccessKeyId, assumeRoleResponse.Credentials.SecretAccessKey, assumeRoleResponse.Credentials.SessionToken); var regions = new Amazon.RegionEndpoint[] { Amazon.RegionEndpoint.USEast1, Amazon.RegionEndpoint.USWest2, Amazon.RegionEndpoint.EUWest1 }; List <SendDataPoint> lst = new List <SendDataPoint>(); foreach (var region in regions) { Console.WriteLine($"Checking {region.ToString()} for account {Account}"); AmazonSimpleEmailServiceClient sesClient = new AmazonSimpleEmailServiceClient(sessionCredentials, region); var response = await sesClient.GetSendStatisticsAsync(); lst.AddRange(response.SendDataPoints); } return(lst); }
public async Task SendEmailsAsync(IEnumerable <string> emails, string subject, string message) { _logger.LogInformation("sending email to {0} with subject {1}", string.Join(", ", emails), subject); SendEmailRequest emailRequest = new SendEmailRequest() { Source = _authOptions.FromAddress, Destination = new Destination(emails.ToList()), Message = new Message() { Body = new Body() { Html = new Content(message) }, Subject = new Content(subject) } }; AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(_authOptions.SesAwsAccessKeyID, _authOptions.SesAwsAccessKey, _authOptions.Region); try { SendEmailResponse response = await client.SendEmailAsync(emailRequest); _logger.LogInformation("successfully send email to {0}", string.Join(", ", emails)); } catch (Exception e) { _logger.LogError("failed to send email to {0} with error {1}", string.Join(", ", emails), e); } }
private async Task <bool> SendMessage(CognitoAWSCredentials creds, RegionEndpoint region) { bool result; try { AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(creds, region); var mailRequest = new SendEmailRequest { Destination = new Destination { /* BccAddresses = new List<string> * { * "*****@*****.**" * }, * CcAddresses = new List<string> { * "*****@*****.**" * },*/ ToAddresses = new List <string> { ToEMailTextBox.Text } }, Message = new Amazon.SimpleEmail.Model.Message { Body = new Body { Html = new Content { Charset = "UTF-8", Data = MessageTextBox.Text }, Text = new Content { Charset = "UTF-8", Data = "This is the message body in text format." } }, Subject = new Content { Charset = "UTF-8", Data = SubjectTextBox.Text } }, ReplyToAddresses = new List <string> { ReplyToEMailTextBox.Text }, Source = "*****@*****.**" }; var response = await client.SendEmailAsync(mailRequest);; string messageId = response.MessageId; result = true; } catch (Exception ex) { Console.WriteLine(ex.Message); result = false; } return(result); }
public override void Init(IDictionary <string, string> properties) { base.Init(properties); ses = new AmazonSimpleEmailServiceClient(properties["accessKey"], properties["secretKey"]); refreshTimeout = TimeSpan.Parse(properties.ContainsKey("refreshTimeout") ? properties["refreshTimeout"] : "0:30:0"); lastRefresh = DateTime.UtcNow - refreshTimeout; //set to refresh on first send }
public Task SendEmailAsync(string email, string subject, string message) { using var client = new AmazonSimpleEmailServiceClient(this.Options.RegionEndpoint); var sendRequest = new SendEmailRequest { Source = this.Options.SenderAddress, Destination = new Destination { ToAddresses = new List <string> { email } }, Message = new Message { Subject = new Content(subject), Body = new Body { Html = new Content { Charset = "UTF-8", Data = message }, Text = new Content { Charset = "UTF-8", Data = message } } }, // todo ConfigurationSetNameについて調査 // ConfigurationSetName = configSet }; return(client.SendEmailAsync(sendRequest)); }
public async Task <bool> SendEmail(MailMessage email) { var accessKey = _config["AWS:SES:AccessKeyId"]; var secret = _config["AWS:SES:AccessKeySecret"]; var creds = new BasicAWSCredentials(accessKey, secret); using (var client = new AmazonSimpleEmailServiceClient(creds, RegionEndpoint.USEast1)) { var req = new SendEmailRequest() { Source = email.From.Address, Destination = new Destination() { ToAddresses = email.To.Select(e => e.Address).ToList() }, Message = ReformatToAWSMessage(email), }; try { var response = await client.SendEmailAsync(req); return(true); } catch (Exception e) { return(false); } } }