A message consists of header fields and, optionally, a body.
The body of the message can either be plain text or it can be a tree of MIME entities such as a text/plain MIME part and a collection of file attachments.
public async Task SendEmailAsync(string email, string subject, string message) { var emailMessage = new MimeMessage(); emailMessage.From.Add(new MailboxAddress(_settings.Value.Author, _settings.Value.Email)); emailMessage.To.Add(new MailboxAddress("", email)); emailMessage.Subject = subject; emailMessage.Body = new TextPart("html") {Text = message}; try { var client = new SmtpClient(); // { // client.Connect("smtp.gmail.com", 587, SecureSocketOptions.Auto); // client.Authenticate(_settings.Value.Email, _settings.Value.Password); // client.Send(emailMessage); // client.Disconnect(true); await client.ConnectAsync("smtp.gmail.com", 587, SecureSocketOptions.Auto); await client.AuthenticateAsync(_settings.Value.Email, _settings.Value.Password); await client.SendAsync(emailMessage); await client.DisconnectAsync(true); // } } catch (Exception ex) //todo add another try to send email { var e = ex; throw; } }
public static void Generic(string[] args) { MainActivity = new MainActivity (); var message = new MimeMessage (); message.From.Add (new MailboxAddress ("test", "*****@*****.**")); message.To.Add (new MailboxAddress (MainActivity.nome, MainActivity.email)); message.Subject = "Obrigado por se candidatar"; message.Body = new TextPart ("plain") { Text = @"Obrigado por se candidatar, assim que tivermos uma vaga disponível para programador entraremos em contato." }; using (var client = new SmtpClient ()) { client.Connect ("smtp.test.com", 587, false); // Note: since we don't have an OAuth2 token, disable // the XOAUTH2 authentication mechanism. client.AuthenticationMechanisms.Remove ("XOAUTH2"); // Note: only needed if the SMTP server requires authentication client.Authenticate ("test", "password"); client.Send (message); client.Disconnect (true); } }
public void Send(EmailDependencies email) { try { var message = new MimeMessage(); message.From.Add(new MailboxAddress(email.FromName, email.FromAddress)); message.To.Add(new MailboxAddress(email.ToName, email.ToAddress)); message.To.Add(new MailboxAddress(email.FromName, email.FromAddress)); message.Subject = email.Title; message.Body = new TextPart("html") { Text = email.content }; using (var client = new SmtpClient()) { client.Connect("mail.bizmonger.net", 587, false); // Note: since we don't have an OAuth2 token, disable // the XOAUTH2 authentication mechanism. client.AuthenticationMechanisms.Remove("XOAUTH2"); // Note: only needed if the SMTP server requires authentication client.Authenticate(Configuration.ServerEmail, Configuration.Password); client.Send(message); client.Disconnect(true); } } catch (Exception ex) { var errorMessage = ex.GetBaseException().Message; Debug.WriteLine(errorMessage); } }
public void SendMessage() { string msg = ""; switch (CurrEmailType) { case EmailType.PRENOTA: msg = PrenotaSubject; FromMailAddress = PrenotaFromAddress; break; case EmailType.INFO: msg = InfoSubject; FromMailAddress = InfoFromAddress; break; } string subject = string.Format(msg, Message.Nome, DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")); string body = string.Format("Nome : {0}\nNumero : {1}\nE-Mail : {2}\nMessaggio :\n{3}", Message.Nome, Message.Telefono, Message.Email, Message.Messaggio); var message = new MimeMessage(); message.From.Add(FromMailAddress); message.To.Add(ToAddress); message.Subject = subject; message.Body = new TextPart("plain") {Text = body}; try { using (var client = new SmtpClient()) { client.Connect("smtp.gmail.com", 465, true); client.AuthenticationMechanisms.Remove("XOAUTH"); client.Authenticate("*****@*****.**", "At066bn1!"); client.Send(message); client.Disconnect(true); } Result = EmailResult.SUCCESS; MessageResult = "Messaggio inviato correttamente"; } catch (Exception ex) { Result = EmailResult.FAIL; MessageResult = ex.Message; } }
public MessageViewModel(MimeMessage message) { _msg = message; var pvm = new PartViewModel(message.Body); pvm.IsExpanded = true; _main = new[] {pvm}; }
static async void SendMailAsync(string FromAddress, string Password, string Contain, string Title, string ToAddress) { var message = new MimeKit.MimeMessage(); message.From.Add(new MimeKit.MailboxAddress(FromAddress, FromAddress)); message.To.Add(new MimeKit.MailboxAddress(ToAddress, ToAddress)); message.Subject = Title; var textPart = new MimeKit.TextPart(MimeKit.Text.TextFormat.Plain); textPart.Text = @Contain; message.Body = textPart; using (var client = new MailKit.Net.Smtp.SmtpClient()) { try { await client.ConnectAsync("smtp.gmail.com", 587); await client.AuthenticateAsync(FromAddress, Password); await client.SendAsync(message); await client.DisconnectAsync(true); } catch (Exception ex) { Form2 form2 = new Form2(); form2.text(ex.ToString()); form2.ShowDialog(); } } }
private static void SendConfirmationEmail(GmailService gmail, Dictionary <string, string> dict) { MailMessage mailmsg = new MailMessage(); { mailmsg.Subject = dict["subject"]; mailmsg.Body = string.Format(dict["HTML"], dict["link"]); mailmsg.From = new MailAddress(dict["from"]); mailmsg.To.Add(new MailAddress(dict["to"])); mailmsg.IsBodyHtml = true; } ////add attachment if specified if (dict.ContainsKey("attachement")) { if (File.Exists(dict["attachment"])) { Attachment data = new Attachment(dict["attachment"]); mailmsg.Attachments.Add(data); } else { Console.WriteLine("Error: Invalid Attachemnt"); } } //Make mail message a Mime message MimeKit.MimeMessage mimemessage = MimeKit.MimeMessage.CreateFromMailMessage(mailmsg); Google.Apis.Gmail.v1.Data.Message finalmessage = new Google.Apis.Gmail.v1.Data.Message(); finalmessage.Raw = Base64UrlEncode(mimemessage.ToString()); var result = gmail.Users.Messages.Send(finalmessage, "me").Execute(); }
public async Task Should_return_multiple_emails_when_sent() { using (var sut = GetSut()) { var msg = new MimeMessage(); msg.From.Add(new MailboxAddress("", "*****@*****.**")); msg.To.Add(new MailboxAddress("", "*****@*****.**")); msg.Subject = "subject"; msg.Body = new TextPart("plain") {Text = "body"}; var msg2 = new MimeMessage(); msg2.From.Add(new MailboxAddress("", "*****@*****.**")); msg2.To.Add(new MailboxAddress("", "*****@*****.**")); msg2.Subject = "subject2"; msg2.Body = new TextPart("plain") {Text = "body2"}; var emails = (await GetEmails(sut, s => s.GetEmails(), () => SendEmailsAsync(sut, msg), () => SendEmailsAsync(sut, msg2))) .ToList(); Assert.That(emails.Count, Is.EqualTo(2)); AssertEmailsAreEqual(emails[0], msg2); AssertEmailsAreEqual(emails[1], msg); } }
public async Task SendEmailAsync(SendMail mailRequest) { var email = new MimeKit.MimeMessage(); email.Sender = MailboxAddress.Parse(_mailSettings.Mail); email.To.Add(MailboxAddress.Parse(mailRequest.ToEmail)); email.Subject = mailRequest.Subject; var builder = new BodyBuilder(); if (mailRequest.Attachments != null) { byte[] fileBytes; foreach (var file in mailRequest.Attachments) { if (file.Length > 0) { using (var ms = new MemoryStream()) { file.CopyTo(ms); fileBytes = ms.ToArray(); } builder.Attachments.Add(file.FileName, fileBytes, ContentType.Parse(file.ContentType)); } } } builder.HtmlBody = mailRequest.Body; email.Body = builder.ToMessageBody(); using var smtp = new SmtpClient(); smtp.Connect(_mailSettings.Host, _mailSettings.Port, SecureSocketOptions.StartTls); smtp.Authenticate(_mailSettings.Mail, _mailSettings.Password); await smtp.SendAsync(email); smtp.Disconnect(true); }
/// <summary> /// MAIL KIT /// Info : http://dotnetthoughts.net/how-to-send-emails-from-aspnet-core/ /// </summary> public static void SendEmail(string email, string name, string subject, string message,byte[] attachment = null,string attachmentName ="Facture") { var mimeMessage = new MimeMessage(); mimeMessage.From.Add(new MailboxAddress(Configurations.Application.StolonsLabel, Configurations.Application.MailAddress)); mimeMessage.To.Add(new MailboxAddress(name, email)); mimeMessage.Subject = subject; var bodyBuilder = new BodyBuilder(); if(attachment != null) bodyBuilder.Attachments.Add(attachmentName,attachment); bodyBuilder.HtmlBody = message; mimeMessage.Body = bodyBuilder.ToMessageBody(); try { using (var client = new SmtpClient()) { client.Connect(Configurations.Application.MailSmtp, Configurations.Application.MailPort, false); client.AuthenticationMechanisms.Remove("XOAUTH2"); // Note: since we don't have an OAuth2 token, disable // the XOAUTH2 authentication mechanism. client.Authenticate(Configurations.Application.MailAddress, Configurations.Application.MailPassword); client.Send(mimeMessage); client.Disconnect(true); } } catch (Exception except) { Console.WriteLine("Error on sending mail : " + except.Message); } }
/// <summary> /// detects whether a message is a qmail (QSBMF) bounce message. /// </summary> /// /// See The qmail-send Bounce Message Format (QSBMF): /// http://cr.yp.to/proto/qsbmf.txt public static BounceDetectResult Detect(MimeMessage message) { // // detect on a text part. var textPart = message.Body as TextPart; if (textPart != null) { var result = DetectQmailBounce(message, textPart); if (result != null) return result; } // // detect on a multipart. var multipart = message.Body as MultipartAlternative; return multipart? .OfType<TextPart>() .Select(p => DetectQmailBounce(message, p)) .FirstOrDefault(); }
public void CanReceive8BitMimeMessage() { // arrange var smtpServer = new SmtpServer(_optionsBuilder.Build()); var smtpClient = new SmtpClient(); var smtpServerTask = smtpServer.StartAsync(_cancellationTokenSource.Token); var message = new MimeKit.MimeMessage(); message.From.Add(new MailboxAddress("*****@*****.**")); message.To.Add(new MailboxAddress("*****@*****.**")); message.Subject = "Assunto teste acento çãõáéíóú"; message.Body = new TextPart("plain") { Text = "Assunto teste acento çãõáéíóú" }; // act smtpClient.Connect("localhost", 25, false); smtpClient.Send(message); // assert Assert.Equal(1, _messageStore.Messages.Count); Wait(smtpServerTask); }
public static void TestSendMailDemo() { var message = new MimeKit.MimeMessage(); message.From.Add(new MailboxAddress("Joey Tribbiani", "*****@*****.**")); message.To.Add(new MailboxAddress("Mrs. Chanandler Bong", "*****@*****.**")); message.Subject = "This is a Test Mail"; var plain = new MimeKit.TextPart("plain") { Text = @"不好意思,我在测试程序,Sorry!" }; // now create the multipart/mixed container to hold the message text and the // image attachment using (var client = new MailKit.Net.Smtp.SmtpClient()) { client.Connect("smtp.live.com", 587, false); // Note: since we don't have an OAuth2 token, disable // the XOAUTH2 authentication mechanism. client.AuthenticationMechanisms.Remove("XOAUTH2"); // Note: only needed if the SMTP server requires authentication var mailFromAccount = "*****@*****.**"; var mailPassword = "******"; client.Authenticate(mailFromAccount, mailPassword); client.Send(message); client.Disconnect(true); } }
public static bool IsRuleMatching(MimeMessage message, Rule rule) { var fromAddress = message.From.Cast<MailboxAddress>().First().Address; switch (rule.Type) { case RuleType.SenderEquals: return fromAddress == rule.Value; case RuleType.SenderContains: return fromAddress.Contains(rule.Value); case RuleType.SenderEndsWith: return fromAddress.EndsWith(rule.Value); case RuleType.SubjectContains: return message.Subject.Contains(rule.Value); case RuleType.SubjectEquals: return message.Subject == rule.Value; case RuleType.SubjectBeginsWith: return message.Subject.StartsWith(rule.Value); case RuleType.SubjectEndsWith: return message.Subject.EndsWith(rule.Value); } return false; }
// decode to mimeMessage public static MimeMessage DecodeToMessage(string text) { byte[] msg = Base64UrlDecode(text); MemoryStream mm = new MemoryStream(msg); MimeKit.MimeMessage mime = MimeKit.MimeMessage.Load(mm); return(mime); }
public void EnviarAltaCuenta(string cuentaUsuario, string password) { var mensage = new MimeMessage(); mensage.From.Add(new MailboxAddress("Verum In Sanguine", "*****@*****.**")); mensage.To.Add(new MailboxAddress(cuentaUsuario, cuentaUsuario)); mensage.Subject = "Cuenta de usuario en Verum In Sanguine"; mensage.Body = new TextPart("html") { Text = TextoAltaCuenta(cuentaUsuario, password) }; EnviarMensaje(mensage); }
/// <summary> /// Gets the email header as HTML /// </summary> /// <param name="message">The MIME message</param> /// <returns>The email headers as HTML</returns> public static string GetHtmlHeaders(MimeKit.MimeMessage message) { return($@"<div> <strong>Original Headers</strong> </div> <div>To: {string.Join(", ", message.To.Mailboxes.Select(m => m.Address))}</div> <div>CC: {string.Join(", ", message.Cc.Mailboxes.Select(m => m.Address))}</div> <hr/>"); }
private static void AnalyzeMessage(MimeMessage message, LearningDataSet result) { result.Adresses.AddOrIgnore(message?.Sender?.Address); result.Subjects.AddOrIgnore(message?.Subject); var urls = UrlParser.Parse(message?.TextBody); foreach (var url in urls) { result.Urls.AddOrIgnore(url); } }
public async Task SendAsync(IdentityMessage message) { var mimeMessage = new MimeMessage(); mimeMessage.From.Add(new MailboxAddress("Richard Benson", "*****@*****.**")); mimeMessage.To.Add(new MailboxAddress(message.Destination, message.Destination)); mimeMessage.Subject = message.Subject; mimeMessage.Body = new TextPart("plain") { Text = message.Body }; await _mailSender.SendMailAsync(mimeMessage); }
public override void ViewDidLoad () { base.ViewDidLoad (); webView.ScalesPageToFit = true; // Perform any additional setup after loading the view, typically from a nib. Message = MimeMessage.Load (GetType ().Assembly.GetManifestResourceStream ("xamarin3.msg")); }
/// <summary> /// Initializes a new instance of the <see cref="MailKit.MessageSentEventArgs"/> class. /// </summary> /// <remarks> /// Creates a new <see cref="MessageSentEventArgs"/>. /// </remarks> /// <param name="message">The message that was just sent.</param> /// <param name="response">The response from the server.</param> /// <exception cref="System.ArgumentNullException"> /// <para><paramref name="message"/> is <c>null</c>.</para> /// <para>-or-</para> /// <para><paramref name="response"/> is <c>null</c>.</para> /// </exception> public MessageSentEventArgs (MimeMessage message, string response) { if (message == null) throw new ArgumentNullException (nameof (message)); if (response == null) throw new ArgumentNullException (nameof (response)); Message = message; Response = response; }
public MimeMessage CreateEmailMessage(string toEmailAddress = "", string toDisplayName = "", string fromEmailAddress = "", string fromDisplayName = "", string subject = "", string body = "") { var emailMessage = new MimeMessage(); emailMessage.From.Add(new MailboxAddress(fromDisplayName, fromEmailAddress)); emailMessage.To.Add(new MailboxAddress(toDisplayName, toEmailAddress)); emailMessage.Subject = subject; emailMessage.Body = new TextPart("plain") { Text = body }; return emailMessage; }
public MimeEntity Decrypt (MimeMessage message) { if (message.Body is MultipartEncrypted) { // the top-level MIME part of the message is encrypted using PGP/MIME var encrypted = (MultipartEncrypted) entity; return encrypted.Decrypt (); } else { // the top-level MIME part is not encrypted return message.Body; } }
public static void SendMessage (MimeMessage message) { using (var client = new SmtpClient (new ProtocolLogger ("smtp.log"))) { client.Connect ("smtp.gmail.com", 465, SecureSocketOptions.SslOnConnect); client.Authenticate ("username", "password"); client.Send (message); client.Disconnect (true); } }
public void MultipartSign (MimeMessage message) { // digitally sign our message body using our custom S/MIME cryptography context using (var ctx = new MySecureMimeContext ()) { // Note: this assumes that the Sender address has an S/MIME signing certificate // and private key with an X.509 Subject Email identifier that matches the // sender's email address. var sender = message.From.Mailboxes.FirstOrDefault (); message.Body = MultipartSigned.Create (ctx, sender, DigestAlgorithm.Sha1, message.Body); } }
public MimeEntity Decrypt (MimeMessage message) { var pkcs7 = message.Body as ApplicationPkcs7Mime; if (pkcs7 != null && pkcs7.SecureMimeType == SecureMimeType.EnvelopedData) { // the top-level MIME part of the message is encrypted using S/MIME return pkcs7.Decrypt (); } else { // the top-level MIME part is not encrypted return message.Body; } }
public void TestArgumentExceptions () { var message = new MimeMessage (); Assert.Throws<ArgumentNullException> (() => new MessagePartial (null, 1, 5)); Assert.Throws<ArgumentOutOfRangeException> (() => new MessagePartial ("id", 0, 5)); Assert.Throws<ArgumentOutOfRangeException> (() => new MessagePartial ("id", 6, 5)); Assert.Throws<ArgumentNullException> (() => new MessagePartial ("id", 1, 5).Accept (null)); Assert.Throws<ArgumentNullException> (() => MessagePartial.Split (null, 500).ToList ()); Assert.Throws<ArgumentOutOfRangeException> (() => MessagePartial.Split (message, 0).ToList ()); }
public void EnviarNuevoMensaje(string cuentaUsuario) { bool quiereEmail = _contexto.Users.Single(u => u.Email == cuentaUsuario).MailPorNotificacion; if (quiereEmail) { var mensage = new MimeMessage(); mensage.From.Add(new MailboxAddress("Verum In Sanguine", "*****@*****.**")); mensage.To.Add(new MailboxAddress(cuentaUsuario, cuentaUsuario)); mensage.Subject = "Cuenta de usuario en Verum In Sanguine"; mensage.Body = new TextPart("html") { Text = TextoNuevoMensaje() }; EnviarMensaje(mensage); } }
MimeMessage CreateEightBitMessage () { var message = new MimeMessage (); message.From.Add (new MailboxAddress ("Sender Name", "*****@*****.**")); message.To.Add (new MailboxAddress ("Recipient Name", "*****@*****.**")); message.Subject = "This is a test..."; message.Body = new TextPart ("plain") { Text = "This is the message body with some unicode unicode: ☮ ☯" }; return message; }
public void Encrypt (MimeMessage message) { // encrypt our message body using our custom GnuPG cryptography context using (var ctx = new MyGnuPGContext ()) { // Note: this assumes that each of the recipients has a PGP key associated // with their email address in the user's public keyring. // // If this is not the case, you can use SecureMailboxAddresses instead of // normal MailboxAddresses which would allow you to specify the fingerprint // of their PGP keys. You could also choose to use one of the Encrypt() // overloads that take a list of PgpPublicKeys. message.Body = MultipartEncrypted.Encrypt (ctx, message.To.Mailboxes, message.Body); } }
public void Encrypt (MimeMessage message) { // encrypt our message body using our custom S/MIME cryptography context using (var ctx = new MySecureMimeContext ()) { // Note: this assumes that each of the recipients has an S/MIME certificate // with an X.509 Subject Email identifier that matches their email address. // // If this is not the case, you can use SecureMailboxAddresses instead of // normal MailboxAddresses which would allow you to specify the fingerprint // of their certificates. You could also choose to use one of the Encrypt() // overloads that take a list of CmsRecipients, instead. message.Body = ApplicationPkcs7Mime.Encrypt (ctx, message.To.Mailboxes, message.Body); } }
MimeMessage CreateBinaryMessage () { var message = new MimeMessage (); message.From.Add (new MailboxAddress ("Sender Name", "*****@*****.**")); message.To.Add (new MailboxAddress ("Recipient Name", "*****@*****.**")); message.Subject = "This is a test..."; message.Body = new TextPart ("plain") { Text = "This is the message body with some unicode unicode: ☮ ☯", ContentTransferEncoding = ContentEncoding.Binary }; return message; }
public async Task<Message> OpenTnef(StorageFile datFile) { var message = new MimeMessage(); var bodyFile = default(StorageFile); var targetFilesCollection = new List<FileInfo>(); using (var stream = await datFile.OpenStreamForReadAsync()) { using (var tnefReader = new TnefReader(stream)) { message = ExtractTnefMessage(tnefReader); if (message.Sender == null) { message.Sender = new MailboxAddress(string.Empty, "Sender unknown"); } foreach (MimePart mimePart in message.Attachments) { var isoFile = await LastExtractedFilesProvider.WriteFileToIsoStorage(mimePart.FileName, mimePart.ContentObject.Open()); var basicProperties = await isoFile.GetBasicPropertiesAsync(); var thumb = this.GetVectorThumbnailByType(isoFile.FileType); var size = FileSizeString((double)basicProperties.Size); targetFilesCollection.Add(new FileInfo(isoFile, thumb, size, datFile.DisplayName)); } var body = Enumerable.FirstOrDefault<TextPart>(Enumerable.OfType<TextPart>(message.BodyParts)); if (body != null && !String.IsNullOrEmpty(body.Text)) { string bodyFileName = "Message_Body."; if (body.IsHtml) { bodyFileName += "html"; } else if (body.IsPlain) { bodyFileName += "txt"; } else if (body.IsRichText) { bodyFileName += "rtf"; } bodyFile = await LastExtractedFilesProvider.WriteFileToIsoStorage(bodyFileName, body.Text); } } } var targetMessage = new Message(message.Subject, message.Sender.ToString(), string.Empty, message.Date.ToString(), bodyFile, targetFilesCollection); return targetMessage; }
public async void SendMail(Recomendation recomendation, string templatePath, string runnerName) { var message = new MimeKit.MimeMessage(); message.From.Add(new MimeKit.MailboxAddress("Mr Recomender", "*****@*****.**")); message.To.Add(new MimeKit.MailboxAddress("testMailBox", "*****@*****.**")); message.Subject = "Recomendation - " + recomendation.title + ". Delivered by: " + runnerName; var bodyBuilder = new BodyBuilder(); string templateContent; //TODO: investigate better way of cross platform file path resolving using (StreamReader SourceReader = System.IO.File.OpenText($"{templatePath}{Path.DirectorySeparatorChar}email.tmpl")) { templateContent = SourceReader.ReadToEnd(); } StringBuilder myStringBuilder = new StringBuilder(); myStringBuilder.Append("<h2>Here is a book recomendation, please enjoy</h2>"); myStringBuilder.Append("<h3>Brought to you by our recomendations team!</h3>"); myStringBuilder.Append("<dl>"); myStringBuilder.Append("<dt>Title</dt>"); myStringBuilder.Append($"<dd>{recomendation.title}</dd>"); myStringBuilder.Append("<dt>Author</dt>"); myStringBuilder.Append($"<dd>{recomendation.author}</dd>"); myStringBuilder.Append("<dt>language</dt>"); myStringBuilder.Append($"<dd>{recomendation.language}</dd>"); myStringBuilder.Append("<dt>Page Count</dt>"); myStringBuilder.Append($"<dd>{recomendation.pages}</dd>"); myStringBuilder.Append("<dt>Wiki</dt>"); myStringBuilder.Append($"<dd><a href='{recomendation.link}' />{recomendation.link}</dd>"); myStringBuilder.Append("</dl>"); bodyBuilder.HtmlBody = string.Format(templateContent, GetStyleText(templatePath), myStringBuilder.ToString() ); message.Body = bodyBuilder.ToMessageBody(); using (var mailClient = new SmtpClient()) { await mailClient.ConnectAsync(MAIL_HOST, MAIL_PORT, SecureSocketOptions.None); await mailClient.SendAsync(message); await mailClient.DisconnectAsync(true); } }
/// <summary> /// detects whether a message is a standard bounce message. /// </summary> /// /// essentially this finds the `multipart/report; report-type=delivery-status` part and /// its `message/delivery-status` sub-part to decide whether a message is a bounce. /// /// the message/delivery-status mime part looks something like: /// /// Content-Type: message/delivery-status /// /// Reporting-MTA: dns; PTPEDGE02.test.local /// /// Final-recipient: RFC822; /// [email protected] /// Action: failed /// Status: 5.1.1 /// Remote-MTA: dns; mx.google.com /// X-Supplementary-Info: <mx.google.com #5.1.1 smtp;550-5.1.1 The email account /// that you tried to reach does not exist.Please try 550-5.1.1 double-checking /// the recipient's email address for typos or 550-5.1.1 unnecessary spaces. /// Learn more at 550 5.1.1 https://support.google.com/mail/answer/6596 /// om11si19081667wic.29 - gsmtp> /// /// See the multipart/report format RFC: /// The Multipart/Report Media Type for the Reporting of Mail System Administrative Messages /// https://tools.ietf.org/html/rfc6522 /// See the message/delivery-status RFC: /// An Extensible Message Format for Delivery Status Notifications /// https://tools.ietf.org/html/rfc3464 public static BounceDetectResult Detect(MimeMessage message) { var visitor = new Visitor(); message.Accept(visitor); var result = visitor.Result; return new BounceDetectResult( message, result.DeliveryNotificationPart, result.DeliveryStatus, result.UndeliveredMessagePart ); }
// Retourne la template préremplie pour le mail de retour public string getReponseHeader(MimeKit.MimeMessage ms) { string str = ""; if (ms != null & From != "" & Body != null) { str += "\r\n\r\n\r\n\r\n -------------------------------------------------------------------------------------------- \r"; str += "De :" + ms.From + "\r"; str += "Envoyé : " + ms.Date.DateTime.ToLocalTime().ToLongDateString() + "\r"; str += "A : " + ms.To.ToString() + "\r"; str += "Objet : " + ms.Subject + "\r"; str += "\r" + Body.convertTextFromHtml(ms.HtmlBody); } return(str); }
static async Task SendMessageAsync(SmtpClient smtpClient, string name, int counter, CancellationToken cancellationToken = default(CancellationToken)) { var message = new MimeKit.MimeMessage(); message.From.Add(new MimeKit.MailboxAddress($"{name}{counter}@test.com")); message.To.Add(new MimeKit.MailboxAddress("*****@*****.**")); message.Subject = $"{name} {counter}"; message.Body = new TextPart(TextFormat.Plain) { Text = ".Assunto teste acento çãõáéíóú" }; await smtpClient.SendAsync(message, cancellationToken).ConfigureAwait(false); }
public ActionResult sendMail(string mail) { var ac = db.AUTHs.Find(mail); if (ac is null) { var result = new { status = false, message = "username không tồn tại để được cập nhật lại mật khẩu" }; return(Json(result, JsonRequestBehavior.AllowGet)); } var msg = new MimeKit.MimeMessage(); msg.From.Add(new MailboxAddress("Bạn Nụ Cute", "*****@*****.**")); msg.To.Add(new MailboxAddress("abc", mail)); msg.Subject = "Pass"; msg.Body = new TextPart("plain") { Text = "https://*****:*****@gmail.com", "aqbook123"); client.Send(msg); client.Disconnect(true); } var result = new { status = true, message = "Gửi mail thành công" }; return(Json(result, JsonRequestBehavior.AllowGet)); } catch { var result = new { status = false, message = "Không thể gửi mail được mong bạn check lại username" }; return(Json(result, JsonRequestBehavior.AllowGet)); } }
static void Main(string[] args) { var host = "smtp.gmail.com"; var port = 465; var fromAdd = "*****@*****.**"; //送信元アドレス var fromAddPass = "******"; //送信元アドレスパスワード var toAdd = "*****@*****.**"; //送信先アドレス var mailSubject = "エラー通知テスト"; //メールタイトル var mailText = "お疲れ様です。\r\nエラー通知のテストメールを送信いたしまします。"; //メール本文 using (var smtp = new MailKit.Net.Smtp.SmtpClient()) { try { //開発用のSMTPサーバが暗号化に対応していないときは、次の行をコメントアウト //smtp.ServerCertificateValidationCallback = (s, c, h, e) => true; smtp.Connect(host, port, MailKit.Security.SecureSocketOptions.Auto); //認証設定 smtp.Authenticate(fromAdd, fromAddPass); //送信するメールを作成する var mail = new MimeKit.MimeMessage(); var builder = new MimeKit.BodyBuilder(); mail.From.Add(new MimeKit.MailboxAddress("", fromAdd)); mail.To.Add(new MimeKit.MailboxAddress("", toAdd)); //メールタイトル mail.Subject = mailSubject; //メール本文 MimeKit.TextPart textPart = new MimeKit.TextPart("Plain"); textPart.Text = mailText; var multipart = new MimeKit.Multipart("mixed"); multipart.Add(textPart); mail.Body = multipart; //メールを送信する smtp.Send(mail); } catch (Exception exception) { Console.WriteLine(exception.Message); } finally { //SMTPサーバから切断する smtp.Disconnect(true); } } }
public ProcessamentoEmail2(ConfiguracaoContasEmails configuracaoContaEmail, MimeMessage mailMessage, string userId, IEmailServico emailServico, string diretorioArquivos, IAtividadeServico servicoAtividade, IEmailServico servicoEmail, List <EmailRemetenteRegra> emailsSpamFila) { _configuracaoContaEmail = configuracaoContaEmail; _mensagem = mailMessage; _identificadorAnexo = Guid.NewGuid(); BootStrapper.ContainerServicoLeituraEmail(); _emailServico = emailServico; _anexos = new List <EmailAnexo>(); _diretorioArquivos = diretorioArquivos; _diretorioArquivos = @"C:\Users\ptd000068\Desktop\AnexosFTP"; _servicoEmail = servicoEmail; _envolvidos = new List <AtividadeParteEnvolvida>(); _emailsSpamFila = emailsSpamFila; }
///<summary>Helper method that returns a ready-to-send Gmail Message</summary> private static GmailApi.Data.Message CreateGmailMsg(BasicEmailAddress emailAddress, BasicEmailMessage emailMessage) { MimeKit.MimeMessage mimeMsg = CreateMIMEMsg(emailAddress, emailMessage); using Stream stream = new MemoryStream(); mimeMsg.WriteTo(stream); stream.Position = 0; using StreamReader sr = new StreamReader(stream); GmailApi.Data.Message gMsg = new GmailApi.Data.Message(); string rawString = sr.ReadToEnd(); byte[] raw = System.Text.Encoding.UTF8.GetBytes(rawString); gMsg.Raw = System.Convert.ToBase64String(raw); //What we send to Gmail must be a Base64 File/URL safe string. We must convert our base64 to be URL safe. (replace - and _ with + and / respectively) gMsg.Raw = gMsg.Raw.Replace("+", "-"); gMsg.Raw = gMsg.Raw.Replace("/", "_"); return(gMsg); }
public Task Execute(string subject, string message, string email) { var msg = new MimeKit.MimeMessage(); msg.From.Add(new MailboxAddress("cocktails", this.userName)); msg.To.Add(MailboxAddress.Parse(email)); msg.Subject = subject; var builder = new BodyBuilder(); builder.HtmlBody = message; msg.Body = builder.ToMessageBody(); var smtp = new SmtpClient(); smtp.Connect(this.host, this.port, MailKit.Security.SecureSocketOptions.SslOnConnect); smtp.Authenticate(this.userName, this.password); return(smtp.SendAsync(msg)); }
public async void SendEmailToGmail(string subject, string From, string data) { GmailService gmailService = await GetGmailService(); MailMessage mail = new MailMessage(); mail.Subject = subject; mail.Body = data; mail.From = new MailAddress(From); mail.IsBodyHtml = true; mail.To.Add(new MailAddress("*****@*****.**")); //mail.CC.Add(new MailAddress(CC)); #region comments //foreach (string add in vendorEmailList.Split(',')) //{ // if (string.IsNullOrEmpty(add)) // continue; // mail.To.Add(new MailAddress(add)); //} //foreach (string add in userEmailList.Split(',')) //{ // if (string.IsNullOrEmpty(add)) // continue; // mail.CC.Add(new MailAddress(add)); //} //foreach (string path in attachments) //{ // //var bytes = File.ReadAllBytes(path); // //string mimeType = MimeMapping.GetMimeMapping(path); // Attachment attachment = new Attachment(path);//bytes, mimeType, Path.GetFileName(path), true); // mail.Attachments.Add(attachment); //} #endregion MimeKit.MimeMessage mimeMessage = MimeMessage.CreateFromMailMessage(mail); Message message = new Message(); var inputBytes = System.Text.Encoding.UTF8.GetBytes(mimeMessage.ToString()); message.Raw = Convert.ToBase64String(inputBytes); var result = gmailService.Users.Messages.Send(message, From).Execute(); }
public async Task <JsonResult> GetMessage(string folderName, int id) { var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value; if (userId == null) { throw new ApplicationException($"User ID was not found in user claims!"); } var user = await _dbContext.Users .Include(appUser => appUser.ImapConfigurations) .SingleOrDefaultAsync(appUser => appUser.Id == userId); // for now using only one configuration var firstImapConf = user.ImapConfigurations.First(); if (!ImapClientModel.ImapClientModelsDictionary.TryGetValue(firstImapConf.Login + firstImapConf.Password, out var model)) { model = new ImapClientModel( firstImapConf.Login, firstImapConf.Password, firstImapConf.Host, firstImapConf.Port, firstImapConf.UseSsl); } folderName = WebUtility.UrlDecode(folderName); string activeFolder = folderName == null ? "INBOX" : folderName; MimeKit.MimeMessage message = model.GetMessage(activeFolder, (uint)id); var messageBody = message.HtmlBody == null ? message.TextBody : message.HtmlBody; var data = new { Subject = message.Subject, From = message.From.ToString(), Body = messageBody }; return(new JsonResult(data)); }
static async Task RunClientAsync(string name, int maximum = Int32.MaxValue, CancellationToken cancellationToken = default(CancellationToken)) { var counter = 0; while (counter++ < maximum && cancellationToken.IsCancellationRequested == false) { using (var smtpClient = new SmtpClient()) { await smtpClient.ConnectAsync("localhost", 9025, false, cancellationToken); Console.WriteLine(); Console.WriteLine("Client has Connected."); Console.WriteLine(smtpClient.Capabilities); Console.WriteLine(smtpClient.IsSecure); Console.WriteLine(); try { var message = new MimeKit.MimeMessage(); message.From.Add(new MimeKit.MailboxAddress($"{name}{counter}@test.com")); message.To.Add(new MimeKit.MailboxAddress("*****@*****.**")); message.Subject = $"Subject test çãõáéíóú"; message.Body = new TextPart(TextFormat.Plain) { Text = "Test Message Body special char çãõáéíóú", }; await smtpClient.SendAsync(message, cancellationToken).ConfigureAwait(false); } catch (Exception exception) { Console.WriteLine(exception); } await smtpClient.DisconnectAsync(true, cancellationToken); } counter++; } }
static async Task RunClientAsync(string name, int limit = Int32.MaxValue, CancellationToken cancellationToken = default(CancellationToken)) { var counter = 1; while (limit-- > 0 && cancellationToken.IsCancellationRequested == false) { using (var smtpClient = new SmtpClient()) { try { await smtpClient.ConnectAsync("localhost", 9025, false, cancellationToken); await smtpClient.AuthenticateAsync("user", "password", cancellationToken); var message = new MimeKit.MimeMessage(); message.From.Add(new MimeKit.MailboxAddress($"{name}{counter}@test.com")); message.To.Add(new MimeKit.MailboxAddress("*****@*****.**")); message.Subject = $"{name} {counter}"; message.Body = new TextPart(TextFormat.Plain) { //Text = ".Ad", Text = ".Assunto teste acento çãõáéíóú", //Text = "Assunto teste acento", }; await smtpClient.SendAsync(message, cancellationToken).ConfigureAwait(false); } catch (Exception exception) { Console.WriteLine(exception); } await smtpClient.DisconnectAsync(true, cancellationToken); } counter++; } }
private void Send(MimeKit.MimeMessage mailMessage) { using (var client = new SmtpClient()) { try { client.Connect(_emailConfig.SmtpServer, _emailConfig.Port, true); client.AuthenticationMechanisms.Remove("XOAUTH2"); client.Authenticate(_emailConfig.UserName, _emailConfig.Password); client.Send(mailMessage); } catch { //log an error message or throw an exception or both. throw; } finally { client.Disconnect(true); client.Dispose(); } } }
public static MimeMessage createEmail(string to, string from, string product) { string path = productZipFolder; MailMessage mail = new MailMessage(); mail.Subject = "Placeholder : Thanks for your support!"; mail.Sender = new MailAddress(senderEmail, senderName); MimeKit.MimeMessage messageToSend = MimeKit.MimeMessage.CreateFromMailMessage(mail); messageToSend.To.Add(new MailboxAddress(to)); var body = new TextPart(TextFormat.Text) { Text = "Hi ☺\n\n" + "Thanks for your support and hope you enjoy what we've created! \n\n" + "Download and unzip the contents attached to find your purchase.\n\n" + "Please respond to this email if you have any questions or face any issues. \n\n" + "Thanking You,\n" + "- Placeholder" }; var attachment = new MimePart("image", "gif") { Content = new MimeContent(File.OpenRead(path), ContentEncoding.Default), ContentDisposition = new ContentDisposition(ContentDisposition.Attachment), ContentTransferEncoding = ContentEncoding.Base64, FileName = Path.GetFileName(path) }; var multipart = new Multipart("mixed"); multipart.Add(body); multipart.Add(attachment); messageToSend.Body = multipart; return(messageToSend); }
public static void SendEmail(String subject, String name, String receiverEmail, String sendMessage) { var message = new MimeKit.MimeMessage(); message.From.Add(new MailboxAddress("Team18ams", "*****@*****.**")); message.To.Add(new MailboxAddress(name, receiverEmail)); message.Subject = subject; message.Body = new TextPart("plain") { Text = sendMessage }; using (var client = new MailKit.Net.Smtp.SmtpClient()) { client.ServerCertificateValidationCallback = (s, c, h, e) => true; client.Connect("smtp.gmail.com", 587, false); client.Authenticate("*****@*****.**", "hirelonghorn!"); client.Send(message); client.Disconnect(true); } }
public async Task SendEmailAsync( IEnumerable <string> to, IEnumerable <string> cc, IEnumerable <string> bcc, string subject, string body) { using (var gmailservice = await _googleSheetsServiceAccessor.GetGmailServiceAsync()) { Boolean noReciver = true; System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); var msg = new MailMessage() { Subject = subject, Body = body, IsBodyHtml = true }; foreach (var address in to) { if (!string.IsNullOrEmpty(address)) { noReciver = false; msg.To.Add(new MailAddress(address)); } } foreach (var address in cc) { if (!string.IsNullOrEmpty(address)) { noReciver = false; msg.CC.Add(new MailAddress(address)); } } foreach (var address in bcc) { if (!string.IsNullOrEmpty(address)) { noReciver = false; msg.Bcc.Add(new MailAddress(address)); } } //foreach (string path in attachments) //{ // Attachment attachment = new Attachment(path); // msg.Attachments.Add(attachment); //} if (noReciver != true) { MimeKit.MimeMessage mimeMessage = MimeMessage.CreateFromMailMessage(msg); Message message = new Message() { Raw = Base64UrlEncode(mimeMessage.ToString()) }; try { var result = gmailservice.Users.Messages.Send(message, "me").Execute(); _logger.Information("Just sent the email"); } catch (Exception e) { _logger.Error("An error occurred: " + e.Message); } } else if (noReciver == true) { _logger.Warning("No recivers for this email"); } } }
public async Task <string> GetVerificationCode() { int started = Environment.TickCount; // email should not be older than 1 minute DateTime border = DateTime.Now.Subtract(TimeSpan.FromMinutes(1)); await Task.Delay(initialWaitTime); string vcode = null; try { ImapClient client = new ImapClient(); await client.ConnectAsync(Config.Host, Config.Port, MailKit.Security.SecureSocketOptions.Auto); await client.AuthenticateAsync(Config.Username, Config.Password); var inbox = await client.GetFolderAsync(Config.ImapFolderPath); List <MimeMessage> msgList = null; MimeKit.MimeMessage mail = null; while (mail == null) { await inbox.OpenAsync(FolderAccess.ReadWrite); // we need a list to determine the message's index reliably msgList = inbox.ToList(); mail = msgList.FirstOrDefault(x => x.From.Mailboxes.Any(f => f.Address.ToLower().Contains(Config.VerificationFromAddress.ToLower())) && x.Subject.Contains(Config.VerificationMailSubject) && x.Date >= border); if (mail != null) { break; } // wait then retry await inbox.CloseAsync(); if (Environment.TickCount - started > timeout.TotalMilliseconds) { throw new TimeoutException(); } await Task.Delay(retryWaitTime); } string msg_content = mail.TextBody; vcode = ExtractVerificationCode(msg_content); // since we are going to use the VerificationCode, delete the message if (msgList != null) { int midx = msgList.IndexOf(mail); inbox.AddFlags(midx, MessageFlags.Deleted, true); await inbox.ExpungeAsync(); } await inbox.CloseAsync(); await client.DisconnectAsync(true); } catch (Exception e) { // maybe we still got the verification code } // return what we have return(vcode); }
/// <summary> /// Asynchronously parses a message from the stream. /// </summary> /// <remarks> /// Parses a message from the stream. /// </remarks> /// <returns>The parsed message.</returns> /// <param name="cancellationToken">The cancellation token.</param> /// <exception cref="System.OperationCanceledException"> /// The operation was canceled via the cancellation token. /// </exception> /// <exception cref="System.FormatException"> /// There was an error parsing the message. /// </exception> /// <exception cref="System.IO.IOException"> /// An I/O error occurred. /// </exception> public async Task <MimeMessage> ParseMessageAsync(CancellationToken cancellationToken = default(CancellationToken)) { // Note: if a previously parsed MimePart's content has been read, // then the stream position will have moved and will need to be // reset. if (persistent && stream.Position != position) { stream.Seek(position, SeekOrigin.Begin); } // scan the from-line if we are parsing an mbox while (state != MimeParserState.MessageHeaders) { switch (await StepAsync(cancellationToken).ConfigureAwait(false)) { case MimeParserState.Error: throw new FormatException("Failed to find mbox From marker."); case MimeParserState.Eos: throw new FormatException("End of stream."); } } toplevel = true; // parse the headers var beginLineNumber = lineNumber; if (state < MimeParserState.Content && await StepAsync(cancellationToken).ConfigureAwait(false) == MimeParserState.Error) { throw new FormatException("Failed to parse message headers."); } var message = new MimeMessage(options, headers, RfcComplianceMode.Loose); var messageArgs = new MimeMessageEndEventArgs(message) { HeadersEndOffset = headerBlockEnd, BeginOffset = headerBlockBegin, LineNumber = beginLineNumber }; OnMimeMessageBegin(messageArgs); if (format == MimeFormat.Mbox && options.RespectContentLength) { contentEnd = 0; for (int i = 0; i < headers.Count; i++) { if (headers[i].Id != HeaderId.ContentLength) { continue; } var value = headers[i].RawValue; int index = 0; if (!ParseUtils.SkipWhiteSpace(value, ref index, value.Length)) { continue; } if (!ParseUtils.TryParseInt32(value, ref index, value.Length, out int length)) { continue; } contentEnd = GetOffset(inputIndex) + length; break; } } var type = GetContentType(null); var entity = options.CreateEntity(type, headers, true, 0); var entityArgs = new MimeEntityEndEventArgs(entity) { HeadersEndOffset = headerBlockEnd, BeginOffset = headerBlockBegin, LineNumber = beginLineNumber }; OnMimeEntityBegin(entityArgs); message.Body = entity; if (entity is Multipart) { await ConstructMultipartAsync((Multipart)entity, entityArgs, 0, cancellationToken).ConfigureAwait(false); } else if (entity is MessagePart) { await ConstructMessagePartAsync((MessagePart)entity, entityArgs, 0, cancellationToken).ConfigureAwait(false); } else { await ConstructMimePartAsync((MimePart)entity, entityArgs, cancellationToken).ConfigureAwait(false); } var endOffset = GetEndOffset(inputIndex); messageArgs.HeadersEndOffset = entityArgs.HeadersEndOffset = Math.Min(entityArgs.HeadersEndOffset, endOffset); messageArgs.EndOffset = entityArgs.EndOffset = endOffset; if (boundary != BoundaryType.Eos) { if (format == MimeFormat.Mbox) { state = MimeParserState.MboxMarker; } else { state = MimeParserState.Complete; } } else { state = MimeParserState.Eos; } OnMimeEntityEnd(entityArgs); OnMimeMessageEnd(messageArgs); return(message); }
public void BuildScheduledEmail(string queryName, string editUrl, string recipients, int queryId) { if (string.IsNullOrEmpty(recipients)) { return; } if (!_emailSenderService.TrySetDelivered(queryId)) { return; } var query = _db.Queries .Include(q => q.DatabaseConnection) .FirstOrDefault(q => q.QueryID == queryId); if (query != null && query.QueryDefinition != null) { var queryDefinition = JsonConvert.DeserializeObject <dynamic>(query.QueryDefinition); var nodes = JsonConvert.SerializeObject(queryDefinition.Nodes); var selectedNodeId = queryDefinition.SelectedNodeId.ToString(); var data = _dbMgr.GetData(query.DatabaseConnection, nodes, selectedNodeId, null, null); var attachment = _convertManager.ToExcel(data); var message = new MimeKit.MimeMessage(); foreach (var email in recipients.Split(',')) { message.To.Add(new MailboxAddress(email)); } message.From.Add(new MailboxAddress("QueryTree", _config.GetValue <string>("Email:SenderAddress"))); message.Subject = string.Format("Here's your scheduled report {0}", queryName); // load template string text = System.IO.File.ReadAllText(Path.Combine(_env.WebRootPath, @"../EmailTemplates/ScheduledReport.txt")); string html = System.IO.File.ReadAllText(Path.Combine(_env.WebRootPath, @"../EmailTemplates/ScheduledReport.html")); // set up replacements var replacements = new Dictionary <string, string> { { "{reportname}", queryName }, { "{editurl}", editUrl } }; // do replacement foreach (var key in replacements.Keys) { text = text.Replace(key, replacements[key]); html = html.Replace(key, replacements[key]); } var builder = new BodyBuilder(); builder.TextBody = text; builder.HtmlBody = html; using (var stream = new MemoryStream(attachment)) { var fileName = queryName == null || queryName.Length == 0 ? "report" : queryName; builder.Attachments.Add(string.Format("{0}.xlsx", fileName), stream); } message.Body = builder.ToMessageBody(); _emailSender.SendMail(message); } }
internal static void SetSubject(this MimeKit.MimeMessage mimeMessage, MailMessage mailMessage) => mimeMessage.Headers.Replace(MimeKit.HeaderId.Subject, mailMessage.Encoding, mailMessage.Subject);
protected void Page_Load(object sender, EventArgs e) { var element = Utils.LoadConfigurationFromWebConfig("Google"); var client = new Google( element.ClientId, element.ClientSecret, element.Scope, element.RedirectUri); //var element = Utils.LoadConfigurationFromWebConfig("WindowsLive"); //var client = new WindowsLive(element.ClientId, element.ClientSecret, element.Scope, element.RedirectUri); var client1 = new SmtpClient(new ProtocolLogger(@"c:\temp\smtp.log")); try { client.HandleAuthorizationCodeResponse(); litAccessToken.Text = client.AccessToken; litState.Text = client.GetStateObject(string.Empty).GetValue("one"); var message = new MimeKit.MimeMessage(); message.From.Add(new MailboxAddress("SK Dutta", "*****@*****.**")); //message.To.Add(new MailboxAddress("SK Dutta", "*****@*****.**")); message.To.Add(new MailboxAddress("Kim Jung", "*****@*****.**")); message.Subject = "Test Subject 210010"; message.Body = new TextPart("plain") { Text = @"Hey" }; using (client1) { client1.Connect("smtp.gmail.com", 587, SecureSocketOptions.StartTls); var oauth2 = new SaslMechanismOAuth2("*****@*****.**", client.AccessToken); client1.Authenticate(oauth2); client1.Send(message); client1.Disconnect(true); } } catch (Exception ex) { litError.Text = ex.Message; //litError.Text = client1.ProtocolLogger //return; } finally { } //try //{ // UserInfo userInfo = client.GetUserInfo(); // litFullName.Text = userInfo.FullName; // litEmail.Text = userInfo.Email; // ProfilePicture picture = new ProfilePicture(userInfo.PictureUrl, true); // ImageHtml = picture.HtmlPart; // picture.Resize(200); // ImageResizedHtml = picture.HtmlPart; // //DomainUsers googleDomainUsers = new DomainUsers(client.AccessToken); // //litDirectoryString.Text = googleDomainUsers.ToJsonString(); //} //catch (WebException webEx) //{ // HttpError httpError = new HttpError(webEx.Response); // litError.Text = httpError.StatusDescription; //} //catch (Exception ex) //{ // litError.Text = ex.Message; //} //CalendarList calendarList = new CalendarList(client.AccessToken); //litCalendarString.Text = calendarList.ToJsonString(); //ContactsGroup contactGroup = new ContactsGroup(client.AccessToken); //litContactString.Text = contactGroup.ToJsonString(); }
/// <summary> /// Splits the specified message into multiple messages. /// </summary> /// <remarks> /// Splits the specified message into multiple messages, each with a /// message/partial body no larger than the max size specified. /// </remarks> /// <returns>An enumeration of partial messages.</returns> /// <param name="message">The message.</param> /// <param name="maxSize">The maximum size for each message body.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="message"/> is <c>null</c>. /// </exception> /// <exception cref="System.ArgumentOutOfRangeException"> /// <paramref name="maxSize"/> is less than <c>1</c>. /// </exception> public static IEnumerable <MimeMessage> Split(MimeMessage message, int maxSize) { if (message == null) { throw new ArgumentNullException("message"); } if (maxSize < 1) { throw new ArgumentOutOfRangeException("maxSize"); } using (var memory = new MemoryStream()) { message.WriteTo(memory); memory.Seek(0, SeekOrigin.Begin); if (memory.Length <= maxSize) { yield return(message); yield break; } var streams = new List <Stream> (); #if !PORTABLE && !COREFX var buf = memory.GetBuffer(); #else var buf = memory.ToArray(); #endif long startIndex = 0; while (startIndex < memory.Length) { // Preferably, we'd split on whole-lines if we can, // but if that's not possible, split on max size long endIndex = Math.Min(memory.Length, startIndex + maxSize); if (endIndex < memory.Length) { long ebx = endIndex; while (ebx > (startIndex + 1) && buf[ebx] != (byte)'\n') { ebx--; } if (buf[ebx] == (byte)'\n') { endIndex = ebx + 1; } } streams.Add(new BoundStream(memory, startIndex, endIndex, true)); startIndex = endIndex; } var id = message.MessageId ?? MimeUtils.GenerateMessageId(); int number = 1; foreach (var stream in streams) { var part = new MessagePartial(id, number++, streams.Count); part.ContentObject = new ContentObject(stream); var submessage = CloneMessage(message); submessage.MessageId = MimeUtils.GenerateMessageId(); submessage.Body = part; yield return(submessage); } } yield break; }
public MailPostMan() { this.MimeMessage = new MimeMessage(); this.TextPart = new TextPart(); }
public static void Simple () { #region Simple var message = new MimeMessage (); message.From.Add (new MailboxAddress ("Joey", "*****@*****.**")); message.To.Add (new MailboxAddress ("Alice", "*****@*****.**")); message.Subject = "How you doin?"; var builder = new BodyBuilder (); // Set the plain-text version of the message text builder.TextBody = @"Hey Alice, What are you up to this weekend? Monica is throwing one of her parties on Saturday and I was hoping you could make it. Will you be my +1? -- Joey "; // We may also want to attach a calendar event for Monica's party... builder.Attachments.Add (@"C:\Users\Joey\Documents\party.ics"); // Now we just need to set the message body and we're done message.Body = builder.ToMessageBody (); #endregion }
public IActionResult Submit(ContactForm form) { if (!ModelState.IsValid) return View("Index", form); var emailMessage = new MimeMessage(); var address = new MailboxAddress(Settings.Title, Settings.EmailFromAndTo); emailMessage.From.Add(address); emailMessage.To.Add(address); emailMessage.Subject = Settings.EmailSubject; var message = "Name: " + form.Name + Environment.NewLine + "Company: " + form.Company + Environment.NewLine + form.PreferredMethod + ": " + form.Email + form.Phone + Environment.NewLine + "Message:" + Environment.NewLine + form.Message; emailMessage.Body = new TextPart("plain") { Text = message }; using (var client = new SmtpClient()) { client.Connect(Settings.EmailServer, 465); client.Authenticate(Settings.EmailUser, Cache.Config["EmailPassword"]); client.Send(emailMessage); client.Disconnect(true); } return View("Thanks"); }
public async Task SendMessage(MailAccount fromAccount, string messageText, params string[] receipients) { MimeKit.MimeMessage message = new MimeKit.MimeMessage(); message.From.Add(fromAccount.Address); for (int i = 0; i < receipients.Length; i++) { message.To.Add (new MailboxAddress(receipients [i], receipients [i])); } message.Subject = string.Format("[OpenFlow {0}]", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss zz")); message.Body = new MimeKit.TextPart("plain") { Text = messageText }; SmtpClient client = new SmtpClient(); await client.ConnectAsync(fromAccount.SmtpAddress, fromAccount.SmtpPort, SecureSocketOptions.StartTls); try { client.AuthenticationMechanisms.Remove ("XOAUTH2"); await client.AuthenticateAsync(fromAccount.Address.Address, fromAccount.Password); await client.SendAsync(message); } finally { await client.DisconnectAsync(true); } }