public static void SESSendRawEmail()
{
#region SESSendRawEmail
// using System.IO;
var sesClient = new AmazonSimpleEmailServiceClient();
var stream = new MemoryStream(
Encoding.UTF8.GetBytes("From: [email protected]\n" +
"To: [email protected]\n" +
"Subject: You're invited to the meeting\n" +
"Content-Type: text/plain\n\n" +
"Please join us Monday at 7:00 PM.")
);
var raw = new RawMessage
{
Data = stream
};
var to = new List<string>() { "*****@*****.**" };
var from = "*****@*****.**";
var request = new SendRawEmailRequest
{
Destinations = to,
RawMessage = raw,
Source = from
};
sesClient.SendRawEmail(request);
#endregion
}
public static string sendInvEmail(string email, string subject, string msg, string attach1, string attach2)
{
try
{
Amazon.SimpleEmail.AmazonSimpleEmailServiceConfig config = new Amazon.SimpleEmail.AmazonSimpleEmailServiceConfig();
config.RegionEndpoint = Amazon.RegionEndpoint.USEast1;
Amazon.SimpleEmail.AmazonSimpleEmailServiceClient client = new Amazon.SimpleEmail.AmazonSimpleEmailServiceClient("AKIAI6NU4VLLI32AI2UA", Cryptography.Decrypt("NdL0xWLhvbF6pvu3hw1FtluhPmUc1jAuWKgj6mb4V89KztEq6MjEhQoiCPLVv4y9"), config);
var stream = new MemoryStream();
MimeMessage objMessage = new MimeMessage();
string[] emls = email.Split(',');
foreach (string eml in emls)
{
objMessage.To.Add(new MailboxAddress(string.Empty, eml));
}
objMessage.From.Add(new MailboxAddress("InfnIT Invoice", "*****@*****.**"));
objMessage.Subject = subject;
BodyBuilder emailBodyObj = new BodyBuilder();
emailBodyObj.HtmlBody = msg;
emailBodyObj.Attachments.Add(attach1);
emailBodyObj.Attachments.Add(attach2);
objMessage.Body = emailBodyObj.ToMessageBody();
objMessage.WriteTo(stream);
Amazon.SimpleEmail.Model.SendRawEmailRequest mailObj = new Amazon.SimpleEmail.Model.SendRawEmailRequest(new RawMessage(stream));
SendRawEmailResponse response = client.SendRawEmail(mailObj);
string res = response.MessageId;
System.Net.Mail.MailMessage aMessage = new System.Net.Mail.MailMessage();
aMessage.From = new System.Net.Mail.MailAddress("*****@*****.**", "InfnIT Invoice");
//aMessage.To.Add(email);
//aMessage.ReplyTo = new System.Net.Mail.MailAddress("*****@*****.**");
//aMessage.Subject = subject;
//System.Net.Mail.AlternateView htmlView = System.Net.Mail.AlternateView.CreateAlternateViewFromString(msg, System.Text.Encoding.UTF8, "text/html");
//aMessage.IsBodyHtml = true;
//aMessage.BodyEncoding = System.Text.Encoding.UTF8;
//aMessage.Attachments.Add(new System.Net.Mail.Attachment(attach1));
//aMessage.Attachments.Add(new System.Net.Mail.Attachment(attach2));
//aMessage.AlternateViews.Add(htmlView);
//System.Net.Mail.SmtpClient mailClient = new System.Net.Mail.SmtpClient();
//mailClient.Host = "smtp.gmail.com";
//mailClient.Port = 587;
//mailClient.EnableSsl = true;
//mailClient.Credentials = new System.Net.NetworkCredential("*****@*****.**", "m4iling2");
//mailClient.Send(aMessage);
return("success");//downloadCfdi += "<p>Correo enviado";
}
catch (Exception ex)
{
return(ex.Message);
//downloadCfdi += "<p><i class=\"w3-red\">No se pudo enviar el correo: +" + ex.Message + "</i>";
}
}
public static void Send(string from, string to, string bcc, string subject, string body)
{
using (var client = new AmazonSimpleEmailServiceClient(Settings.AccessKey, Settings.Secret, RegionEndpoint.USWest2))
{
var request = new SendRawEmailRequest
{
Source = from,
Destinations = new List<string> { to, bcc },
RawMessage = CreateMessage(from, to, bcc, subject, body)
};
client.SendRawEmail(request);
}
}
public static void SendVerificationEmail(string emailaddress, string validation_guid)
{
const string VERIFICATION_DOMAIN = "https://nzixo03fx1.execute-api.us-west-2.amazonaws.com/prod/emailvalidation?verificationstring="; //TODO: Move this to our domain name prior to launch
const string FROM = "*****@*****.**"; //TODO: Change to real domain name
const string SUBJECT = "Please verify your email address";
string TO = emailaddress;
string mBase64EncodedGuid = Convert.ToBase64String(Encoding.UTF8.GetBytes(emailaddress + ":" + validation_guid));
var message = new MimeMessage();
message.From.Add(new MailboxAddress("GEM CARRY EMAIL VERIFICATION", FROM));
message.To.Add(new MailboxAddress("New Gamer", TO));
message.Subject = SUBJECT;
var builder = new BodyBuilder();
builder.TextBody = string.Format("To activate your account, please click the following link to verifiy your email address {0}{1}", VERIFICATION_DOMAIN, mBase64EncodedGuid);
builder.HtmlBody = string.Format("To activate your account, please click <a href={0}{1}> here</a> to verify your email address.",VERIFICATION_DOMAIN,mBase64EncodedGuid);
message.Body = builder.ToMessageBody();
var stream = new MemoryStream();
message.WriteTo(stream);
try
{
AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient();
var request = new SendRawEmailRequest { RawMessage = new RawMessage { Data = stream } };
client.SendRawEmail(request);
#if DEBUG
logger.WriteLog(GameLogger.LogLevel.Debug, string.Format("Generating Validation Email for {0}.", emailaddress));
#endif // DEBUG
}
catch (Exception ex)
{
logger.WriteLog(GameLogger.LogLevel.Error, ex.Message.ToString());
}
}
/// <summary>
/// Initiates the asynchronous execution of the SendRawEmail operation.
/// <seealso cref="Amazon.SimpleEmail.IAmazonSimpleEmailService.SendRawEmail"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendRawEmail operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<SendRawEmailResponse> SendRawEmailAsync(SendRawEmailRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SendRawEmailRequestMarshaller();
var unmarshaller = SendRawEmailResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, SendRawEmailRequest, SendRawEmailResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
/// <summary>
/// Sends a raw email.
/// </summary>
/// <param name="request">
/// A <see cref="SendRawEmailRequest" /> object.
/// </param>
/// <returns>
/// The unique <see cref="Message" /> ID for the email.
/// </returns>
internal string SendRawEmail(SendRawEmailRequest request)
{
SendRawEmailResponse response = _sesClient.SendRawEmail(request);
return response != null && response.SendRawEmailResult != null ? response.SendRawEmailResult.MessageId : string.Empty;
}
/// <summary>
/// <para>Sends an email message, with header and content specified by the client. The <c>SendRawEmail</c> action is useful for sending
/// multipart MIME emails. The raw text of the message must comply with Internet email standards; otherwise, the message cannot be sent. </para>
/// <para><b>IMPORTANT:</b> You can only send email from verified email addresses and domains. If you have not requested production access to
/// Amazon SES, you must also verify every recipient email address except for the recipients provided by the Amazon SES mailbox simulator. For
/// more information, go to the Amazon SES Developer Guide. </para> <para>The total size of the message cannot exceed 10 MB. This includes any
/// attachments that are part of the message.</para> <para>Amazon SES has a limit on the total number of recipients per message: The combined
/// number of To:, CC: and BCC: email addresses cannot exceed 50. If you need to send an email message to a larger audience, you can divide your
/// recipient list into groups of 50 or fewer, and then call Amazon SES repeatedly to send the message to each group. </para> <para>For every
/// message that you send, the total number of recipients (To:, CC: and BCC:) is counted against your <i>sending quota</i> - the maximum number
/// of emails you can send in a 24-hour period. For information about your sending quota, go to the <a href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/manage-sending-limits.html">Amazon SES Developer Guide</a> .
/// </para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendRawEmail service method on
/// AmazonSimpleEmailService.</param>
///
/// <returns>The response from the SendRawEmail service method, as returned by AmazonSimpleEmailService.</returns>
///
/// <exception cref="T:Amazon.SimpleEmail.Model.MessageRejectedException" />
public SendRawEmailResponse SendRawEmail(SendRawEmailRequest request)
{
var task = SendRawEmailAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Initiates the asynchronous execution of the SendRawEmail operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendRawEmail operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<SendRawEmailResponse> SendRawEmailAsync(SendRawEmailRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SendRawEmailRequestMarshaller();
var unmarshaller = SendRawEmailResponseUnmarshaller.Instance;
return InvokeAsync<SendRawEmailRequest,SendRawEmailResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the SendRawEmail operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendRawEmail operation on AmazonSimpleEmailServiceClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendRawEmail
/// operation.</returns>
public IAsyncResult BeginSendRawEmail(SendRawEmailRequest request, AsyncCallback callback, object state)
{
var marshaller = new SendRawEmailRequestMarshaller();
var unmarshaller = SendRawEmailResponseUnmarshaller.Instance;
return BeginInvoke<SendRawEmailRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Initiates the asynchronous execution of the SendRawEmail operation.
/// <seealso cref="Amazon.SimpleEmail.AmazonSimpleEmailService.SendRawEmail"/>
/// </summary>
///
/// <param name="sendRawEmailRequest">Container for the necessary parameters to execute the SendRawEmail operation on
/// AmazonSimpleEmailService.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendRawEmail
/// operation.</returns>
public IAsyncResult BeginSendRawEmail(SendRawEmailRequest sendRawEmailRequest, AsyncCallback callback, object state)
{
return invokeSendRawEmail(sendRawEmailRequest, callback, state, false);
}
public void SendEmailWithAttachment()
{
var client = Amazon.AWSClientFactory.CreateAmazonSimpleEmailServiceClient(EmailProcessingConfigurationManager.Section.Amazon.Key, EmailProcessingConfigurationManager.Section.Amazon.Secret);
MailMessage m = new MailMessage();
var attachment = new Attachment("TextFile1.txt", "text/plain");
attachment.TransferEncoding = TransferEncoding.QuotedPrintable;
m.Attachments.Add(attachment);
m.Body = "hello";
m.Subject = "hello";
m.To.Add("*****@*****.**");
m.From = new MailAddress("*****@*****.**");
var messageData = ConvertMailMessageToMemoryStream(m);
RawMessage message = new RawMessage(messageData);
SendRawEmailRequest request = new SendRawEmailRequest(message);
var response = client.SendRawEmail(request);
}
public bool SendEmailWithAttachments(string AWSAccessKey, string AWSSecretKey, MailAddress From, MailAddress[] To, String Subject, System.Net.Mail.Attachment[] Attachments, String Text = null, String Html = null, MailAddress ReplyTo = null, MailAddress[] CCAddresses = null, MailAddress[] BCCAddresses = null)
{
AlternateView plainView = null;
if (Text != null)
plainView = AlternateView.CreateAlternateViewFromString(Text, Encoding.UTF8, "text/plain");
AlternateView htmlView = null;
if (Html != null)
htmlView = AlternateView.CreateAlternateViewFromString(Html, Encoding.UTF8, "text/html");
MailMessage mailMessage = new MailMessage();
mailMessage.From = From;
foreach (MailAddress toAdd in To ?? Enumerable.Empty<MailAddress>())
mailMessage.To.Add(toAdd);
foreach (MailAddress toCC in CCAddresses ?? Enumerable.Empty<MailAddress>())
mailMessage.CC.Add(toCC);
foreach (MailAddress toBcc in BCCAddresses ?? Enumerable.Empty<MailAddress>())
mailMessage.Bcc.Add(toBcc);
mailMessage.Subject = Subject;
mailMessage.SubjectEncoding = Encoding.UTF8;
if (ReplyTo != null)
{
mailMessage.ReplyTo = ReplyTo;
}
if (Text != null)
{
mailMessage.AlternateViews.Add(plainView);
}
if (Html != null)
{
mailMessage.AlternateViews.Add(htmlView);
}
foreach (System.Net.Mail.Attachment a in Attachments ?? Enumerable.Empty<System.Net.Mail.Attachment>())
{
mailMessage.Attachments.Add(a);
}
RawMessage rawMessage = new RawMessage();
using (MemoryStream memoryStream = ConvertMailMessageToMemoryStream(mailMessage))
{
rawMessage.WithData(memoryStream);
}
SendRawEmailRequest request = new SendRawEmailRequest();
request.WithRawMessage(rawMessage);
request.WithDestinations(To.Select(a => a.Address));
request.WithSource(From.Address);
AmazonSimpleEmailService ses = AWSClientFactory.CreateAmazonSimpleEmailServiceClient(AWSAccessKey, AWSSecretKey);
try
{
SendRawEmailResponse response = ses.SendRawEmail(request);
SendRawEmailResult result = response.SendRawEmailResult;
return true;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("There was an error sending the e-mail: {0}", ex.Message));
return false;
}
}
public void enviarCorreoInstruc(JGA_PGS_NAV navieraCorreo, List<JGA_PGS_CXE> contactosNav, JGA_PGS_AGEN agenciaNacional,
List<JGA_PGS_CXE> contactosAgenN, JGA_PGS_ENT embarcador, List<JGA_PGS_CXE> contactosEmb,
JGA_PGS_USR usuario, JGA_REPORTESPDF jga_reportespdf, Byte[] binary)
{
//acá empieza el método para enviar el correo electrónico a las personas pertinentes.
//enviamos al método ISFEmail las listas de los datos para envio del correo a las personas correspondientes.
var message = (MimeMessage)InstrucEmail(navieraCorreo, contactosNav, agenciaNacional, contactosAgenN, embarcador, contactosEmb, usuario, jga_reportespdf, binary);
var stream = new MemoryStream();
message.WriteTo(stream);
//acá seteamos las credenciales que nos provee AWS para el envío de correos electrónicos.
AWSCredentials credentials = new BasicAWSCredentials("AKIAI5LCJ5RFIUB4NJUQ", "XTRtXuW+mxYg2nZOtc7MnErmwJFRD5kgAKCPjmjU");
//seteamos una variable con las credenciales y la zona que tenemos de AWS.
using (var client = AWSClientFactory.CreateAmazonSimpleEmailServiceClient(credentials, RegionEndpoint.USEast1))
{
var request = new SendRawEmailRequest { RawMessage = new RawMessage { Data = stream } };
//acá ejecutamos el envio del correo.
var response = client.SendRawEmail(request);
}
}
private void MessageNotif(JGA_PROYECCION proyeccion, JGA_PGS_ENT suplidor, List<JGA_PGS_CXE> contactosSup, JGA_PGS_ENT embarcador, List<JGA_PGS_CXE> contactosEmb, JGA_PGS_USR usuario)
{
//Se envía al método notifEmail las listas de los emails de los destinatarios.
var message = (MimeMessage)notifEmail(proyeccion, suplidor, contactosSup, embarcador, contactosEmb, usuario);
var stream = new MemoryStream();
message.WriteTo(stream);
//acá seteamos las credenciales que nos provee AWS para el envío de correos electrónicos.
AWSCredentials credentials = new BasicAWSCredentials("AKIAI5LCJ5RFIUB4NJUQ", "XTRtXuW+mxYg2nZOtc7MnErmwJFRD5kgAKCPjmjU");
//seteamos una variable con las credenciales y la zona que tenemos de AWS.
using (var client = AWSClientFactory.CreateAmazonSimpleEmailServiceClient(credentials, RegionEndpoint.USEast1))
{
var request = new SendRawEmailRequest { RawMessage = new RawMessage { Data = stream } };
//acá ejecutamos el envio del correo.
var response = client.SendRawEmail(request);
}
}
/// <summary>
/// Initiates the asynchronous execution of the SendRawEmail operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendRawEmail operation on AmazonSimpleEmailServiceClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void SendRawEmailAsync(SendRawEmailRequest request, AmazonServiceCallback<SendRawEmailRequest, SendRawEmailResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new SendRawEmailRequestMarshaller();
var unmarshaller = SendRawEmailResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<SendRawEmailRequest,SendRawEmailResponse> responseObject
= new AmazonServiceResult<SendRawEmailRequest,SendRawEmailResponse>((SendRawEmailRequest)req, (SendRawEmailResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<SendRawEmailRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
IAsyncResult invokeSendRawEmail(SendRawEmailRequest request, AsyncCallback callback, object state, bool synchronized)
{
var marshaller = new SendRawEmailRequestMarshaller();
var unmarshaller = SendRawEmailResponseUnmarshaller.Instance;
return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer);
}
//From E-mail address must be verified through Amazon
/// <summary>
/// Text Only for now, no attachments yet. Amazon SES is still in Beta
/// </summary>
/// <param name="AWSAccessKey">public key associated with our Amazon Account</param>
/// <param name="AWSSecretKey">private key associated with our Amazon Account</param>
/// <param name="From">Who is the e-mail from, this must be a verified e-mail address through Amazon</param>
/// <param name="To">Who do you want to send the E-mail to, seperate multiple addresses with a comma</param>
/// <param name="Subject">Subject of e-mail</param>
/// <param name="Attachment">File Location of attachment. PDF's, text files and images supported, seperate multiple addresses with a comma</param>
/// <param name="Text">Plain text for e-mail, can be null</param>
/// <param name="Html">Html view for e-mail, can be null</param>
/// <param name="ReplyTo ">Email address for replies, can be null</param>
/// <param name="CCAddresses ">ArrayList of strings for CC'd addresses</param>
/// <param name="BCCAddresses ">ArrayList of strings for BCC'd addresses</param>
public bool SendEmailWithAttachments(string AWSAccessKey, string AWSSecretKey, String From, String To, String Subject, String Attachment, String Text = null, String Html = null, String ReplyTo = null, ArrayList CCAddresses = null, ArrayList BCCAddresses = null)
{
AlternateView plainView = null;
if (Text != null)
plainView = AlternateView.CreateAlternateViewFromString(Text, Encoding.UTF8, "text/plain");
AlternateView htmlView = null;
if (Html != null)
htmlView = AlternateView.CreateAlternateViewFromString(Html, Encoding.UTF8, "text/html");
MailMessage mailMessage = new MailMessage();
mailMessage.From = new MailAddress(From);
List<String> toAddresses = To.Replace(", ", ",").Split(',').ToList();
foreach (String toAddress in toAddresses)
{
mailMessage.To.Add(new MailAddress(toAddress));
}
if (CCAddresses != null)
{
foreach (String ccAddress in CCAddresses)
{
mailMessage.CC.Add(new MailAddress(ccAddress));
}
}
if (BCCAddresses != null)
{
foreach (String bccAddress in BCCAddresses)
{
mailMessage.Bcc.Add(new MailAddress(bccAddress));
}
}
mailMessage.Subject = Subject;
mailMessage.SubjectEncoding = Encoding.UTF8;
if (ReplyTo != null)
{
mailMessage.ReplyTo = new MailAddress(ReplyTo);
}
if (Text != null)
{
mailMessage.AlternateViews.Add(plainView);
}
if (Html != null)
{
mailMessage.AlternateViews.Add(htmlView);
}
// Attachment Fix
//System.Net.Mail.Attachment a = new System.Net.Mail.Attachment(Attachment);
//mailMessage.Attachments.Add(a);
foreach (String attachment in Attachment.Replace(", ", ",").Split(',').ToList())
{
System.Net.Mail.Attachment a = new System.Net.Mail.Attachment(attachment);
mailMessage.Attachments.Add(a);
}
RawMessage rawMessage = new RawMessage();
using (MemoryStream memoryStream = ConvertMailMessageToMemoryStream(mailMessage))
{
rawMessage.WithData(memoryStream);
}
SendRawEmailRequest request = new SendRawEmailRequest();
request.WithRawMessage(rawMessage);
request.WithDestinations(toAddresses);
request.WithSource(From);
AmazonSimpleEmailService ses = AWSClientFactory.CreateAmazonSimpleEmailServiceClient(AWSAccessKey, AWSSecretKey);
try
{
SendRawEmailResponse response = ses.SendRawEmail(request);
SendRawEmailResult result = response.SendRawEmailResult;
return true;
}
catch
{
return false;
}
}
IAsyncResult invokeSendRawEmail(SendRawEmailRequest sendRawEmailRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new SendRawEmailRequestMarshaller().Marshall(sendRawEmailRequest);
var unmarshaller = SendRawEmailResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// <para>Sends an email message, with header and content specified by the
/// client. The <c>SendRawEmail</c> action is useful for sending multipart
/// MIME emails, with attachments or inline content.</para> <para>The raw
/// text of the message must comply with Internet email standards;
/// otherwise, the message cannot be sent. For more information, go to
/// the Amazon SES Developer Guide.</para>
/// </summary>
///
/// <param name="sendRawEmailRequest">Container for the necessary
/// parameters to execute the SendRawEmail service method on
/// AmazonSimpleEmailService.</param>
///
/// <returns>The response from the SendRawEmail service method, as
/// returned by AmazonSimpleEmailService.</returns>
///
/// <exception cref="MessageRejectedException"/>
public SendRawEmailResponse SendRawEmail(SendRawEmailRequest sendRawEmailRequest)
{
IRequest<SendRawEmailRequest> request = new SendRawEmailRequestMarshaller().Marshall(sendRawEmailRequest);
SendRawEmailResponse response = Invoke<SendRawEmailRequest, SendRawEmailResponse> (request, this.signer, SendRawEmailResponseUnmarshaller.GetInstance());
return response;
}
/// <summary>
/// <para>Sends an email message, with header and content specified by the client. The <c>SendRawEmail</c> action is useful for sending
/// multipart MIME emails. The raw text of the message must comply with Internet email standards; otherwise, the message cannot be sent. </para>
/// <para><b>IMPORTANT:</b>If you have not yet requested production access to Amazon SES, then you will only be able to send email to and from
/// verified email addresses and domains. For more information, go to the Amazon SES Developer Guide. </para> <para>The total size of the
/// message cannot exceed 10 MB. This includes any attachments that are part of the message.</para> <para>Amazon SES has a limit on the total
/// number of recipients per message: The combined number of To:, CC: and BCC: email addresses cannot exceed 50. If you need to send an email
/// message to a larger audience, you can divide your recipient list into groups of 50 or fewer, and then call Amazon SES repeatedly to send the
/// message to each group. </para> <para>For every message that you send, the total number of recipients (To:, CC: and BCC:) is counted against
/// your <i>sending quota</i> - the maximum number of emails you can send in a 24-hour period. For information about your sending quota, go to
/// the "Managing Your Sending Activity" section of theAmazon SES Developer Guide. </para>
/// </summary>
///
/// <param name="sendRawEmailRequest">Container for the necessary parameters to execute the SendRawEmail service method on
/// AmazonSimpleEmailService.</param>
///
/// <returns>The response from the SendRawEmail service method, as returned by AmazonSimpleEmailService.</returns>
///
/// <exception cref="MessageRejectedException"/>
public SendRawEmailResponse SendRawEmail(SendRawEmailRequest sendRawEmailRequest)
{
IAsyncResult asyncResult = invokeSendRawEmail(sendRawEmailRequest, null, null, true);
return EndSendRawEmail(asyncResult);
}
public object Execute(ExecutorContext context)
{
System.IO.MemoryStream _RawMessage_DataStream = null;
try
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.SimpleEmail.Model.SendRawEmailRequest();
if (cmdletContext.ConfigurationSetName != null)
{
request.ConfigurationSetName = cmdletContext.ConfigurationSetName;
}
if (cmdletContext.Destination != null)
{
request.Destinations = cmdletContext.Destination;
}
if (cmdletContext.FromArn != null)
{
request.FromArn = cmdletContext.FromArn;
}
// populate RawMessage
var requestRawMessageIsNull = true;
request.RawMessage = new Amazon.SimpleEmail.Model.RawMessage();
System.IO.MemoryStream requestRawMessage_rawMessage_Data = null;
if (cmdletContext.RawMessage_Data != null)
{
_RawMessage_DataStream = new System.IO.MemoryStream(cmdletContext.RawMessage_Data);
requestRawMessage_rawMessage_Data = _RawMessage_DataStream;
}
if (requestRawMessage_rawMessage_Data != null)
{
request.RawMessage.Data = requestRawMessage_rawMessage_Data;
requestRawMessageIsNull = false;
}
// determine if request.RawMessage should be set to null
if (requestRawMessageIsNull)
{
request.RawMessage = null;
}
if (cmdletContext.ReturnPathArn != null)
{
request.ReturnPathArn = cmdletContext.ReturnPathArn;
}
if (cmdletContext.Source != null)
{
request.Source = cmdletContext.Source;
}
if (cmdletContext.SourceArn != null)
{
request.SourceArn = cmdletContext.SourceArn;
}
if (cmdletContext.Tag != null)
{
request.Tags = cmdletContext.Tag;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
return(output);
}
finally
{
if (_RawMessage_DataStream != null)
{
_RawMessage_DataStream.Dispose();
}
}
}
/// <summary>
/// Sends an email message, with header and content specified by the client. The <code>SendRawEmail</code>
/// action is useful for sending multipart MIME emails. The raw text of the message must
/// comply with Internet email standards; otherwise, the message cannot be sent.
///
///
/// <para>
/// There are several important points to know about <code>SendRawEmail</code>:
/// </para>
/// <ul> <li>
/// <para>
/// You can only send email from verified email addresses and domains; otherwise, you
/// will get an "Email address not verified" error. If your account is still in the Amazon
/// SES sandbox, you must also verify every recipient email address except for the recipients
/// provided by the Amazon SES mailbox simulator. For more information, go to the <a href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html">Amazon
/// SES Developer Guide</a>.
/// </para>
/// </li> <li>
/// <para>
/// The total size of the message cannot exceed 10 MB. This includes any attachments that
/// are part of the message.
/// </para>
/// </li> <li>
/// <para>
/// Amazon SES has a limit on the total number of recipients per message. The combined
/// number of To:, CC: and BCC: email addresses cannot exceed 50. If you need to send
/// an email message to a larger audience, you can divide your recipient list into groups
/// of 50 or fewer, and then call Amazon SES repeatedly to send the message to each group.
/// </para>
/// </li> <li>
/// <para>
/// The To:, CC:, and BCC: headers in the raw message can contain a group list. Note that
/// each recipient in a group list counts towards the 50-recipient limit.
/// </para>
/// </li> <li>
/// <para>
/// Amazon SES overrides any Message-ID and Date headers you provide.
/// </para>
/// </li> <li>
/// <para>
/// For every message that you send, the total number of recipients (To:, CC: and BCC:)
/// is counted against your sending quota - the maximum number of emails you can send
/// in a 24-hour period. For information about your sending quota, go to the <a href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/manage-sending-limits.html">Amazon
/// SES Developer Guide</a>.
/// </para>
/// </li> <li>
/// <para>
/// If you are using sending authorization to send on behalf of another user, <code>SendRawEmail</code>
/// enables you to specify the cross-account identity for the email's "Source," "From,"
/// and "Return-Path" parameters in one of two ways: you can pass optional parameters
/// <code>SourceArn</code>, <code>FromArn</code>, and/or <code>ReturnPathArn</code> to
/// the API, or you can include the following X-headers in the header of your raw email:
/// </para>
/// <ul> <li>
/// <para>
/// <code>X-SES-SOURCE-ARN</code>
/// </para>
/// </li> <li>
/// <para>
/// <code>X-SES-FROM-ARN</code>
/// </para>
/// </li> <li>
/// <para>
/// <code>X-SES-RETURN-PATH-ARN</code>
/// </para>
/// </li> </ul> <important>
/// <para>
/// Do not include these X-headers in the DKIM signature, because they are removed by
/// Amazon SES before sending the email.
/// </para>
/// </important>
/// <para>
/// For the most common sending authorization use case, we recommend that you specify
/// the <code>SourceIdentityArn</code> and do not specify either the <code>FromIdentityArn</code>
/// or <code>ReturnPathIdentityArn</code>. (The same note applies to the corresponding
/// X-headers.) If you only specify the <code>SourceIdentityArn</code>, Amazon SES will
/// simply set the "From" address and the "Return Path" address to the identity specified
/// in <code>SourceIdentityArn</code>. For more information about sending authorization,
/// see the <a href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html">Amazon
/// SES Developer Guide</a>.
/// </para>
/// </li> </ul>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the SendRawEmail service method.</param>
///
/// <returns>The response from the SendRawEmail service method, as returned by SimpleEmailService.</returns>
/// <exception cref="Amazon.SimpleEmail.Model.ConfigurationSetDoesNotExistException">
/// Indicates that the configuration set does not exist.
/// </exception>
/// <exception cref="Amazon.SimpleEmail.Model.MailFromDomainNotVerifiedException">
/// Indicates that the message could not be sent because Amazon SES could not read the
/// MX record required to use the specified MAIL FROM domain. For information about editing
/// the custom MAIL FROM domain settings for an identity, see the <a href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/mail-from-edit.html">Amazon
/// SES Developer Guide</a>.
/// </exception>
/// <exception cref="Amazon.SimpleEmail.Model.MessageRejectedException">
/// Indicates that the action failed, and the message could not be sent. Check the error
/// stack for more information about what caused the error.
/// </exception>
public SendRawEmailResponse SendRawEmail(SendRawEmailRequest request)
{
var marshaller = new SendRawEmailRequestMarshaller();
var unmarshaller = SendRawEmailResponseUnmarshaller.Instance;
return Invoke<SendRawEmailRequest,SendRawEmailResponse>(request, marshaller, unmarshaller);
}
private Amazon.SimpleEmail.Model.SendRawEmailResponse CallAWSServiceOperation(IAmazonSimpleEmailService client, Amazon.SimpleEmail.Model.SendRawEmailRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Email Service (SES)", "SendRawEmail");
try
{
#if DESKTOP
return(client.SendRawEmail(request));
#elif CORECLR
return(client.SendRawEmailAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
/// <summary>
/// <para>Sends an email message, with header and content specified by the client. The <c>SendRawEmail</c> action is useful for sending
/// multipart MIME emails. The raw text of the message must comply with Internet email standards; otherwise, the message cannot be sent. </para>
/// <para><b>IMPORTANT:</b> You can only send email from verified email addresses and domains. If you have not requested production access to
/// Amazon SES, you must also verify every recipient email address except for the recipients provided by the Amazon SES mailbox simulator. For
/// more information, go to the Amazon SES Developer Guide. </para> <para>The total size of the message cannot exceed 10 MB. This includes any
/// attachments that are part of the message.</para> <para>Amazon SES has a limit on the total number of recipients per message: The combined
/// number of To:, CC: and BCC: email addresses cannot exceed 50. If you need to send an email message to a larger audience, you can divide your
/// recipient list into groups of 50 or fewer, and then call Amazon SES repeatedly to send the message to each group. </para> <para>For every
/// message that you send, the total number of recipients (To:, CC: and BCC:) is counted against your <i>sending quota</i> - the maximum number
/// of emails you can send in a 24-hour period. For information about your sending quota, go to the <a href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/manage-sending-limits.html">Amazon SES Developer Guide</a> .
/// </para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendRawEmail service method on
/// AmazonSimpleEmailService.</param>
///
/// <returns>The response from the SendRawEmail service method, as returned by AmazonSimpleEmailService.</returns>
///
/// <exception cref="T:Amazon.SimpleEmail.Model.MessageRejectedException" />
public SendRawEmailResponse SendRawEmail(SendRawEmailRequest request)
{
var task = SendRawEmailAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
/// <summary>
/// Method to send email through cloud service. Please make sure that the attachements are of supported types.
/// If MailMessage has LinkedResources associated with alternate views, they will be removed. Amazon SES currently
/// requires content disposition for linked resources, which .Net does not support.
/// </summary>
/// <param name="mailMessage">.Net MailMessage</param>
public void SendBulkEmail(MailMessage mailMessage)
{
//Create a temp unique folder under WorkingTempFolder
string currentWorkingFolder = Path.Combine(this.cloudServiceConfigProvider.WorkingTempFolder, System.Guid.NewGuid().ToString("N"));
try
{
if (mailMessage == null)
throw new CloudServiceException("Mail message must be provided.");
if (mailMessage.To.Count == 0)
throw new CloudServiceException("To address is required.");
if (mailMessage.From == null || string.IsNullOrEmpty(mailMessage.From.Address))
throw new CloudServiceException("From address is required.");
if (!Directory.Exists(this.cloudServiceConfigProvider.WorkingTempFolder))
throw new CloudServiceConfigException("WorkingTempFolder specified does not exist.");
DirectoryInfo dInfo = Directory.CreateDirectory(currentWorkingFolder);
//Clear linked resources (Amazon has a glitch by requiring content-disposition for LinkedResource)
foreach (AlternateView av in mailMessage.AlternateViews)
{
av.LinkedResources.Clear();
}
//Setup content disposition for attachments
//Amazon needs content disposition
foreach (Attachment attachment in mailMessage.Attachments)
{
if (attachment.ContentDisposition != null)
{
attachment.ContentDisposition.Inline = false;
if (attachment.ContentStream != null)
attachment.ContentDisposition.Size = attachment.ContentStream.Length;
}
}
//Create smpt client
SmtpClient client = new SmtpClient();
client.DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory;
client.PickupDirectoryLocation = currentWorkingFolder;
client.Send(mailMessage);
//Create AWS Client
AmazonSimpleEmailService amazonSes = AWSClientFactory.CreateAmazonSimpleEmailServiceClient(this.cloudServiceConfigProvider.AWSAccessKeyId, this.cloudServiceConfigProvider.AWSSecretKey);
//At this point the email is created in the working folder. Ready one at a time and send to amazon
foreach (FileInfo fInfo in dInfo.GetFiles())
{
byte[] emailRawContent = File.ReadAllBytes(fInfo.FullName);
using (MemoryStream msEmail = new MemoryStream(emailRawContent, 0, emailRawContent.Length))
{
RawMessage rawMessage = new RawMessage(msEmail);
SendRawEmailRequest sendRawEmailRequest = new SendRawEmailRequest(rawMessage);
SendRawEmailResponse sendRawEmailRes = amazonSes.SendRawEmail(sendRawEmailRequest);
}
}
}
catch (CloudServiceException aex)
{
throw aex;
}
catch (Exception ex)
{
throw new CloudServiceException(ex, "Error occured when sending bulk email.");
}
finally
{
if(!this.cloudServiceConfigProvider.IsTraceMode == !string.IsNullOrEmpty(currentWorkingFolder))
{
if (Directory.Exists(currentWorkingFolder))
{
foreach (string file in Directory.GetFiles(currentWorkingFolder))
{
try
{
if (File.Exists(file))
File.Delete(file);
}
catch
{
///TODO: Add log once moved to common library
}
}
try
{
Directory.Delete(currentWorkingFolder);
}
catch
{
///TODO: Add log once moved to common library
}
}
}
}
}
/// <summary>
/// Initiates the asynchronous execution of the SendRawEmail operation.
/// <seealso cref="Amazon.SimpleEmail.IAmazonSimpleEmailService.SendRawEmail"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendRawEmail operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<SendRawEmailResponse> SendRawEmailAsync(SendRawEmailRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SendRawEmailRequestMarshaller();
var unmarshaller = SendRawEmailResponseUnmarshaller.GetInstance();
return Invoke<IRequest, SendRawEmailRequest, SendRawEmailResponse>(request, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// <see cref="Send" /> this message.
/// </summary>
/// <returns>
/// <see langword="true" /> if it succeeds, <see langword="false" /> if it fails.
/// </returns>
internal bool Send()
{
_email.MessageId = string.Empty;
try
{
var mailMessage = new MailMessage { From = new MailAddress(_email.FromAddress) };
foreach (string toAddress in _email.ToAddressList)
mailMessage.To.Add(new MailAddress(toAddress));
foreach (string ccAddress in _email.CcAddressList)
mailMessage.CC.Add(new MailAddress(ccAddress));
foreach (string bccAddress in _email.BccAddressList)
mailMessage.Bcc.Add(new MailAddress(bccAddress));
mailMessage.Subject = _email.MessageSubject;
mailMessage.SubjectEncoding = Encoding.UTF8;
mailMessage.AlternateViews.Add(
_email.HTML
? AlternateView.CreateAlternateViewFromString(_email.MessageBody, Encoding.UTF8, "text/html")
: AlternateView.CreateAlternateViewFromString(_email.MessageBody, Encoding.UTF8, "text/plain"));
var attachment = new Attachment(_email.AttachmentFilePath)
{
ContentType = new ContentType("application/octet-stream")
};
ContentDisposition disposition = attachment.ContentDisposition;
disposition.DispositionType = "attachment";
disposition.CreationDate = File.GetCreationTime(_email.AttachmentFilePath);
disposition.ModificationDate = File.GetLastWriteTime(_email.AttachmentFilePath);
disposition.ReadDate = File.GetLastAccessTime(_email.AttachmentFilePath);
mailMessage.Attachments.Add(attachment);
var rawMessage = new RawMessage();
using (MemoryStream memoryStream = ConvertMailMessageToMemoryStream(mailMessage))
rawMessage.WithData(memoryStream);
var request = new SendRawEmailRequest
{
RawMessage = rawMessage,
Destinations = _email.Destination.ToAddresses,
Source = _email.FromAddress
};
using (var client = new Client(_email.Credentials))
{
_email.MessageId = client.SendRawEmail(request);
}
return !_email.ErrorExists;
}
catch (AmazonSimpleEmailServiceException ex)
{
return _email.SetErrorMessage(
string.Format(
"AWS Simple Email Service Exception\n\nError Type: {0}\n" +
"Error Code: {1}\nRequest Id: {2}\nStatus Code: {3}\n\n{4}",
ex.ErrorType, ex.ErrorCode, ex.RequestId, ex.StatusCode, ex));
}
catch (AmazonClientException ex)
{
return _email.SetErrorMessage(ex.ToString());
}
catch (Exception ex)
{
return _email.SetErrorMessage(ex.ToString());
}
}