private void SendMail()
{
string mailSubject = "終業打刻忘れ通知";
string mailBody = "終業打刻がされてないっぽいです";
var addrList = _smtpMailToRaw.Split(";");
var message = new MimeKit.MimeMessage();
message.From.Add(new MimeKit.MailboxAddress(_smtpAccount));
foreach (var addr in addrList)
{
message.To.Add(new MimeKit.MailboxAddress(addr.Trim()));
}
message.Subject = mailSubject;
var textpart = new MimeKit.TextPart(MimeKit.Text.TextFormat.Plain);
textpart.Text = mailBody;
message.Body = textpart;
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect(this._smtpServer, this._smtpPort);
client.Authenticate(_smtpAccount, this._smtpPass);
client.Send(message);
client.Disconnect(true);
}
}
/// <summary>
/// Prepares MailMessage object for Gmail API
/// </summary>
/// <param name="to">To field of a message</param>
/// <param name="from">From field of a message</param>
/// <param name="subject">Subject field of a message</param>
/// <param name="bodyHtml">HTML formatted body of a message</param>
/// <returns>Result message</returns>
private static Google.Apis.Gmail.v1.Data.Message CreateGmailMessage(string from, string to, string subject, string bodyHtml)
{
MailMessage mailMessage = new MailMessage();
mailMessage.From = new MailAddress(from);
string[] splittedTo = to.Split(new Char[] { ';', ',' });
foreach (string t in splittedTo)
{
mailMessage.To.Add(t.Trim());
}
mailMessage.ReplyToList.Add(from);
mailMessage.Subject = subject;
mailMessage.Body = bodyHtml;
mailMessage.IsBodyHtml = true;
MimeKit.MimeMessage mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mailMessage);
Google.Apis.Gmail.v1.Data.Message gmailMessage = new Google.Apis.Gmail.v1.Data.Message
{
Raw = Base64UrlEncoder.Encode(mimeMessage.ToString())
};
return(gmailMessage);
}
public static void SendMail(SmtpConfig smtpConfig, string strContactName, string strContactEmail, string strContactMessage)
{
MimeKit.MimeMessage message = new MimeKit.MimeMessage();
message.From.Add(new MimeKit.MailboxAddress(strContactEmail, strContactEmail));
message.To.Add(new MimeKit.MailboxAddress("Noob", "*****@*****.**"));
message.To.Add(new MimeKit.MailboxAddress("Noob2", "*****@*****.**"));
message.Subject = "Neue Nachricht von www.daniel-steiger.ch";
message.Body = new MimeKit.TextPart("plain")
{
Text = strContactMessage
};
string pw = CoinBaseSharp.StringHelper.ReverseGraphemeClusters(smtpConfig.Pass);
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient())
{
// client.Connect("smtp.gmail.com", 587);
////Note: only needed if the SMTP server requires authentication
// client.Authenticate("*****@*****.**", "mypassword");
client.Connect(smtpConfig.Server, smtpConfig.Port, false);
client.Authenticate(smtpConfig.User, pw);
client.Send(message);
client.Disconnect(true);
}
}
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();
}
} // End Sub TestPop3
public static void TestImap(string username, string password)
{
using (MailKit.MailStore client = new MailKit.Net.Imap.ImapClient())
{
// For demo-purposes, accept all SSL certificates
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
// Non-Encrypted: 143
// SSL/TLS: 993
client.Connect(RedmineMailService.Trash.UserData.IMAP, 993, true);
// Note: since we don't have an OAuth2 token, disable
// the XOAUTH2 authentication mechanism.
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.Authenticate(username, password);
// The Inbox folder is always available on all IMAP servers...
MailKit.IMailFolder inbox = client.Inbox;
inbox.Open(MailKit.FolderAccess.ReadOnly);
System.Console.WriteLine("Total messages: {0}", inbox.Count);
System.Console.WriteLine("Recent messages: {0}", inbox.Recent);
for (int i = 0; i < inbox.Count; i++)
{
MimeKit.MimeMessage message = inbox.GetMessage(i);
System.Console.WriteLine("Subject: {0}", message.Subject);
} // Next i
client.Disconnect(true);
} // End Using client
} // End Sub TestImap
public static void TestPop3(string username, string password)
{
using (MailKit.MailSpool client = new MailKit.Net.Pop3.Pop3Client())
{
// For demo-purposes, accept all SSL certificates (in case the server supports STARTTLS)
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
// Non-Encrypted: 110
// SSL/TLS: 995
//client.Connect(RedmineMailService.Trash.UserData.POP, 110, false);
client.Connect(RedmineMailService.Trash.UserData.POP, 995, true);
// Note: since we don't have an OAuth2 token, disable
// the XOAUTH2 authentication mechanism.
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.Authenticate(username, password);
for (int i = 0; i < client.Count; i++)
{
MimeKit.MimeMessage message = client.GetMessage(i);
System.Console.WriteLine("Subject: {0}", message.Subject);
} // Next i
client.Disconnect(true);
} // End Using client
} // End Sub TestPop3
public IEnumerable <MailMessagePreviewDTO> GetMailInbox()
{
List <MailMessagePreviewDTO> list = new List <MailMessagePreviewDTO>();
using (ImapClient client = new ImapClient())
{
// For demo-purposes, accept all SSL certificates
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect("imap.gmail.com", 993, true);
client.Authenticate("*****@*****.**", "V3@pu166@@!!");
// The Inbox folder is always available on all IMAP servers...
IMailFolder inbox = client.Inbox;
inbox.Open(FolderAccess.ReadOnly);
int index = Math.Max(inbox.Count - 10, 0);
IList <IMessageSummary> items = inbox.Fetch(index, -1, MessageSummaryItems.UniqueId);
foreach (IMessageSummary item in items)
{
MimeKit.MimeMessage message = inbox.GetMessage(item.UniqueId);
list.Add(new MailMessagePreviewDTO
{
Date = message.Date.DateTime.ToUniversalTime(),
Sender = message.From[0].Name,
Subject = message.Subject
});
}
}
return(list);
}
static Task <Message> ReadEmailAsync(ImapClient client, UniqueId uid, CancellationToken token)
{
return(Task.Run <Message>(() =>
{
Message message = new Message();
MimeKit.MimeMessage newEmail = client.Inbox.GetMessage(uid);
message.SentTime = (ulong)newEmail.Date.ToUnixTimeSeconds();
MimeKit.MailboxAddress fromAdress = newEmail.From.Mailboxes.FirstOrDefault();
message.EMail = fromAdress.Address;
string content = "KEIN INHALT";
if (newEmail.TextBody != null && newEmail.TextBody.Length > 5)
{
content = newEmail.TextBody;
}
message.Content = content;
message.Type = (ushort)MessageType.RecievedFromEmail;
token.ThrowIfCancellationRequested();
return message;
}));
}
static async Task RunClientAsync(string name, CancellationToken cancellationToken)
{
var counter = 1;
while (cancellationToken.IsCancellationRequested == false)
{
using (var smtpClient = new SmtpClient())
{
await smtpClient.ConnectAsync("localhost", 9025, false, cancellationToken);
//smtpClient.EnableSsl = true;
try
{
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 MimeKit.TextPart("plain")
{
Text = ""
};
await smtpClient.SendAsync(message, cancellationToken).ConfigureAwait(false);
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
await smtpClient.DisconnectAsync(true, cancellationToken);
}
counter++;
}
}
GetDeliveryStatusNotifications(MimeKit.MimeMessage message, MimeKit.MailboxAddress mailbox)
{
//if (/* some criteria for deciding whether to get DSN's... */)
return(MailKit.DeliveryStatusNotification.Delay |
MailKit.DeliveryStatusNotification.Failure |
MailKit.DeliveryStatusNotification.Success);
// return null;
}
/// <summary>
/// メール送信試験
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void SendTestButton_Click(object sender, EventArgs e)
{
try
{
var message = new MimeKit.MimeMessage();
message.From.Add(new MimeKit.MailboxAddress(SenderNameTextBox.Text, SenderAddressTextBox.Text));
string[] name = ReceiverNameTextBox.Text.Replace(",", ";").Split(';');
string[] addresses = ReceiverAddressTextBox.Text.Replace(",", ";").Split(';');
try
{
for (int i = 0; i < addresses.Length; i++)
{
message.To.Add(new MimeKit.MailboxAddress(name[i].Trim(), addresses[i].Trim()));
}
}
catch (Exception)
{
this.ShowErrorDialog("宛先・送信先エラー", "宛先又は送信先が不正です。");
return;
}
message.Subject = MailTitleTextBox.Text;
var textPart = new MimeKit.TextPart(MimeKit.Text.TextFormat.Plain);
textPart.Text = MailTextBox.Text;
message.Body = textPart;
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
try
{
await client.ConnectAsync(MailHostTextBox.Text, int.Parse(PortNoTextBox.Text));
if (!string.IsNullOrEmpty(UserNameTextBox.Text) && !string.IsNullOrEmpty(PasswordTextBox.Text))
{
await client.AuthenticateAsync(UserNameTextBox.Text, PasswordTextBox.Text);
}
await client.SendAsync(message);
await client.DisconnectAsync(true);
this.ShowDialog("送信成功", "メール送信に成功しました!!");
}
catch (Exception ex)
{
this.ShowErrorDialog("メール送信失敗", ex.Message);
Console.WriteLine(ex.Message);
}
}
}
catch (Exception ex)
{
throw Program.ThrowException(ex);
}
}
public MailClientMessageEventArgs(MimeKit.MimeMessage message, string messageUid, bool uread, MailFolder folder,
MailBox mailBox, ILogger logger)
{
Message = message;
Unread = uread;
Folder = folder;
Mailbox = mailBox;
MessageUid = messageUid;
Logger = logger;
}
/// <summary>
/// Explicit cast to convert a <see cref="MimeKit.MimeMessage"/> to a
/// <see cref="System.Net.Mail.MailMessage"/>.
/// </summary>
/// <remarks>
/// <para>Casting a <see cref="MimeKit.MimeMessage"/> to a <see cref="System.Net.Mail.MailMessage"/>
/// makes it possible to use MimeKit with <see cref="System.Net.Mail.SmtpClient"/>.</para>
/// <para>It should be noted, however, that <see cref="System.Net.Mail.MailMessage"/>
/// cannot represent all MIME structures that can be constructed using MimeKit,
/// so the conversion may not be perfect.</para>
/// <para>A better approach would be to use MailKit's SmtpClient instead.</para>
/// </remarks>
/// <returns>A <see cref="System.Net.Mail.MailMessage"/>.</returns>
/// <param name="message">The message.</param>
public static MailMessage ConvertToMailMessage(this MimeKit.MimeMessage message)
{
if (message == null)
{
return(null);
}
var from = message.From.Mailboxes.FirstOrDefault();
var msg = new MailMessage();
var sender = message.Sender;
foreach (var header in message.Headers)
{
msg.Headers.Add(header.Field, header.Value);
}
if (sender != null)
{
msg.Sender = ConvertToMailAddress(sender);
}
if (from != null)
{
msg.From = ConvertToMailAddress(from);
}
foreach (var mailbox in message.ReplyTo.Mailboxes)
{
msg.ReplyToList.Add(ConvertToMailAddress(mailbox));
}
foreach (var mailbox in message.To.Mailboxes)
{
msg.To.Add(ConvertToMailAddress(mailbox));
}
foreach (var mailbox in message.Cc.Mailboxes)
{
msg.CC.Add(ConvertToMailAddress(mailbox));
}
foreach (var mailbox in message.Bcc.Mailboxes)
{
msg.Bcc.Add(ConvertToMailAddress(mailbox));
}
msg.Subject = message.Subject;
if (message.Body != null)
{
AddBodyPart(msg, message.Body);
}
return(msg);
}
public static void Mail(string id, string pass, string from, string to, string subject, string body, string path)
{
//Console.WriteLine("Hello SMTP World!");
/*
* string id = "<gmailのログインID>";
* string pass = "******";
* string from = "<宛先>";
* string to = "<自分のメール>";
* string subject = "送信テスト : " + DateTime.Now.ToString();
* string body = "from t.masuda";
*/
#if false
var smtp = new System.Net.Mail.SmtpClient();
smtp.Host = "smtp.gmail.com"; //SMTPサーバ
smtp.Port = 587; //SMTPポート
smtp.EnableSsl = true;
smtp.Credentials = new System.Net.NetworkCredential(id, pass); //認証
var msg = new System.Net.Mail.MailMessage(from, to, subject, body);
smtp.Send(msg); //メール送信
#else
var smtp = new MailKit.Net.Smtp.SmtpClient();
smtp.Connect("smtp.gmail.com", 587, SecureSocketOptions.Auto);
smtp.Authenticate(id, pass);
var mail = new MimeKit.MimeMessage();
var builder = new MimeKit.BodyBuilder();
mail.From.Add(new MimeKit.MailboxAddress("", from));
mail.To.Add(new MimeKit.MailboxAddress("", to));
mail.Subject = subject;
builder.TextBody = body;
//mail.Body = builder.ToMessageBody();
//var path = @"C:\Windows\Web\Wallpaper\Theme2\img10.jpg"; // 添付したいファイル
var attachment = new MimeKit.MimePart("application", "vnd.openxmlformats-officedocument.spreadsheetml.sheet")
{
Content = new MimeKit.MimeContent(File.OpenRead(path)),
ContentDisposition = new MimeKit.ContentDisposition(),
ContentTransferEncoding = MimeKit.ContentEncoding.Base64,
FileName = System.IO.Path.GetFileName(path)
};
var multipart = new MimeKit.Multipart("mixed");
multipart.Add(builder.ToMessageBody());
multipart.Add(attachment);
mail.Body = multipart;
smtp.Send(mail);
smtp.Disconnect(true);
#endif
Console.WriteLine("メールを送信しました");
}
public static void SendHtmlMessage()
{
//Create Message
MailMessage mail = new MailMessage();
mail.Subject = "Result of APIs!";
var weather = File.ReadAllText(_weatherFile);
mail.Body = $"Sending {_weatherFile} and {_faceFile}";
mail.From = new MailAddress("<REQUIRED>");
mail.IsBodyHtml = true;
string attImg = "temp.jpg";
mail.Attachments.Add(new Attachment(attImg));
/*mail.Attachments.Add(new Attachment(_faceFile));
* mail.Attachments.Add(new Attachment(_weatherFile));*/
mail.To.Add(new MailAddress("<REQUIRED>"));
MimeKit.MimeMessage mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mail);
Message message = new Message();
message.Raw = Base64UrlEncode(mimeMessage.ToString());
//Gmail API credentials
UserCredential credential;
using (var stream =
new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/gmail-dotnet-quickstart2.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
Scopes,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
Console.WriteLine("Credential file saved to: " + credPath);
}
// Create Gmail API service.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
//Send Email
var result = service.Users.Messages.Send(message, "me").Execute();
}
} // End Sub TestImap
public static void TestSMTP(string username, string password)
{
// RedmineClient.CertificateCallback.Initialize();
MimeKit.MimeMessage message = new MimeKit.MimeMessage();
message.From.Add(new MimeKit.MailboxAddress("Joey Tribbiani", "*****@*****.**"));
message.To.Add(new MimeKit.MailboxAddress("Mrs. Chanandler Bong", RedmineMailService.Trash.UserData.Email));
message.Subject = "How you doin'?";
message.Body = new MimeKit.TextPart("plain")
{
Text = @"Hey Chandler,
I just wanted to let you know that Monica and I were going to go play some paintball, you in?
-- Joey"
};
//using (MailKit.MailTransport client = new MailKit.Net.Smtp.SmtpClient())
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient())
{
// For demo-purposes, accept all SSL certificates (in case the server supports STARTTLS)
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
// Non-Encrypted: 25
// StartTLS: 587
// SSL: 465
// The handshake failed due to an unexpected packet format
// I had this same problem, for me when using port 587 with SSL it failed,
// but when using port 465 with SSL it worked.
// Which is weird because that's the opposite behaviour of System.Net.Mail.SmtpClient
// (which works for 587 with SSL but fails with 465 with SSL).
// Port 587 is a clear-text port for SMTP which is why you got the error when using an SSL-wrapped connection.
// The way to get SSL support on port 587 is to use STARTTLS
// (which MailKit will do automatically for you once it connects unless you explicitly disable the feature).
// Ah right, yes using 587 with SSL=false does work. Thanks!
// A value of true should only ever be used for port 465 unless you know the port is ssl-wrapped
client.Connect(RedmineMailService.Trash.UserData.SMTP, 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(username, password);
client.Send(message);
client.Disconnect(true);
} // End Using client
} // End Sub TestSMTP
} // End Sub SaveAttachments
// https://github.com/jstedfast/MailKit/blob/master/Documentation/Examples/SmtpExamples.cs
public static void SendMessage(MimeKit.MimeMessage message)
{
// using (SmtpClient client = new SmtpClient (new ProtocolLogger ("smtp.log")))
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect("smtp.gmail.com", 465, MailKit.Security.SecureSocketOptions.SslOnConnect);
client.Authenticate("username", "password");
client.Send(message);
client.Disconnect(true);
} // End Using client
} // End Sub SendMessage
public static void GmailWithOauth(MimeKit.MimeMessage message)
{
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect("smtp.gmail.com", 587, MailKit.Security.SecureSocketOptions.StartTls);
// use the access token
var oauth2 = new MailKit.Security.SaslMechanismOAuth2("*****@*****.**", "credential.Token.AccessToken");
client.Authenticate(oauth2);
client.Send(message);
client.Disconnect(true);
}
}
/// <summary>
/// 使用MailKit发送邮件
/// </summary>
/// <param name="body">邮件内容</param>
/// <param name="subject">邮件主题</param>
/// <param name="to">收件人集合</param>
/// <param name="cc">抄送人集合</param>
public void SendEmailByMailKit(string body, string subject, string[] to, string[] cc = null)
{
var message = new MimeKit.MimeMessage();
//发件人
message.From.Add(new MimeKit.MailboxAddress(_config.From, _config.From));
//邮件主题
message.Subject = (subject);
//设置邮件内容
if (_config.BodyHtml)
{
var bodybuilder = new MimeKit.BodyBuilder
{
HtmlBody = body
};
message.Body = bodybuilder.ToMessageBody();
}
else
{
message.Body = new MimeKit.TextPart("plain")
{
Text = body
}
};
//添加收件人
foreach (var item in to)
{
message.To.Add(new MimeKit.MailboxAddress(item, item));
}
//添加抄送人
if (cc != null)
{
foreach (var item in cc)
{
message.Cc.Add(new MimeKit.MailboxAddress(item, item));
}
}
//初始化SMTP服务器并发送邮件
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect(_config.SmtpHost, _config.SmtpPort, _config.EnableSsl);
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.Authenticate(_config.SmtpAccount, _config.SmtpPwd);
client.Send(message);
client.Disconnect(true);
}
}
public void sendMail(string mailClient, string nomFichier)
{
//Chemin d'accès
DirectoryInfo dirBeforeAppli = Directory.GetParent(Convert.ToString(Directory.GetParent(Convert.ToString(Directory.GetParent(Convert.ToString(Directory.GetParent(Directory.GetCurrentDirectory())))))));
//Create Message
MailMessage mail = new MailMessage();
mail.Subject = "Devis Île de Loisirs de Vaires-Torcy";
mail.Body = "Bonjour, \r\n\r\nVeuillez trouver ci joint votre devis pour la baignade. \r\n\r\nBonne journee, Cordialement. \nDJEMMAA Walid\r\n\r\n\r\n--\r\nAccueil Plage\r\[email protected]\r\nPole baignade\r\nRoute de Lagny\r\n77200 Torcy\r\nTel: 0160200204 (touche 2)\r\nFax: 0164809149";
mail.From = new MailAddress("*****@*****.**");
mail.IsBodyHtml = false;
string joint = dirBeforeAppli + @"\Devis" + DateTime.Today.Year.ToString() + @"\5860" + (DateTime.Today.Year - 2000) + "-" + nomFichier + ".xlsx";
mail.Attachments.Add(new Attachment(joint));
mail.To.Add(new MailAddress(mailClient));
MimeKit.MimeMessage mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mail);
Google.Apis.Gmail.v1.Data.Message message = new Message();
message.Raw = Base64UrlEncode(mimeMessage.ToString());
//Gmail API credentials
UserCredential credential;
using (var stream =
new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/gmail-dotnet-quickstart2.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
Scope,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
}
// Create Gmail API service.
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
//Send Email
var result = service.Users.Messages.Send(message, "me").Execute();
}
private MimeKit.MimeMessage CreateMailMessage(string payload, string subject)
{
var mailMessage = new MimeKit.MimeMessage();
mailMessage.From.Add(_fromAddress);
mailMessage.To.AddRange(_toAddresses);
mailMessage.Subject = subject;
mailMessage.Body = _connectionInfo.IsBodyHtml
? new MimeKit.BodyBuilder {
HtmlBody = payload
}.ToMessageBody()
: new MimeKit.BodyBuilder {
TextBody = payload
}.ToMessageBody();
return(mailMessage);
}
protected bool CheckRule(MimeKit.MimeMessage message, SmtpSession session)
{
if (message == null || session == null)
{
return(false);
}
foreach (var address in message.Bcc)
{
var mailAddress = address as MimeKit.MailboxAddress;
if (mailAddress != null)
{
}
}
return(false);
}
static void SendHTMLmessage_err(GmailService service)
{
//Create Message
MailMessage mail = new MailMessage();
mail.Subject = "Subject testtttttt!";
mail.Body = "This is <b><i>body</i></b> of message";
mail.From = new MailAddress("*****@*****.**");
mail.IsBodyHtml = true;
//////string attImg = "C:\\Users\\ADMIN\\Pictures\\1.png";
//////mail.Attachments.Add(new Attachment(attImg));
////////mail.To.Add(new MailAddress("*****@*****.**"));
MimeKit.MimeMessage mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mail);
Message message = new Message();
message.Raw = Base64UrlEncode(mimeMessage.ToString());
////////Gmail API credentials
//////UserCredential credential;
//////using (var stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
//////{
////// string credPath = System.Environment.GetFolderPath(
////// System.Environment.SpecialFolder.Personal);
////// credPath = Path.Combine(credPath, ".credentials/gmail-dotnet-quickstart2.json");
////// credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
////// GoogleClientSecrets.Load(stream).Secrets,
////// Scopes,
////// "user",
////// CancellationToken.None,
////// new FileDataStore(credPath, true)).Result;
////// Console.WriteLine("Credential file saved to: " + credPath);
//////}
//////// Create Gmail API service.
//////var service = new GmailService(new BaseClientService.Initializer()
//////{
////// HttpClientInitializer = credential,
////// ApplicationName = ApplicationName,
//////});
//Send Email
//var result = service.Users.Messages.Send(message, "me/OR UserId/EmailAddress").Execute();
var result = service.Users.Messages.Send(message, "*****@*****.**").Execute();
}
/// <summary>
/// Writes to file async process.
/// </summary>
/// <param name="id">The identifier of message.</param>
/// <param name="file">The file where write message.</param>
/// <param name="content">The content of message.</param>
/// <returns>Completed task.</returns>
private static Task WriteToFileProcess(UniqueId id, string file, MimeKit.MimeMessage content)
{
return(Task.Run(async() =>
{
using (StreamWriter sw = new StreamWriter(File.Create(file)))
{
var emailDto = new EmailDto
{
Subject = content.Subject,
From = content.From.ToString(),
MessageId = (int)id.Id,
Body = content.HtmlBody
};
await Task.Run(() => { EmailDtoFileWorker.WriteEmailDto(sw, emailDto); });
}
}));
}
public async Task SendMailSuccessTest()
{
var recipient = "*****@*****.**";
using var client = await SpgMailClient.Create(username, password);
var message = new MimeKit.MimeMessage();
message.From.Add(new MimeKit.MailboxAddress("Ich", $"{username}@spengergasse.at"));
message.ReplyTo.Add(new MimeKit.MailboxAddress("Ich", $"{username}@spengergasse.at"));
message.To.Add(new MimeKit.MailboxAddress("Du", recipient));
message.Subject = "Testmail aus dem Exchange Server";
message.Body = new MimeKit.TextPart("plain")
{
Text = $"Testmail gesendet um {DateTime.UtcNow} UTC."
};
await client.SendMailAsync(message);
}
private static Message CreateMessage(string contactFormResponse)
{
MailMessage mail = new MailMessage
{
Subject = "FAILURE: Could not submit contact form",
Body = contactFormResponse,
From = new MailAddress("*****@*****.**"),
IsBodyHtml = true
};
mail.To.Add(new MailAddress("*****@*****.**"));
MimeKit.MimeMessage mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mail);
return(new Message {
Raw = Base64UrlEncode(mimeMessage.ToString())
});
}
//*************************************************************************************************************
private void TestWithMailKit(Test test)
{
try
{
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
if (test.SMTPSecurity == "STARTTLS")
{
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect(test.SMTPHost, int.Parse(test.SMTPPort), MailKit.Security.SecureSocketOptions.StartTls);
}
else
{
client.Connect(test.SMTPHost, int.Parse(test.SMTPPort), MailKit.Security.SecureSocketOptions.None);
}
if (test.SMTPUser != "")
{
client.Authenticate(test.SMTPUser, test.SMTPPassword);
}
var message = new MimeKit.MimeMessage();
message.From.Add(new MimeKit.MailboxAddress(test.From));
message.To.Add(new MimeKit.MailboxAddress(test.To));
message.Subject = test.Subject;
message.Body = new MimeKit.TextPart("plain")
{
Text = test.Body
};
client.Send(message);
client.Disconnect(true);
}
Log("********* SENT *********");
}
catch (Exception ex)
{
textLog.AppendText("=================================================================\r\n");
Log(ex.Message);
Log(ex.StackTrace);
}
}
/// <summary>
/// 发送邮件
/// </summary>
/// <param name="Name">发件人名字</param>
/// <param name="receive">接收邮箱</param>
/// <param name="sender">发送邮箱</param>
/// <param name="password">邮箱密码</param>
/// <param name="host">邮箱主机</param>
/// <param name="port">邮箱端口</param>
/// <param name="subject">邮件主题</param>
/// <param name="body">邮件内容</param>
/// <returns></returns>
public async System.Threading.Tasks.Task <bool> SendMailAsync(string Name, string receive, string sender, string password, string host, int port, string subject, string body)
{
try
{
// MimeMessage代表一封电子邮件的对象
var message = new MimeKit.MimeMessage();
// 添加发件人地址 Name 发件人名字 sender 发件人邮箱
message.From.Add(new MimeKit.MailboxAddress(Name, sender));
// 添加收件人地址
message.To.Add(new MimeKit.MailboxAddress("", receive));
// 设置邮件主题信息
message.Subject = subject;
// 设置邮件内容
var bodyBuilder = new MimeKit.BodyBuilder()
{
HtmlBody = body
};
message.Body = bodyBuilder.ToMessageBody();
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
// For demo-purposes, accept all SSL certificates (in case the server supports STARTTLS)
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
// Note: since we don't have an OAuth2 token, disable
// the XOAUTH2 authentication mechanism.
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.CheckCertificateRevocation = false;
//client.SslProtocols = System.Security.Authentication.SslProtocols.Tls12;
client.Connect(host, port, MailKit.Security.SecureSocketOptions.Auto);
// Note: only needed if the SMTP server requires authentication
client.Authenticate(sender, password);
await client.SendAsync(message);
client.Disconnect(true);
return(true);
}
}
catch (Exception ex)
{
}
return(false);
}
public static Message CreateMessage(string to, string subject, string content, string path)
{
Message message = new Message();
MailMessage mail = new MailMessage();
mail.Subject = subject;
mail.Body = content;
mail.To.Add(new MailAddress(to));
mail.IsBodyHtml = true;
mail.Attachments.Add(new Attachment(path));
MimeKit.MimeMessage mimeMessage = MimeKit.MimeMessage.CreateFromMailMessage(mail);
message.Raw = Base64UrlEncode(mimeMessage.ToString());
return(message);
}
public ViewMessageViewController(MimeKit.MimeMessage msg) : base(UITableViewStyle.Grouped, null, true)
{
Root = new RootElement("Details")
{
new Section {
new StyledMultilineElement(msg.Subject),
new StyledMultilineElement("From:", msg.From.ToString()),
new StyledStringElement(msg.Date.LocalDateTime.ToString())
{
Font = UIFont.SystemFontOfSize(12f)
},
},
new Section {
new StyledMultilineElement(msg.TextBody)
{
Font = UIFont.SystemFontOfSize(12f)
}
},
};
}
