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);
}
public ArrayImpl Get(bool deleteMessages, ArrayImpl ids, bool markAsRead)
{
var result = new ArrayImpl();
var processedMessages = GetMessagesList(ids);
foreach (var i in processedMessages)
{
var mimeMessage = _currentFolder.GetMessage(i);
var iMessage = new InternetMailMessage(mimeMessage, UniqueIdToInternalId(i));
result.Add(iMessage);
}
if (processedMessages.Count > 0)
{
if (deleteMessages)
{
_currentFolder.AddFlags(processedMessages, MessageFlags.Deleted, silent: true);
}
else if (markAsRead)
{
_currentFolder.AddFlags(processedMessages, MessageFlags.Seen, silent: true);
}
}
return(result);
}
private void datagridOnSelected(object sender, RoutedEventArgs e)
{
if (!imapClient.IsAuthenticated)
{
login();
}
readMail rM = new readMail();
MessageBox.Show("ww" + dataGrid.SelectedItem.ToString().Split('=')[5].Substring(1, dataGrid.SelectedItem.ToString().Split('=')[5].Length - 3) + "ww");
string[] x = { dataGrid.SelectedItem.ToString().Split('=')[5].Substring(1, dataGrid.SelectedItem.ToString().Split('=')[5].Length - 3) };
intializeFolder();
var temp = fol.GetMessage(UniqueId.Parse(x[0]));
rM.Title = temp.Subject;
rM.lb1.Content += temp.Date.ToString();
rM.lb2.Content += temp.Subject;
rM.lb3.Content += temp.From.ToString();
Uri uri;
if (temp.HtmlBody != null)
{
StreamWriter sw = new StreamWriter("d:\\temp.html", false); sw.Write(temp.HtmlBody); sw.Close();
uri = new Uri(@"d:\temp.html", UriKind.Absolute);
}
else
{
uri = new Uri("data:text/plain," + temp.TextBody, UriKind.Absolute);
}
rM.wb.Source = uri;
rM.Show();
}
public void CopyFolder(IMailFolder folder, Folder sqlEntity, bool update, string password)
{
try
{
folder.Open(FolderAccess.ReadOnly);
}
catch (Exception)
{
return;
}
Random rng = AzusaContext.GetInstance().RandomNumberGenerator;
IList <UniqueId> uuids = folder.Search(FolderService.GetSearchQuery(sqlEntity));
foreach (UniqueId uuid in uuids)
{
if (MessageService.TestForMessage((int)uuid.Id))
{
continue;
}
var message = folder.GetMessage(uuid);
byte[] saltBuffer = new byte[16];
rng.NextBytes(saltBuffer);
Array.Copy(azusaString, 0, saltBuffer, 0, azusaString.Length);
int iterations = rng.Next(1000, short.MaxValue);
Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(password, saltBuffer, iterations);
Aes aes = Aes.Create();
aes.Key = deriveBytes.GetBytes(32);
aes.IV = deriveBytes.GetBytes(16);
MemoryStream ms = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write);
message.WriteTo(cryptoStream);
cryptoStream.Flush();
Mail child = new Mail();
child.Uid = (int)uuid.Id;
child.MessageUtime = message.Date.DateTime.ToUnixTime();
child.Folder = sqlEntity.id;
child.From = message.From[0].ToString();
if (message.To.Count > 0)
{
child.To = message.To[0].ToString();
}
else
{
child.To = null;
}
child.Subject = message.Subject;
child.Salt = saltBuffer;
child.Iterations = (short)iterations;
child.Data = new byte[ms.Position];
Array.Copy(ms.GetBuffer(), 0, child.Data, 0, ms.Position);
MessageService.StoreMessage(child);
}
folder.Close(false);
}
/// <summary>
/// 根据唯一标识和文件夹名,获取单个邮件
/// </summary>
/// <param name="folderName"></param>
/// <returns></returns>
public EmailViewM GetEmailByUid(uint uniqueid, string folderName = null)
{
try
{
using (ImapClient client = ConnectIMAP())
{
if (folderName == null)
{
folderName = client.Inbox.Name;
}
IMailFolder folder = client.GetFolder(folderName);
folder.Open(FolderAccess.ReadOnly);
var email = folder.GetMessage(new UniqueId(uniqueid));
var entity = FillEntity(null, email);
//
folder.Close();
client.Disconnect(true);
//
return(entity);
}
}
catch (Exception e)
{
ErrMsg = $"获取单个邮件异常:{e.ToString()} [{e.Message}]";
return(null);
}
}
private UniqueId GetUniqueId(MimeMessage mailMessage, string folder)
{
UniqueId id = new UniqueId();
IMailFolder mailFolder = GetFolder(folder);
bool open = mailFolder.IsOpen;
if (!open)
{
mailFolder.Open(FolderAccess.ReadOnly);
}
var items = mailFolder.Fetch(0, -1, MessageSummaryItems.UniqueId | MessageSummaryItems.Size | MessageSummaryItems.Flags);
foreach (var item in items)
{
var message = mailFolder.GetMessage(item.UniqueId);
if (message.MessageId == mailMessage.MessageId)
{
id = item.UniqueId;
break;
}
}
if (!open)
{
mailFolder.Close();
}
return(id);
}
// GET api/<controller>
public IEnumerable <long> Get(string IMAP, int Port, string Login, string Password)
{
List <long> list = new List <long>();
using (ImapClient client = new ImapClient())
{
var context = new ELMA3Entities();
client.Connect(IMAP, Port, SecureSocketOptions.SslOnConnect);
client.Authenticate(Login, Password);
IMailFolder inbox = client.Inbox;
inbox.Open(FolderAccess.ReadOnly);
var uids = inbox.Search(SearchQuery.NotSeen);
foreach (var item in uids)
{
var message = inbox.GetMessage(item);
string a;
if (message.HtmlBody != null)
{
a = message.HtmlBody;
}
else
{
a = message.TextBody;
}
var b = context.CreateEmailMessageI(DateTime.Now.ToString(), DateTime.Now, message.Subject, a, message.Date.UtcDateTime, message.From.FirstOrDefault().Name);
list.Add(b.FirstOrDefault().Id);
}
}
return(list.AsEnumerable());
}
private void CheckImapMail()
{
try
{
using (ImapClient imapClient = new ImapClient())
{
imapClient.Connect(_configuration.ServerName, _configuration.Port, _configuration.SSL);
imapClient.AuthenticationMechanisms.Remove("XOAUTH2");
imapClient.Authenticate(_configuration.UserName, _configuration.Password);
IMailFolder inbox = imapClient.Inbox;
inbox.Open(FolderAccess.ReadWrite);
foreach (UniqueId msgUid in inbox.Search(SearchQuery.NotSeen))
{
MimeMessage msg = inbox.GetMessage(msgUid);
ProcessMail(msg);
inbox.SetFlags(msgUid, MessageFlags.Seen, true);
}
}
}
catch (Exception ex)
{
// Sometimes an error occures, e.g. if the network was disconected or a timeout occured.
Logger.Instance.LogException(this, ex);
}
}
IEnumerable <MimeMessage> Fetch(IMailFolder inbox)
{
for (int i = 0; i < inbox.Count; i++)
{
yield return(inbox.GetMessage(i));
}
}
public List <string> ReceivedFileImap(string SaveToDirectory)
{
List <string> file_names = new List <string>();
using (ImapClient client = new ImapClient())
{
client.Connect(IMAPGmailServer, IMAPGmailPort, true);
client.Authenticate(mailAddress, mailPassword);
IMailFolder inbox = client.Inbox;
inbox.Open(FolderAccess.ReadOnly);
for (int i = 0; i < inbox.Count; i++)
{
MimeMessage message = inbox.GetMessage(i);
if (message.Date.Month == DateTime.Now.Month && message.Date.Day == DateTime.Now.Day && message.Date.Year == DateTime.Now.Year)
{
IEnumerable <MimeEntity> attachments = message.Attachments;
foreach (MimeEntity file in attachments)
{
file_names.Add(SaveToDirectory + file.ContentType.Name);
GetFileImap(file, SaveToDirectory);
}
}
}
}
logger.WriteLog("Get archives from email", LogLevel.Mail);
return(file_names);
}
/// <summary>
/// Get the list of emails for a search
/// </summary>
/// <param name="condition">The search condition</param>
/// <param name="headersOnly">True if you only want header information</param>
/// <param name="markRead">True if you want the emails marked as read</param>
/// <returns>The list of mail message that match the search</returns>
private List <MimeMessage> GetSearchResults(SearchQuery condition, bool headersOnly, bool markRead)
{
List <MimeMessage> messageList = new List <MimeMessage>();
IMailFolder folder = this.GetCurrentFolder();
foreach (UniqueId uid in folder.Search(condition, default))
{
if (markRead)
{
folder.AddFlags(uid, MessageFlags.Seen, true);
}
MimeMessage message;
if (headersOnly)
{
HeaderList headers = folder.GetHeaders(uid);
var messageId = headers[HeaderId.MessageId];
message = new MimeMessage(headers)
{
MessageId = messageId
};
}
else
{
message = folder.GetMessage(uid);
}
messageList.Add(message);
}
return(messageList);
}
public static void DownloadEmail(this Email email, IMailFolder mailFolder)
{
try
{
Console.WriteLine("[Downloading Email] {0:D2} ", email.Id);
var savePath = AppConfig.EmailSaveDirectory + email.Id + ".eml";
if (!File.Exists(savePath))
{
lock (mailFolder.SyncRoot)
{
File.WriteAllText(savePath, mailFolder.GetMessage(email.Id).ToString());
Console.WriteLine("[Email Downloaded] {0:D2}: {1}", email.Id, savePath);
}
}
else
{
Console.WriteLine("[Download Cancelled] EML {0:D2} Already Exists: {1}", email.Id, savePath);
}
}
catch (Exception e)
{
Console.WriteLine("Failed to download email of ID {" + email.Id + "}.");
Console.WriteLine(e.StackTrace);
throw;
//return null;
}
}
public void GetAllMails(IProgress <MailInfo> progress, [Optional] IMailFolder folder)
{
using (ImapClient client = new ImapClient())
{
client.Connect(mailServer, port, ssl);
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.Authenticate(UserData.Email, UserData.Password);
if (folder == null)
{
folder = client.Inbox;
}
else
{
folder = client.GetFolder(folder.FullName);
}
folder.Open(FolderAccess.ReadOnly);
SearchResults results = folder.Search(SearchOptions.All, SearchQuery.DeliveredAfter(DateFrom));
if (results.UniqueIds.Count < MaxEmails)
{
MaxEmails = results.UniqueIds.Count;
}
for (int i = MaxEmails - 1; i >= 0; i--)
{
MailInfo message = new MailInfo(folder.GetMessage(results.UniqueIds[i]), results.UniqueIds[i], folder);
progress.Report(message);
}
folder.Close();
client.Disconnect(true);
}
}
/// <summary>
/// Get the list of emails for a search
/// </summary>
/// <param name="args">The search condition followed by the header only and set as seen booleans</param>
/// <returns>The list of mail message that match the search</returns>
private List <MimeMessage> GetSearchResults(params object[] args)
{
List <MimeMessage> messageList = new List <MimeMessage>();
IMailFolder folder = this.GetCurrentFolder();
foreach (UniqueId uid in folder.Search((SearchQuery)args[0], default(CancellationToken)))
{
if ((bool)args[2])
{
folder.AddFlags(uid, MessageFlags.Seen, true);
}
MimeMessage message = null;
if ((bool)args[1])
{
HeaderList headers = folder.GetHeaders(uid);
message = new MimeMessage(headers);
}
else
{
message = folder.GetMessage(uid);
}
messageList.Add(message);
}
return(messageList);
}
public IEnumerable <IEMailMessageI> GetReadMailMessages(IMailRequestI mailRequest)
{
var mailMessages = new List <IEMailMessageI>();
using (ImapClient client = new ImapClient())
{
client.Connect(MailReadersSettingsModule.Settings.IMAP, MailReadersSettingsModule.Settings.IMAPport, SecureSocketOptions.SslOnConnect);
client.Authenticate(MailReadersSettingsModule.Settings.Login, MailReadersSettingsModule.Settings.Password);
IMailFolder inbox = client.Inbox;
inbox.Open(FolderAccess.ReadOnly);
var uids = inbox.Search(SearchQuery.Seen);
foreach (var item in uids)
{
var message = inbox.GetMessage(item);
var mailMessage = EntityManager <IEMailMessageI> .Instance.Create();
mailMessage.Name = DateTime.Now.ToString();
mailMessage.CreationDate = DateTime.Now;
mailMessage.Tema = message.Subject;
mailMessage.Soobschenie = message.HtmlBody;
mailMessage.DataPolucheniePisjma = message.Date.UtcDateTime;
mailMessage.OtKogo = message.From.FirstOrDefault().Name;
mailMessage.Save();
mailMessages.Add(mailMessage);
}
}
return(mailMessages.AsEnumerable());
}
/// <summary>
/// Reads all the messages.
/// </summary>
private static void ReadMessage()
{
using (ImapClient client = new ImapClient())
{
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect("imap.gmail.com", 993, true);
client.Authenticate(from.Address, password);
IMailFolder inbox = client.Inbox;
inbox.Open(FolderAccess.ReadOnly);
Console.WriteLine("Total messages: {0}", inbox.Count);
Console.WriteLine("Recent messages: {0}", inbox.Recent);
for (int i = 0; i < inbox.Count; i++)
{
MimeMessage message = inbox.GetMessage(i);
Console.WriteLine("\n-------------------- messsage " + i + 1 + ", size=" + inbox.Fetch(0, -1, MessageSummaryItems.Size).ElementAt(i).Size + " --------------------");
Console.WriteLine("From: {0}", message.From[0]);
Console.WriteLine("Subject: {0}", message.Subject);
Console.WriteLine("Text: {0}", message.TextBody);
Console.WriteLine("-------------------- end of message " + i + 1 + " --------------------");
}
Console.WriteLine("Press a key to continue");
Console.ReadKey();
client.Disconnect(true);
}
}
private static void GetMessagesWithAttachments(IMailFolder inbox)
{
for (int i = 0; i < inbox.Count; i++)
{
var message = inbox.GetMessage(i);
GetAttachments(message);
}
}
private async Task <MimeMessage> GetMessage(IMailFolder mailFolder, UniqueId uid)
{
var tollerantGetMessage = new TolerantFunction <UniqueId, MimeMessage>(new TolerantFunctionConfig <UniqueId, MimeMessage>()
{
Func = id => mailFolder.GetMessage(id)
});
return(await tollerantGetMessage.Execute(uid));
}
public List <MimeMessage> LoadMessages()
{
foreach (var item in Fetch(inbox))
{
unSorted.Add(item);
}
foreach (var uid in inbox.Search(SearchQuery.NotSeen))
{
var message = inbox.GetMessage(uid);
notseen.Add(message);
}
foreach (var uid in inbox.Search(SearchQuery.Seen))
{
var message = inbox.GetMessage(uid);
seen.Add(message);
}
msg = unSorted;
return(new List <MimeMessage>(msg));
}
public IList <MimeMessage> GetMessages(IMailFolder folder)
{
folder.Open(FolderAccess.ReadOnly);
List <MimeMessage> mimeMessages = new List <MimeMessage>(folder.Count);
for (int i = 0; i < folder.Count; i++)
{
mimeMessages.Add(folder.GetMessage(i));
}
return(mimeMessages);
}
/// <summary>
/// Uses the given indices to extract messages from provided inbox, returning a list of messages
/// </summary>
/// <param name="emails">Mail folder of emails</param>
/// <param name="ids">List of unique ids of emails to be extracted</param>
/// <returns></returns>
public static List <MimeMessage> ExtractMessages(IMailFolder emails, IList <UniqueId> ids)
{
List <MimeMessage> messages = new List <MimeMessage>();
foreach (UniqueId id in ids)
{
messages.Add(emails.GetMessage(id));
}
return(messages);
}
public Tuple <IList <Mail>, HttpStatusCode> GetMailsFromFolder(string folder, int page, int pageSize, string sortOrder)
{
if (!IsAuthenticated())
{
return(new Tuple <IList <Mail>, HttpStatusCode>(null, HttpStatusCode.ExpectationFailed));
}
if (folder != _currentFolder)
{
reloadMessages(folder);
}
List <Mail> Mails = new List <Mail>();
if (_currentFolderSummary == null)
{
_currentFolderSummary = new List <IMessageSummary>();
}
switch (sortOrder)
{
case "dateAsc":
_currentFolderSummary = _currentFolderSummary.OrderBy(mail => mail.Date.DateTime);
break;
case "subjectDesc":
_currentFolderSummary = _currentFolderSummary.OrderByDescending(mail => mail.NormalizedSubject);
break;
case "subjectAsc":
_currentFolderSummary = _currentFolderSummary.OrderBy(mail => mail.NormalizedSubject);
break;
case "senderDesc":
_currentFolderSummary = _currentFolderSummary.OrderByDescending(mail => mail.Envelope.From[0]);
break;
case "senderAsc":
_currentFolderSummary = _currentFolderSummary.OrderBy(mail => mail.Envelope.From[0]);
break;
default:
_currentFolderSummary = _currentFolderSummary.OrderByDescending(mail => mail.Date.DateTime);
break;
}
IMailFolder mailFolder = GetFolder(folder);
mailFolder.Open(FolderAccess.ReadWrite);
foreach (var mail in _currentFolderSummary.Skip((page - 1) * pageSize).Take(pageSize))
{
Mails.Add(new Mail((MessageSummary)mail, mailFolder.GetMessage(mail.UniqueId), folder));
}
mailFolder.Close();
return(new Tuple <IList <Mail>, HttpStatusCode>(Mails, HttpStatusCode.OK));
}
private static string CheckMail(long postId, IMailFolder inbox, UniqueIdRange range,
BinarySearchQuery query)
{
string result = string.Empty;
foreach (UniqueId uid in inbox.Search(range, query))
{
var message = inbox.GetMessage(uid);
result = message.TextBody.Split('\r', '\n').FirstOrDefault();
if (!string.IsNullOrEmpty(result))
{
inbox.AddFlags(uid, MessageFlags.Seen, true);
}
if (result != null && result.ToLower().ToLower() == "cancel")
{
C.WriteLine("We won't be proceeding with this post...");
DbBlackList dbBlackList = new DbBlackList();
Blacklist item = new Blacklist
{
Subreddit = WorkingSub,
PostId = postId,
CreatedDate = DateTime.Now
};
dbBlackList.AddToBlacklist(item);
Environment.Exit(0);
}
else if (result != null && result.ToLower().ToLower() == "next")
{
C.WriteLine("We won't be proceeding with this post...");
DbBlackList dbBlackList = new DbBlackList();
Blacklist item = new Blacklist
{
Subreddit = WorkingSub,
PostId = postId,
CreatedDate = DateTime.Now
};
dbBlackList.AddToBlacklist(item);
Process.Start(Assembly.GetExecutingAssembly().Location, Args.FirstOrDefault());
Environment.Exit(0);
}
else
{
C.WriteLineNoTime("We got a title!");
}
break;
}
return(result);
}
public static void Analyze(IMailFolder folder, LearningDataSet result) {
var messages = folder.Search(SearchQuery.All);
if (messages.Count > 0) {
foreach (var messageUid in messages) {
var message = folder.GetMessage(messageUid);
AnalyzeMessage(message, result);
}
}
result.LastUpdate = DateTime.Now;
}
public void GetAllMailsByFolder(IProgress <MimeMessage> progress, String selectedFolder)
{
var messages = new List <MimeMessage>();
using (var client = new ImapClient())
{
try
{
client.Connect(mailServer, port, ssl);
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.Authenticate(login, password);
var mainEmailFolder = client.GetFolder(client.PersonalNamespaces[0]);
emailFolders = mainEmailFolder.GetSubfolders().ToList();
IMailFolder inbox = null;
foreach (var folder in emailFolders)
{
if (folder.FullName == selectedFolder)
{
inbox = folder;
}
}
inbox.Open(FolderAccess.ReadOnly);
var results = inbox.Search(SearchOptions.All, SearchQuery.All);
int emailCounter = results.UniqueIds.Count;
if (emailCounter > 50)
{
emailCount = 50;
}
else
{
emailCount = results.UniqueIds.Count;
}
for (int i = emailCounter - 1; i >= emailCounter - emailCount; i--)
{
var message = inbox.GetMessage(results.UniqueIds[i]);
progress.Report(message);
messages.Add(message);
}
client.Disconnect(true);
}
catch (AuthenticationException)
{
MessageBox.Show("Wrong username or password.");
}
}
}
static void fetch_incoming_messages()
{
using (var client = new ImapClient())
{
try
{
bd_util.log("fetch_incoming_messages Connecting to Imap");
client.Connect(
bd_config.get(bd_config.ImapHost),
bd_config.get(bd_config.ImapPort),
true); // ssl
client.Authenticate(
bd_config.get(bd_config.ImapUser),
bd_config.get(bd_config.ImapPassword)
);
// The Inbox folder is always available on all IMAP servers...
IMailFolder inbox = client.Inbox;
inbox.Open(FolderAccess.ReadWrite);
bd_util.log("Total messages: " + inbox.Count.ToString());
bd_util.log("Recent messages: " + inbox.Recent.ToString());
for (int index = 0; index < inbox.Count; index++)
{
var message = inbox.GetMessage(index);
bool processed = process_incoming_message(message);
if (processed)
{
// delete it
if (bd_config.get(bd_config.DebugSkipDeleteOfIncomingEmails) == 0)
{
bd_util.log("Actually deleting: " + message.Subject);
inbox.AddFlags(index, MessageFlags.Deleted, true);
client.Inbox.Expunge();
}
}
}
client.Disconnect(true);
bd_util.log("Disconnecting from Imap");
}
catch (Exception exception)
{
bd_util.log(exception.Message);
bd_util.log(exception.StackTrace);
}
}
}
protected override void Execute(CodeActivityContext context)
{
string username = Email.Get(context); //发送端账号
string password = Password.Get(context); //发送端密码(这个客户端重置后的密码)
string server = Server.Get(context); //邮件服务器
Int32 port = Port.Get(context); //端口号
string mailFolderTo = MailFolderTo.Get(context); //目标文件夹
string mailFolderFrom = MailFolderFrom.Get(context); //源文件夹
MimeMessage mailMoveMessage = MailMoveMessage.Get(context);
ImapClient client = new ImapClient();
SearchQuery query;
try
{
client.Connect(server, port, SecureConnection);
client.Authenticate(username, password);
if (EnableSSL)
{
client.SslProtocols = System.Security.Authentication.SslProtocols.Ssl3;
}
query = SearchQuery.All;
List <IMailFolder> mailFolderList = client.GetFolders(client.PersonalNamespaces[0]).ToList();
IMailFolder fromFolder = client.GetFolder(mailFolderFrom);
IMailFolder toFolder = client.GetFolder(mailFolderTo);
fromFolder.Open(FolderAccess.ReadWrite);
IList <UniqueId> uidss = fromFolder.Search(query);
List <MailMessage> emails = new List <MailMessage>();
for (int i = uidss.Count - 1; i >= 0; i--)
{
MimeMessage message = fromFolder.GetMessage(new UniqueId(uidss[i].Id));
if (message.Date == mailMoveMessage.Date &&
message.MessageId == mailMoveMessage.MessageId &&
message.Subject == mailMoveMessage.Subject)
{
fromFolder.MoveTo(new UniqueId(uidss[i].Id), toFolder);
break;
}
}
client.Disconnect(true);
}
catch (Exception e)
{
client.Disconnect(true);
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "IMAP移动邮件失败", e.Message);
}
}
public List <MailItem> ExtractMailItems(IMailFolder folder, int pageSize, int page, List <uint> existingUids)
{
try
{
using (var client = new ImapClient())
{
Connect(client);
if (!folder.IsOpen)
{
logger.LogTrace("Open Folder");
folder.Open(FolderAccess.ReadOnly);
}
logger.LogInformation($"Fetch summaries [{folder.FullName}] - \tPage: {page} - Page Size: {pageSize}");
var summaries = folder.Fetch(page * pageSize, (page + 1) * pageSize - 1, MessageSummaryItems.UniqueId);
logger.LogInformation($"Got summaries [{folder.FullName}] - Count: {summaries.Count}");
if (summaries.Count == 0)
{
return(null);
}
var result = new List <MailItem>();
logger.LogTrace("Extract Mail Addresses");
foreach (var summary in summaries)
{
if (!existingUids.Contains(summary.UniqueId.Id))
{
var message = folder.GetMessage(summary.UniqueId);
result.AddRange(CreateMailItems(logger, message, this, folder, summary.UniqueId));
}
}
if (folder.IsOpen)
{
logger.LogTrace("Close Folder");
folder.Close(false);
}
return(result);
}
}
catch (Exception e)
{
logger.LogError(e, $"Error in folder: {folder.FullName} \r\n {e.Message}");
return(null);
}
}
private void button1_Click(object sender, EventArgs e)
{
ImapClient client = new ImapClient();
string account = "*****@*****.**";
string passWord = "******";
client.Connect("imap.qiye.163.com", 993, true);
//client.Authenticate("*****@*****.**", "TNL7EtuUVJ5mRNcw");
client.Authenticate(account, passWord);
IMailFolder inbox = client.Inbox;
inbox.Open(FolderAccess.ReadWrite);
IList <UniqueId> mail_list = inbox.Search(SearchQuery.New);
foreach (UniqueId item in mail_list)
{
//得到邮件的内容
MimeMessage message = inbox.GetMessage(item);
foreach (MimeEntity attachment in message.Attachments)
{
MimePart mime = (MimePart)attachment;
Console.WriteLine(mime.FileName);
string fileName = mime.FileName;
if (mime.FileName.Contains(".xls"))
{
try
{
using (FileStream stream = File.Create(fileName))
{
mime.Content.DecodeTo(stream);
}
}
catch
{
continue;
}
}
// client.Inbox.SetFlags(item, MessageFlags.Seen,false);
}
}
}
/// <summary>
/// download a mail's attachments
/// </summary>
/// <param name="folder">file folder</param>
/// <param name="id">mail uid</param>
/// <returns>file's stream</returns>
private Stream Download(IMailFolder folder, UniqueId id)
{
Stream stream = new MemoryStream();
MimeMessage message = folder.GetMessage(id);
foreach (MimePart attachment in message.Attachments)
{
//下载附件
using (var cancel = new CancellationTokenSource())
{
attachment.Content.DecodeTo(stream, cancel.Token);
return(stream);
}
}
return(stream);
}
public WrappedMessage(ImapClient client, IMailFolder inbox, int index, List <string> filters)
{
this.Client = client;
this.Inbox = inbox;
this.Index = index;
this.Filters = filters;
Message = inbox.GetMessage(index);
SenderAddress = Message.From.Mailboxes.FirstOrDefault()?.Address;
SenderName = Message.From.Mailboxes.FirstOrDefault()?.Name;
MailAddress senderAddressObj = new MailAddress(SenderAddress ?? string.Empty);
Host = senderAddressObj.Host;
}
private void ProcessRules(IMailFolder inbox) {
inbox.Open(FolderAccess.ReadWrite);
inbox.Status(StatusItems.Unread);
if (inbox.Unread > 0) {
var unreadMessageUids = inbox.Search(SearchQuery.NotSeen);
var toMove = new Dictionary<string, List<UniqueId>>();
var markAsRead = new List<UniqueId>();
// process unread messages
foreach (var unreadMessageUid in unreadMessageUids) {
var message = inbox.GetMessage(unreadMessageUid);
var matchingRule = GetMatchingRule(message);
if (matchingRule != null) {
if (!toMove.ContainsKey(matchingRule.Destination)) {
toMove.Add(matchingRule.Destination, new List<UniqueId>());
}
toMove[matchingRule.Destination].Add(unreadMessageUid);
if (matchingRule.MarkAsRead) {
markAsRead.Add(unreadMessageUid);
}
}
}
// mark as read
if (markAsRead.Any()) {
inbox.AddFlags(markAsRead, MessageFlags.Seen, true);
}
// move to destination
if (toMove.Any()) {
foreach (var destination in toMove.Keys) {
inbox.MoveTo(toMove[destination], inbox.GetSubfolder(destination));
}
}
}
}