Example #1
0
        private List<string> CheckForMessages()
        {
            var messages = new List<string>();

            _client = new ImapClient(_IMAPClientUri, true);
            if (_client.Connect() && _client.Login(_IMAPUsername, _IMAPPassword))
            {
                try
                {
                    var keyword = _subjectKeyword;                    
                    var emails = _client.Folders.Inbox.Search(string.Format("UNSEEN SUBJECT \"{0}\"", keyword), ImapX.Enums.MessageFetchMode.Full);
                    Console.WriteLine(string.Format("{0} emails", emails.Count()));
                    foreach (var email in emails)
                    {
                        messages.Add(email.Body.Text);
                        email.Remove();
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
                finally
                {
                    _client.Logout();
                    _client.Disconnect();                    
                }
            }
            else
            {
                Console.WriteLine("Bad email login");
            }
            return messages;
        }
    protected void brnSendEmail_Click(object sender, EventArgs e)
    {
        lblMessage.Text = "";

        try
        {
            // initialize imap client
            ImapClient client = new ImapClient();
            client.Host = txtHost.Text;
            client.Port = int.Parse(txtPort.Text);
            client.Username = txtUsername.Text;
            client.Password = txtPassword.Text;

            // connect to imap server and login
            client.Connect(true);
            lblMessage.ForeColor = Color.Green;
            lblMessage.Text = "Successfully connected to IMAP Mail server.<br><hr>";

            client.Disconnect();
        }
        catch (Exception ex)
        {
            lblMessage.ForeColor = Color.Red;
            lblMessage.Text = "Error: " + ex.Message;
        }
    }
    protected void gvMessages_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        if (e.CommandName == "DisplayMessage")
        {
            pnlMessage.Visible = true;
            string msgSequenceNumber = e.CommandArgument.ToString();

            try
            {
                // initialize imap client
                ImapClient client = new ImapClient();
                client.Host = txtHost.Text;
                client.Port = int.Parse(txtPort.Text);
                client.Username = txtUsername.Text;
                client.Password = Session["Password"].ToString();

                // SSL Settings
                if (chSSL.Checked == true)
                {
                    client.EnableSsl = true;
                    client.SecurityMode = ImapSslSecurityMode.Implicit;
                }

                // connect to pop3 server and login
                client.Connect(true);
                client.SelectFolder(ImapFolderInfo.InBox);
                lblMessage.ForeColor = Color.Green;
                lblMessage.Text = "Successfully connected to Imap Mail server.<br><hr>";

                // get the message
                MailMessage msg = client.FetchMessage(int.Parse(msgSequenceNumber));
                // sender name and address
                litFrom.Text = msg.From[0].DisplayName + " <" + msg.From[0].Address + ">";
                // to addresses
                litTo.Text = "";
                foreach (MailAddress address in msg.To)
                {
                    litTo.Text += address.DisplayName + " <" + address.Address + "> , ";
                }
                // cc addresses
                litCc.Text = "";
                foreach (MailAddress address in msg.CC)
                {
                    litCc.Text += address.DisplayName + " <" + address.Address + "> , ";
                }
                // subject
                litSubject.Text = msg.Subject;
                litBody.Text = msg.HtmlBody;

                client.Disconnect();
            }
            catch (Exception ex)
            {
                lblMessage.ForeColor = Color.Red;
                lblMessage.Text = "Error: " + ex.Message;
            }
        }
    }
        public static void Run()
        {
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_IMAP();
            string dstEmail = dataDir + "1234.eml";

            // Create a message
            Aspose.Email.Mail.MailMessage msg;
            msg = new Aspose.Email.Mail.MailMessage(
            "*****@*****.**",
            "*****@*****.**",
            "subject",
            "message"
            );

            //Create an instance of the ImapClient class
            ImapClient client = new ImapClient();

            //Specify host, username and password for your client
            client.Host = "imap.gmail.com";

            // Set username
            client.Username = "******";

            // Set password
            client.Password = "******";

            // Set the port to 993. This is the SSL port of IMAP server
            client.Port = 993;

            // Enable SSL
            client.SecurityOptions = SecurityOptions.Auto;

            try
            {
                // Subscribe to the Inbox folder
                client.SelectFolder(ImapFolderInfo.InBox);
                client.SubscribeFolder(client.CurrentFolder.Name);

                // Append the newly created message
                client.AppendMessage(client.CurrentFolder.Name, msg);

                System.Console.WriteLine("New Message Added Successfully");

                //Disconnect to the remote IMAP server
                client.Disconnect();

            }
            catch (Exception ex)
            {
                System.Console.Write(Environment.NewLine + ex.ToString());
            }

            Console.WriteLine(Environment.NewLine + "Added new message on IMAP server.");
        }
        public static void Run()
        {
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_IMAP();
            string dstEmail = dataDir + "1234.eml";

            //Create an instance of the ImapClient class
            ImapClient client = new ImapClient();

            //Specify host, username and password for your client
            client.Host = "imap.gmail.com";

            // Set username
            client.Username = "******";

            // Set password
            client.Password = "******";

            // Set the port to 993. This is the SSL port of IMAP server
            client.Port = 993;

            // Enable SSL
            client.SecurityOptions = SecurityOptions.Auto;

            try
            {
                // Get all folders in the currently subscribed folder
                Aspose.Email.Imap.ImapFolderInfoCollection folderInfoColl = client.ListFolders();

                // Iterate through the collection to get folder info one by one
                foreach (Aspose.Email.Imap.ImapFolderInfo folderInfo in folderInfoColl)
                {
                    // Folder name
                    Console.WriteLine("Folder name is " + folderInfo.Name);
                    ImapFolderInfo folderExtInfo = client.ListFolder(folderInfo.Name);
                    // New messages in the folder
                    Console.WriteLine("New message count: " + folderExtInfo.NewMessageCount);
                    // Check whether its readonly
                    Console.WriteLine("Is it readonly? " + folderExtInfo.ReadOnly);
                    // Total number of messages
                    Console.WriteLine("Total number of messages " + folderExtInfo.TotalMessageCount);
                }

                //Disconnect to the remote IMAP server
                client.Disconnect();

            }
            catch (Exception ex)
            {
                System.Console.Write(Environment.NewLine + ex.ToString());
            }

            Console.WriteLine(Environment.NewLine + "Getting folders information from IMAP server.");
        }
    private void DownloadFile(string msgSequenceNumber, string format)
    {
        try
        {
            // initialize imap client
            ImapClient client = new ImapClient();
            client.Host = txtHost.Text;
            client.Port = int.Parse(txtPort.Text);
            client.Username = txtUsername.Text;
            client.Password = Session["Password"].ToString();

            // SSL Settings
            if (chSSL.Checked == true)
            {
                client.EnableSsl = true;
                client.SecurityMode = ImapSslSecurityMode.Implicit;
            }

            // connect to imap server and login
            client.Connect(true);
            client.SelectFolder(ImapFolderInfo.InBox);
            lblMessage.ForeColor = Color.Green;
            lblMessage.Text = "Successfully connected to Imap Mail server.<br><hr>";

            // get the message
            MemoryStream stream = new MemoryStream();
            MailMessage msg = client.FetchMessage(int.Parse(msgSequenceNumber));
            if (format == "eml")
                msg.Save(stream, MessageFormat.Eml);
            else
                msg.Save(stream, MessageFormat.Msg);
            stream.Position = 0;
            byte[] msgBytes = new byte[stream.Length];
            stream.Read(msgBytes, 0, (int)stream.Length);

            client.Disconnect();

            Response.Clear();
            Response.Buffer = true;
            Response.AddHeader("Content-Length", msgBytes.Length.ToString());
            Response.AddHeader("Content-Disposition", "attachment; filename=Message." + format);
            Response.ContentType = "application/octet-stream";
            Response.BinaryWrite(msgBytes);
            Response.End();

        }
        catch (Exception ex)
        {
            lblMessage.ForeColor = Color.Red;
            lblMessage.Text = "Error: " + ex.Message;
        }
    }
        public static void Run()
        {
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_IMAP();
            string dstEmail = dataDir + "1234.eml";

            //Create an instance of the ImapClient class
            ImapClient client = new ImapClient();

            //Specify host, username and password for your client
            client.Host = "imap.gmail.com";

            // Set username
            client.Username = "******";

            // Set password
            client.Password = "******";

            // Set the port to 993. This is the SSL port of IMAP server
            client.Port = 993;

            // Enable SSL
            client.SecurityOptions = SecurityOptions.Auto;

            try
            {
                // The root folder (which will be created on disk) consists of host and username
                string rootFolder = client.Host + "-" + client.Username;
                // Create the root folder
                Directory.CreateDirectory(rootFolder);

                // List all the folders from IMAP server
                ImapFolderInfoCollection folderInfoCollection = client.ListFolders();
                foreach (ImapFolderInfo folderInfo in folderInfoCollection)
                {
                    // Call the recursive method to read messages and get sub-folders
                    ListMessagesInFolder(folderInfo, rootFolder, client);
                }


                //Disconnect to the remote IMAP server
                client.Disconnect();

            }
            catch (Exception ex)
            {
                System.Console.Write(Environment.NewLine + ex.ToString());
            }

            Console.WriteLine(Environment.NewLine + "Downloaded messages recursively from IMAP server.");
        }
        public static void Run()
        {
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_IMAP();
            string dstEmail = dataDir + "1234.eml";

            //Create an instance of the ImapClient class
            ImapClient client = new ImapClient();

            //Specify host, username and password for your client
            client.Host = "imap.gmail.com";

            // Set username
            client.Username = "******";

            // Set password
            client.Password = "******";

            // Set the port to 993. This is the SSL port of IMAP server
            client.Port = 993;

            // Enable SSL
            client.SecurityOptions = SecurityOptions.Auto;

            try
            {
                // Select the inbox folder
                client.SelectFolder(ImapFolderInfo.InBox);

                // Get the message info collection
                ImapMessageInfoCollection list = client.ListMessages();

                // Download each message
                for (int i = 0; i < list.Count; i++)
                {
                    //Save the EML file locally
                    client.SaveMessage(list[i].UniqueId, dataDir + list[i].UniqueId + ".eml");
                }

                //Disconnect to the remote IMAP server
                client.Disconnect();

            }
            catch (Exception ex)
            {
                System.Console.Write(Environment.NewLine + ex.ToString());
            }

            Console.WriteLine(Environment.NewLine + "Downloaded messages from IMAP server.");
        }
        public void GetAllMails(IProgress <MimeMessage> progress)
        {
            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();

                    var inbox = client.Inbox;
                    inbox.Open(FolderAccess.ReadOnly);
                    var results      = inbox.Search(SearchOptions.All, SearchQuery.DeliveredAfter(new DateTime(2019, 08, 01)));
                    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.");
                }
            }
            //return messages;
        }
Example #10
0
        public void TestThreadUidsBadCharsetFallback()
        {
            var badCharsetResponse = Encoding.ASCII.GetBytes("A00000005 NO [BADCHARSET (US-ASCII)] The specified charset is not supported.\r\n");

            var commands = new List <ImapReplayCommand> ();

            commands.Add(new ImapReplayCommand("", "dovecot.greeting.txt"));
            commands.Add(new ImapReplayCommand("A00000000 LOGIN username password\r\n", "dovecot.authenticate+gmail-capabilities.txt"));
            commands.Add(new ImapReplayCommand("A00000001 NAMESPACE\r\n", "dovecot.namespace.txt"));
            commands.Add(new ImapReplayCommand("A00000002 LIST \"\" \"INBOX\" RETURN (SUBSCRIBED CHILDREN)\r\n", "dovecot.list-inbox.txt"));
            commands.Add(new ImapReplayCommand("A00000003 LIST (SPECIAL-USE) \"\" \"*\" RETURN (SUBSCRIBED CHILDREN)\r\n", "dovecot.list-special-use.txt"));
            commands.Add(new ImapReplayCommand("A00000004 SELECT INBOX (CONDSTORE)\r\n", "common.select-inbox.txt"));
            commands.Add(new ImapReplayCommand(Encoding.UTF8, "A00000005 UID THREAD REFERENCES UTF-8 UID 1:* SUBJECT {12+}\r\nпривет\r\n", badCharsetResponse));
            commands.Add(new ImapReplayCommand("A00000006 UID THREAD REFERENCES US-ASCII UID 1:* SUBJECT {6+}\r\n?@825B\r\n", "dovecot.thread-references.txt"));

            using (var client = new ImapClient()) {
                var credentials = new NetworkCredential("username", "password");

                try {
                    client.ReplayConnect("localhost", new ImapReplayStream(commands, false));
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Connect: {0}", ex);
                }

                // Note: we do not want to use SASL at all...
                client.AuthenticationMechanisms.Clear();

                try {
                    client.Authenticate(credentials);
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Authenticate: {0}", ex);
                }

                Assert.IsInstanceOf <ImapEngine> (client.Inbox.SyncRoot, "SyncRoot");

                var inbox = (ImapFolder)client.Inbox;
                inbox.Open(FolderAccess.ReadWrite);

                var threaded = inbox.Thread(UniqueIdRange.All, ThreadingAlgorithm.References, SearchQuery.SubjectContains("привет"));
                Assert.AreEqual(2, threaded.Count, "Unexpected number of root nodes in threaded results");

                client.Disconnect(false);
            }
        }
Example #11
0
        public Task <List <Message> > PaerserEmailAsync(Setting setting, ISoapService soapService)
        {
            List <Message> messages = new List <Message>();

            using (var client = new ImapClient())
            {
                client.Connect(setting.ImapServer, setting.ImapPort, SecureSocketOptions.SslOnConnect);

                client.Authenticate(setting.InputMail, setting.InputMailPassword);

                client.Inbox.Open(FolderAccess.ReadWrite);

                var uids = client.Inbox.Search(SearchQuery.New);
                uids = client.Inbox.Search(SearchQuery.NotSeen);

                foreach (var uid in uids)
                {
                    var message = client.Inbox.GetMessage(uid);

                    if (message.Subject == setting.Subject)
                    {
                        var ItemRegex    = new Regex(setting.RegexMask, RegexOptions.Compiled);
                        var AllParamList = ItemRegex.Matches(message.TextBody)
                                           .Cast <Match>()
                                           .Select(m => new
                        {
                            Name  = m.Groups[1].ToString(),
                            Value = m.Groups[2].ToString()
                        })
                                           .ToList();
                        var paramList = AllParamList.Join(setting.ParamSettings, ap => ap.Name, cp => cp.FullName, (paramsetting, parammessage) => new ParamMessage {
                            Name = parammessage.Name, Value = paramsetting.Value
                        }).ToList();
                        var resultService = soapService.SendRequest(setting, paramList);
                        if (resultService == "sucsess")
                        {
                            client.Inbox.AddFlags(uid, MessageFlags.Seen, true);
                        }
                    }
                }
                client.Disconnect(true);
            }
            return(Task.Run(() => messages));;
        }
        public void TestSearchAnnotations()
        {
            var commands = CreateSearchAnnotationsCommands();

            using (var client = new ImapClient()) {
                var credentials = new NetworkCredential("username", "password");

                try {
                    client.ReplayConnect("localhost", new ImapReplayStream(commands, false));
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Connect: {0}", ex);
                }

                // Note: we do not want to use SASL at all...
                client.AuthenticationMechanisms.Clear();

                try {
                    client.Authenticate(credentials);
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Authenticate: {0}", ex);
                }

                Assert.IsInstanceOf <ImapEngine> (client.Inbox.SyncRoot, "SyncRoot");

                var inbox = (ImapFolder)client.Inbox;
                inbox.Open(FolderAccess.ReadWrite);

                Assert.AreEqual(AnnotationAccess.ReadOnly, inbox.AnnotationAccess, "AnnotationAccess");
                Assert.AreEqual(AnnotationScope.Both, inbox.AnnotationScopes, "AnnotationScopes");
                Assert.AreEqual(0, inbox.MaxAnnotationSize, "MaxAnnotationSize");

                var query = SearchQuery.AnnotationsContain(AnnotationEntry.Comment, AnnotationAttribute.Value, "a comment");
                var uids  = inbox.Search(query);

                Assert.AreEqual(14, uids.Count, "Unexpected number of UIDs");

                // disable ANNOTATE-EXPERIMENT-1 and try again
                client.Capabilities &= ~ImapCapabilities.Annotate;

                Assert.Throws <NotSupportedException> (() => inbox.Search(query));

                client.Disconnect(false);
            }
        }
        private static void AppendToFolder(ImapSettings settings, EmailCredentials credentials,
                                           MimeMessage emailMessage, string folder)
        {
            using (var imapClient = new ImapClient())
            {
                imapClient.Connect(settings.ImapHost, settings.ImapPort);
                imapClient.Authenticate(credentials.Email, credentials.Password);
                var personal   = imapClient.GetFolder(imapClient.PersonalNamespaces[0]);
                var sentFolder = personal.GetSubfolders()
                                 .FirstOrDefault(x => x.Name.ToLowerInvariant() == folder.ToLowerInvariant());
                if (sentFolder != null)
                {
                    sentFolder.Append(emailMessage);
                    sentFolder.Close();
                }

                imapClient.Disconnect(true);
            }
        }
 // This is where all the magic happens.
 void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
 {
     StatusBarText = "Connecting to server...";
     try
     {
         ImapClient ic = new ImapClient(ServerName, Username, Password, AuthMethods.Login, 993, true);
         ic.SelectMailbox("INBOX");
         Lazy <MailMessage>[] messages = ic.SearchMessages(SearchCondition.Unseen(), true, false);
         display.printNumber(messages.Length);
         StatusBarText = "Number of unread messages: " + messages.Length;
         ic.Disconnect();
         ic.Dispose();
     }
     catch (Exception ex)
     {
         StatusBarText = ex.Message;
         StopRunning();
     }
 }
Example #15
0
        private void UseImap()
        {
            using (var client = new ImapClient())
            {
                using (var cancel = new CancellationTokenSource())
                {
                    //client.Timeout = 200000;
                    client.Connect("imap.test.com", 143, SecureSocketOptions.None, cancel.Token);

                    // If you want to disable an authentication mechanism,
                    // you can do so by removing the mechanism like this:no
                    client.AuthenticationMechanisms.Remove("XOAUTH");

                    client.Authenticate("*****@*****.**", "password", cancel.Token);

                    // The Inbox folder is always available...
                    var inbox = client.Inbox;
                    inbox.Open(FolderAccess.ReadOnly, cancel.Token);

                    lblerror.Text  = string.Format("Total messages: {0}", inbox.Count);
                    lblerror.Text += string.Format("<br />Recent messages: {0}", inbox.Recent);

                    // download each message based on the message index
                    //for (int i = 0; i < inbox.Count; i++)
                    //{
                    //    var message = inbox.GetMessage(i, cancel.Token);
                    //    Console.WriteLine("Subject: {0}", message.Subject);
                    //}

                    //// let's try searching for some messages...

                    //var query = SearchQuery.BodyContains(txttitle.Text).And(SearchQuery.BodyContains(txtToAddress.Text));

                    //foreach (var uid in inbox.Search(query, cancel.Token))
                    //{
                    //    var message = inbox.GetMessage(uid, cancel.Token);
                    //    lblerror.Text += string.Format("<br /> [match] {0}: {1}", uid, message.Subject);
                    //}

                    client.Disconnect(true, cancel.Token);
                }
            }
        }
Example #16
0
 public static void Main(string[] args)
 {
     using (var client = new ImapClient()) {
         var credentials = new NetworkCredential("*****@*****.**", "xxx");
         var uri         = new Uri("imaps://imap-mail.outlook.com");
         using (var cancel = new CancellationTokenSource()) {
             client.Connect(uri, cancel.Token);
             client.Authenticate(credentials, cancel.Token);
             // Open the Inbox folder
             client.Inbox.Open(FolderAccess.ReadOnly, cancel.Token);
             var query = SearchQuery.FromContains("*****@*****.**");
             foreach (var uid in client.Inbox.Search(query, cancel.Token))
             {
                 var message = client.Inbox.GetMessage(uid, cancel.Token);
             }
             client.Disconnect(true, cancel.Token);
         }
     }
 }
 public static void Main(string[] args)
 {
     using (var client = new ImapClient()) {
         var credentials = new NetworkCredential("joey", "password");
         var uri         = new Uri("imaps://imap.gmail.com");
         using (var cancel = new CancellationTokenSource()) {
             client.Connect(uri, cancel.Token);
             // If you want to disable an authentication mechanism,
             // you can do so by removing the mechanism like this:
             client.AuthenticationMechanisms.Remove("XOAUTH");
             client.Authenticate(credentials, cancel.Token);
             // The Inbox folder is always available...
             var inbox = client.Inbox;
             inbox.Open(FolderAccess.ReadOnly, cancel.Token);
             Console.WriteLine("Total messages: {0}", inbox.Count);
             Console.WriteLine("Recent messages: {0}", inbox.Recent);
             // download each message based on the message index
             for (int i = 0; i < inbox.Count; i++)
             {
                 var message = inbox.GetMessage(i, cancel.Token);
                 Console.WriteLine("Subject: {0}", message.Subject);
             }
             // download them in reverse order...
             var orderBy = new [] { OrderBy.ReverseArrival };
             foreach (var uid in inbox.Search(SearchQuery.All, orderBy, cancel.Token))
             {
                 var message = inbox.GetMessage(i, cancel.Token);
                 Console.WriteLine("Subject: {0}", message.Subject);
             }
             // let's try searching for some messages...
             var query = SearchQuery.DeliveredAfter(DateTime.Parse("2013-01-12"))
                         .And(SearchQuery.SubjectContains("MailKit"))
                         .And(SearchQuery.Seen);
             foreach (var uid in inbox.Search(query, cancel.Token))
             {
                 var message = inbox.GetMessage(uid, cancel.Token);
                 Console.WriteLine("[match] {0}: {1}", uid, message.Subject);
             }
             client.Disconnect(true, cancel.Token);
         }
     }
 }
Example #18
0
        private void button5_Click(object sender, EventArgs e)
        {
            try
            {
                using (var client = new ImapClient())
                {
                    var port = Convert.ToInt32(textBox7.Text);
                    //MessageBox.Show(port.ToString());

                    client.ServerCertificateValidationCallback = (s, c, h, r) => true;
                    client.AuthenticationMechanisms.Remove("XOAUTH2");
                    client.Connect(textBox2.Text, port, true);

                    client.Authenticate(textBox3.Text, textBox4.Text);
                    client.Disconnect(true);
                }

                MessageBox.Show("Połącznie ustanowione!");

                label14.ForeColor = System.Drawing.Color.ForestGreen;
                label14.Text      = "OK!";

                button4.Enabled   = true;
                button4.ForeColor = System.Drawing.Color.ForestGreen;

                label12.BackColor = System.Drawing.Color.Lime;
                label12.ForeColor = System.Drawing.Color.Lime;

                button1.Enabled = true;
                button2.Enabled = true;
                button3.Enabled = true;
            }
            catch (Exception ex) {
                MessageBox.Show("Połącznie nieudane!");

                label14.ForeColor = System.Drawing.Color.Maroon;
                label14.Text      = "BŁĄD!";

                label12.BackColor = System.Drawing.Color.Red;
                label12.ForeColor = System.Drawing.Color.Red;
            }
        }
Example #19
0
        public bool ProcessEmails(JobType jobType)
        {
            List <IEmailDerivative> derivativesList = new List <IEmailDerivative>();

            using (var client = new ImapClient())
            {
                client.Connect(mailServer, port, ssl);
                client.AuthenticationMechanisms.Remove("XOAUTH2");
                client.Authenticate(login, password);
                client.Inbox.Open(FolderAccess.ReadOnly);

                int d = 0;
                foreach (UniqueId uid in client.Inbox.Search(_searchQueries[jobType]))
                {
                    MimeMessage mm = client.Inbox.GetMessage(uid);
                    //if (mm.HtmlBody.IndexOf("localhost") == -1) // remove this line if necessary
                    //{
                    if (ConfigurationProvider.TestMode)
                    {
                        Logger.AddMessageToLog(mm);
                    }
                    try
                    {
                        IEmailDerivative emailDerivative = ProduceEmailDerivative(mm, jobType);
                        if (emailDerivative != null)
                        {
                            derivativesList.Add(emailDerivative);
                            Console.WriteLine("{0}", ++d);
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.ToString());
                    }
                    //}
                }
                client.Disconnect(true);
            }

            //return DbProvider.Synchronize(derivativesList);
            return(DbProvider.ProduceUpdatesList(derivativesList));
        }
        /// <summary>
        /// Gets all email as an enumerable collection of MailModel
        /// </summary>
        /// <returns>Enumerable collection of MailModels</returns>
        public IEnumerable <MailModel> GetAllMails()
        {
            var mails = new List <MailModel>();

            using (var client = new ImapClient())
            {
                client.Connect(mailServer, port, ssl);

                // Note: since we don't have an OAuth2 token, disable
                // the XOAUTH2 authentication mechanism.
                client.AuthenticationMechanisms.Remove("XOAUTH2");

                try
                {
                    client.Authenticate(login, password);

                    // The Inbox folder is always available on all IMAP servers...
                    var inbox = client.Inbox;
                    inbox.Open(FolderAccess.ReadOnly);
                    var results = inbox.Search(SearchQuery.All);
                    foreach (var uniqueId in results)
                    {
                        MimeMessage t = inbox.GetMessage(uniqueId);

                        var mail = new MailModel(t, uniqueId);

                        mails.Add(mail);

                        //Mark message as read
                        //inbox.AddFlags(uniqueId, MessageFlags.Seen, true);
                    }

                    client.Disconnect(true);
                }
                catch (AuthenticationException)
                {
                    AreCredentialsCorrect = false;
                }
            }

            return(mails);
        }
        public static void Run()
        {
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_IMAP();
            string dstEmail = dataDir + "1234.eml";

            //Create an instance of the ImapClient class
            ImapClient client = new ImapClient();

            //Specify host, username and password for your client
            client.Host = "imap.gmail.com";

            // Set username
            client.Username = "******";

            // Set password
            client.Password = "******";

            // Set the port to 993. This is the SSL port of IMAP server
            client.Port = 993;

            // Enable SSL
            client.SecurityOptions = SecurityOptions.Auto;

            try
            {
                System.Console.WriteLine("Logged in to the IMAP server");

                // Mark the message as read
                client.RemoveMessageFlags(1, Aspose.Email.Imap.ImapMessageFlags.IsRead);

                //Disconnect to the remote IMAP server
                client.Disconnect();

            }
            catch (Exception ex)
            {
                System.Console.Write(Environment.NewLine + ex.ToString());
            }

            Console.WriteLine(Environment.NewLine + "Removed message flags from IMAP server.");
        }
Example #22
0
        ///////////////////////////////////////////////////

        private bool Connect()
        {
            if (imap_client != null)
            {
                imap_client.Disconnect();
            }
            imap_client = null;
            bool success = false;

            try {
                imap_client            = new ImapClient();
                imap_client.AuthMethod = AUTH_METHOD;
                imap_client.Port       = PORT;
                imap_client.Ssl        = USE_SSL;
                imap_client.Connect(GMAIL_SERVER);

                success = imap_client.Login(username, password);

                if (!success)
                {
                    Log.Error("IMAP connection unsuccessful: {0}", imap_client.LastError);
                }
                else
                {
                    Mailbox search_mailbox = imap_client.SelectMailbox(search_folder);
                    success = (search_mailbox != null);
                    if (!success)
                    {
                        Log.Error("Selection folder unsuccessful: {0}", imap_client.LastError);
                    }
                }
            } catch (Exception e) {
                Log.Error(e, "GMailSearchDriver: Error in connecting to {0} with username {1}", GMAIL_SERVER, username);
            }

            if (!success && imap_client != null)
            {
                imap_client.Disconnect();
            }

            return(success);
        }
Example #23
0
        /// <summary>
        /// IMAP接收邮件
        /// </summary>
        /// <param name="FromAccount">邮箱账户</param>
        /// <param name="FromPassword">邮箱密码</param>
        /// <returns></returns>
        public static IList <ReceiveEmailModel> ReceiveImapEmail(string FromAccount, string FromPassword)
        {
            List <ReceiveEmailModel> receiveEmailList = new List <ReceiveEmailModel>();

            using (var client = new ImapClient())
            {
                // For demo-purposes, accept all SSL certificates
                client.ServerCertificateValidationCallback = (s, c, h, e) => true;

                client.Connect(ImapServer, ImapPort, true);

                client.Authenticate(FromAccount, FromPassword);

                // The Inbox folder is always available on all IMAP servers...
                var 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++)
                {
                    var message = inbox.GetMessage(i);

                    ReceiveEmailModel receiveEmailModel = new ReceiveEmailModel();

                    receiveEmailModel.FromAddress = message.From[0].Name;

                    receiveEmailModel.Date = message.Date.DateTime;

                    receiveEmailModel.Subject = message.Subject;

                    receiveEmailModel.Body = message.TextBody;

                    receiveEmailList.Add(receiveEmailModel);
                }
                client.Disconnect(true);
            }
            return(receiveEmailList);
        }
Example #24
0
        public async Task DownloadMessages(User user, ConfigModel conf, MailWindow inboxPage, string Folder = null)
        {
            using (ImapClient client = new ImapClient())
            {
                if (load < 10)
                {
                    load = ActualSettings.Actual.DefaultLoadValue;
                }
                await client.ConnectAsync(conf.ImapServer, conf.ImapPort);

                client.Authenticate(user.Mail, user.Password);
                List <int> uids   = new List <int>();
                var        folder = GetFold(client, Folder);
                if (Folder != null)
                {
                    fold = Folder;
                }
                else
                {
                    Folder = fold;
                }
                await folder.OpenAsync(MailKit.FolderAccess.ReadOnly);

                List <IMessageSummary> InfoReverse = new List <IMessageSummary>();
                string ENDToken = null;
                if (folder.Count < load + loaded)
                {
                    load     = folder.Count - loaded;
                    ENDToken = "END";
                }

                for (int i = folder.Count - (loaded == 0 ? 1 : loaded); i >= folder.Count - (load == 1 ? 1: (loaded + load - 1)); i--)
                {
                    IList <IMessageSummary> info = await folder.FetchAsync(new[] { i }, MessageSummaryItems.Envelope | MessageSummaryItems.Flags | MessageSummaryItems.UniqueId);

                    InfoReverse.Add(info.First());
                }
                ShowMessages(InfoReverse, inboxPage, ENDToken);

                client.Disconnect(true);
            }
        }
Example #25
0
        private void imapTestButton_Click(object sender, EventArgs e)
        {
            logger.Info("Testing IMAP connection...");

            using (ImapClient client = smtpLoggingEnabledCheckBox.Checked && smtpLoggingFileTextBox.Text.Length > 0 ? new ImapClient(new ProtocolLogger(smtpLoggingFileTextBox.Text)) : new ImapClient())
            {
                client.Timeout = Decimal.ToInt32(smtpNetworkTimeoutNumericUpDown.Value) * 1000;
                client.ServerCertificateValidationCallback = NoSslCertificateValidationCallback;

                try
                {
                    if (imapSSLCheckBox.Checked)
                    {
                        client.Connect(imapHostTextBox.Text, Decimal.ToInt32(imapPortTextBox.Value), MailKit.Security.SecureSocketOptions.Auto);
                    }
                    else
                    {
                        client.Connect(imapHostTextBox.Text, Decimal.ToInt32(imapPortTextBox.Value), false);
                    }

                    if (imapLoginPasswordTextBox.Text.Length > 0)
                    {
                        client.Authenticate(imapLoginUsernameTextBox.Text, imapLoginPasswordTextBox.Text);
                    }

                    MailKit.IMailFolder inbox = client.Inbox;
                    inbox.Open(MailKit.FolderAccess.ReadOnly);

                    logger.Info("IMAP Test OK, inbox message count: " + inbox.Count);
                    MessageBox.Show(this, "IMAP Test OK, inbox message count: " + inbox.Count, "IMAP Test", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                catch (Exception ex)
                {
                    logger.Error("IMAP Test failed", ex);
                    MessageBox.Show(this, "IMAP Test failed: " + ex.Message, "IMAP Test", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                finally
                {
                    client.Disconnect(true);
                }
            }
        }
Example #26
0
        public async Task <IEnumerable <InboxDetail> > GetAllMailFolders()
        {
            var result = new List <InboxDetail>();

            using var client = new ImapClient(_protoLog);
            await ConnectToClient(client);

            var folders = await client.GetFoldersAsync(new FolderNamespace('.', ""), false);

            foreach (var folder in folders)
            {
                var whatIsThis = await folder.OpenAsync(FolderAccess.ReadOnly);

                result.Add(BuildInboxDetail(folder, whatIsThis));
            }

            client.Disconnect(true);

            return(result);
        }
Example #27
0
        public MailInfo GetMailById(MailInfo mailInfo)
        {
            using (ImapClient client = new ImapClient())
            {
                client.Connect(mailServer, port, ssl);
                client.AuthenticationMechanisms.Remove("XOAUTH2");
                client.Authenticate(UserData.Email, UserData.Password);

                IMailFolder folder = client.GetFolder(mailInfo.ParentFolder.FullName);
                folder.Open(FolderAccess.ReadOnly);
                var results = folder.Search(SearchQuery.Uids(new List <UniqueId> {
                    mailInfo.Uid
                }));

                MailInfo message = new MailInfo(folder.GetMessage(results[0]), results[0], folder);

                client.Disconnect(true);
                return(message);
            }
        }
Example #28
0
 public static HashSet <string> UpdateListContact(string mail, string passward, HashSet <string> contactList)
 {
     using (var client = new ImapClient())
     {
         client.Connect("imap.gmail.com", 993, true);
         client.AuthenticationMechanisms.Remove("XOAUTH2");
         client.AuthenticationMechanisms.Remove("XOAUTH2");
         client.Authenticate(mail, passward);
         client.Inbox.Open(FolderAccess.ReadWrite);
         var uids     = client.Inbox.Search(SearchQuery.HasGMailLabel("unread"));
         var messages = client.Inbox.Fetch(uids, MessageSummaryItems.BodyStructure | MessageSummaryItems.UniqueId | MessageSummaryItems.Full);
         foreach (var messag in messages)
         {
             var message = client.Inbox.GetMessage(messag.UniqueId);
             contactList.Add(message.Sender.Address.ToString());
         }
         client.Disconnect(true);
         return(contactList);
     }
 }
Example #29
0
        public static void Main(string[] args)
        {
            using (var client = new ImapClient(new ProtocolLogger(Console.OpenStandardOutput()))) {
                // For demo-purposes, accept all SSL certificates
                client.ServerCertificateValidationCallback = (s, c, h, e) => true;

                client.Connect("imap.gmail.com", 993, true);

                // Note: since we don't have an OAuth2 token, disable
                // the XOAUTH2 authentication mechanism.
                client.AuthenticationMechanisms.Remove("XOAUTH2");

                client.Authenticate("*****@*****.**", "xxx");

                client.Inbox.Open(FolderAccess.ReadOnly);
                client.Inbox.Search(SearchQuery.SubjectContains("سلام"));

                client.Disconnect(true);
            }
        }
        public static void Run()
        {
            // The path to the documents directory.
            string dataDir  = RunExamples.GetDataDir_IMAP();
            string dstEmail = dataDir + "1234.eml";

            //Create an instance of the ImapClient class
            ImapClient client = new ImapClient();

            //Specify host, username and password for your client
            client.Host = "imap.gmail.com";

            // Set username
            client.Username = "******";

            // Set password
            client.Password = "******";

            // Set the port to 993. This is the SSL port of IMAP server
            client.Port = 993;

            // Enable SSL
            client.SecurityOptions = SecurityOptions.Auto;

            try
            {
                System.Console.WriteLine("Logged in to the IMAP server");

                // Mark the message as read
                client.ChangeMessageFlags(1, Aspose.Email.Imap.ImapMessageFlags.IsRead);

                //Disconnect to the remote IMAP server
                client.Disconnect();
            }
            catch (Exception ex)
            {
                System.Console.Write(Environment.NewLine + ex.ToString());
            }

            Console.WriteLine(Environment.NewLine + "Set message flags from IMAP server.");
        }
Example #31
0
		public void TestAppendWithAnnotations (bool withInternalDates)
		{
			var expectedFlags = MessageFlags.Answered | MessageFlags.Flagged | MessageFlags.Deleted | MessageFlags.Seen | MessageFlags.Draft;
			var expectedPermanentFlags = expectedFlags | MessageFlags.UserDefined;
			List<DateTimeOffset> internalDates;
			List<Annotation> annotations;
			List<MimeMessage> messages;
			List<MessageFlags> flags;

			var commands = CreateAppendWithAnnotationsCommands (withInternalDates, out messages, out flags, out internalDates, out annotations);

			using (var client = new ImapClient ()) {
				try {
					client.ReplayConnect ("localhost", new ImapReplayStream (commands, false));
				} catch (Exception ex) {
					Assert.Fail ("Did not expect an exception in Connect: {0}", ex);
				}

				client.AuthenticationMechanisms.Clear ();

				try {
					client.Authenticate ("username", "password");
				} catch (Exception ex) {
					Assert.Fail ("Did not expect an exception in Authenticate: {0}", ex);
				}

				for (int i = 0; i < messages.Count; i++) {
					UniqueId? uid;

					if (withInternalDates)
						uid = client.Inbox.Append (messages[i], flags[i], internalDates[i], new [] { annotations[i] });
					else
						uid = client.Inbox.Append (messages[i], flags[i], null, new [] { annotations[i] });

					Assert.IsTrue (uid.HasValue, "Expected a UIDAPPEND resp-code");
					Assert.AreEqual (i + 1, uid.Value.Id, "Unexpected UID");
				}

				client.Disconnect (true);
			}
		}
        private void checkGmailBtn_Click(object sender, EventArgs e)
        {
            if (usernameTb.Text != "" && passwordTb.Text != "")
            {
                using (ImapClient imapClient = new ImapClient())
                {
                    try
                    {
                        imapClient.Connect("imap.gmail.com", 993, true);
                        imapClient.AuthenticationMechanisms.Remove("XOAUTH2");
                        imapClient.Authenticate(usernameTb.Text, passwordTb.Text);

                        var inbox = imapClient.Inbox;
                        inbox.Open(FolderAccess.ReadWrite);


                        imapClient.Disconnect(true);
                        MessageBox.Show("Gmail Setup Correctly");
                        gmailOK = true;
                    }
                    catch (Exception exception)
                    {
                        if (exception.Message.Contains("Authentication failed"))
                        {
                            MessageBox.Show("Authentication failed");
                        }

                        if (exception.Message.Contains("Please log in via your web browser"))
                        {
                            MessageBox.Show("You have Not setup Your Account.");
                        }

                        Console.WriteLine(exception);
                    }
                }
            }
            else
            {
                MessageBox.Show("You are missing some Gmail Data");
            }
        }
Example #33
0
        public void TestSelectAnnotateNone()
        {
            var commands = new List <ImapReplayCommand> ();

            commands.Add(new ImapReplayCommand("", "dovecot.greeting.txt"));
            commands.Add(new ImapReplayCommand("A00000000 LOGIN username password\r\n", "dovecot.authenticate+annotate.txt"));
            commands.Add(new ImapReplayCommand("A00000001 NAMESPACE\r\n", "dovecot.namespace.txt"));
            commands.Add(new ImapReplayCommand("A00000002 LIST \"\" \"INBOX\" RETURN (SUBSCRIBED CHILDREN)\r\n", "dovecot.list-inbox.txt"));
            commands.Add(new ImapReplayCommand("A00000003 LIST (SPECIAL-USE) \"\" \"*\" RETURN (SUBSCRIBED CHILDREN)\r\n", "dovecot.list-special-use.txt"));
            commands.Add(new ImapReplayCommand("A00000004 SELECT INBOX (CONDSTORE ANNOTATE)\r\n", "common.select-inbox-annotate-none.txt"));

            using (var client = new ImapClient()) {
                var credentials = new NetworkCredential("username", "password");

                try {
                    client.ReplayConnect("localhost", new ImapReplayStream(commands, false));
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Connect: {0}", ex);
                }

                // Note: we do not want to use SASL at all...
                client.AuthenticationMechanisms.Clear();

                try {
                    client.Authenticate(credentials);
                } catch (Exception ex) {
                    Assert.Fail("Did not expect an exception in Authenticate: {0}", ex);
                }

                Assert.IsInstanceOf <ImapEngine> (client.Inbox.SyncRoot, "SyncRoot");

                var inbox = (ImapFolder)client.Inbox;
                inbox.Open(FolderAccess.ReadWrite);

                Assert.AreEqual(AnnotationAccess.None, inbox.AnnotationAccess, "AnnotationAccess");
                Assert.AreEqual(AnnotationScope.None, inbox.AnnotationScopes, "AnnotationScopes");
                Assert.AreEqual(0, inbox.MaxAnnotationSize, "MaxAnnotationSize");

                client.Disconnect(false);
            }
        }
Example #34
0
        /// <summary>
        /// Move Messages with MimeKit, works with outlook, but not gmail
        /// </summary>
        public void moveInboxMessages()
        {
            using (var client = new ImapClient())
            {
                client.Connect(Constant.GoogleImapHost, Constant.ImapPort, SecureSocketOptions.SslOnConnect);
                client.Authenticate(Constant.GoogleUserName, Constant.GenericPassword);


                FolderAccess     inboxAccess = client.Inbox.Open(FolderAccess.ReadWrite);
                IMailFolder      destination = client.GetFolder(Constant.ProcessedFolder);
                IList <UniqueId> uids        = client.Inbox.Search(SearchQuery.All);

                if (destination != null && uids.Count > 0)
                {
                    client.Inbox.MoveTo(uids, destination);
                    Console.WriteLine("Moved Messages");
                }

                client.Disconnect(true);
            }
        }
Example #35
0
        private static bool CheckBackup()
        {
            var isOk = false;

            using (var client = new ImapClient()) {
                client.Connect("imap.gmail.com", 993, true);

                client.Authenticate(_config["Email"], _config["Password"]);

                var backupFolder = client.GetFolder("Backup");
                backupFolder.Open(FolderAccess.ReadOnly);

                var query = SearchQuery.DeliveredAfter(DateTime.Now.Date).And(SearchQuery.SubjectContains("CloudBerry Backup completed"));

                isOk = backupFolder.Search(query).Count > 0;

                client.Disconnect(true);
            }

            return(isOk);
        }
Example #36
0
        public void SaveToFile()
        {
            imap.Disconnect(true);
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
            int i  = 1;
            var sb = new StringBuilder(path);

            foreach (var item in unSorted)
            {
                sb.Append("\\msg").Append(i).Append(".eml");
                item.WriteTo(sb.ToString());
                i++;
                sb.Clear();
                sb.Append(path);
            }
            Settings.Default.isSaved = true;
            Settings.Default.Save();
        }
Example #37
0
 public bool IsLoginSuccessfullyAuth()
 {
     using (ImapClient client = new ImapClient())
     {
         try
         {
             client.Connect(mailServer, port, ssl);
             client.AuthenticationMechanisms.Remove("XOAUTH2");
             client.Authenticate(UserData.Email, UserData.Password);
             return(true);
         }
         catch (AuthenticationException)
         {
             return(false);
         }
         finally
         {
             client.Disconnect(true);
         }
     }
 }
Example #38
0
        public FolderInfo GetFolderByName(string name)
        {
            using (ImapClient client = new ImapClient())
            {
                client.Connect(mailServer, port, ssl);
                client.AuthenticationMechanisms.Remove("XOAUTH2");
                client.Authenticate(UserData.Email, UserData.Password);

                var folders = client.GetFolders(new FolderNamespace('/', ""));
                foreach (var folder in folders)
                {
                    if (folder.Name.Equals(name))
                    {
                        FolderInfo folderInfo = new FolderInfo(folder, folder.Count);
                        return(folderInfo);
                    }
                }
                client.Disconnect(true);
                return(null);
            }
        }
        public static void Run()
        {
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_IMAP();
            string dstEmail = dataDir + "1234.eml";

            //Create an instance of the ImapClient class
            ImapClient client = new ImapClient();

            //Specify host, username and password for your client
            client.Host = "imap.gmail.com";

            // Set username
            client.Username = "******";

            // Set password
            client.Password = "******";

            // Set the port to 993. This is the SSL port of IMAP server
            client.Port = 993;

            // Enable SSL
            client.SecurityOptions = SecurityOptions.Auto;

            try
            {
                // Rename a folder
                client.DeleteFolder("Client");

                //Disconnect to the remote IMAP server
                client.Disconnect();

            }
            catch (Exception ex)
            {
                System.Console.Write(Environment.NewLine + ex.ToString());
            } 

            Console.WriteLine(Environment.NewLine + "Deleted folders on IMAP server.");
        }
        public static List <string> GetInboxMessages()
        {
            List <string> Messages = new List <string>();

            using (var client = new ImapClient())
            {
                // For demo-purposes, accept all SSL certificates
                client.ServerCertificateValidationCallback = (s, c, h, e) => true;

                client.Connect("imap.gmail.com", 993, true);

                // Note: since we don't have an OAuth2 token, disable
                // the XOAUTH2 authentication mechanism.
                client.AuthenticationMechanisms.Remove("XOAUTH2");

                client.Authenticate(SendEmailMIMEKIT.selfUserName, SendEmailMIMEKIT.selfKeyWord);

                // The Inbox folder is always available on all IMAP servers...
                var inbox = client.Inbox;
                inbox.Open(FolderAccess.ReadOnly);

                Console.WriteLine("Total messages: {0}", inbox.Count);
                Console.WriteLine("Recent messages: {0}", inbox.Recent);

                Messages.Add(inbox.Count.ToString());
                Messages.Add(inbox.Recent.ToString());

                for (int i = 0; i < inbox.Count; i++)
                {
                    var message = inbox.GetMessage(i);
                    //Serialize.serialize(message);
                    Console.WriteLine("Subject: {0}", message.Subject);
                    Messages.Add(message.Subject);
                }

                client.Disconnect(true);

                return(Messages);
            }
        }
    private void ListMessages()
    {
        lblMessage.Text = "";

        try
        {
            // initialize imap client
            ImapClient client = new ImapClient();
            client.Host = txtHost.Text;
            client.Port = int.Parse(txtPort.Text);
            client.Username = txtUsername.Text;
            client.Password = txtPassword.Text;

            // SSL Settings
            if (chSSL.Checked == true)
            {
                client.EnableSsl = true;
                client.SecurityMode = ImapSslSecurityMode.Implicit;
            }

            // connect to imap server and login
            client.Connect(true);
            lblMessage.Text = "Successfully connected to IMAP Mail server.<br><hr>";

            client.SelectFolder("inbox");

            // get list of messages
            ImapMessageInfoCollection msgCollection = client.ListMessages();
            gvMessages.DataSource = msgCollection;
            gvMessages.DataBind();

            client.Disconnect();
        }
        catch (Exception ex)
        {
            lblMessage.ForeColor = Color.Red;
            lblMessage.Text = "Error: " + ex.Message;
        }
    }
    protected void brnSendEmail_Click(object sender, EventArgs e)
    {
        lblMessage.Text = "";

        try
        {
            // initialize imap client
            ImapClient client = new ImapClient();
            client.Host = txtHost.Text;
            client.Port = int.Parse(txtPort.Text);
            client.Username = txtUsername.Text;
            client.Password = txtPassword.Text;

            // SSL Settings
            if (chSSL.Checked == true)
            {
                client.EnableSsl = true;
                client.SecurityMode = ImapSslSecurityMode.Implicit;
            }

            // connect to imap server and login
            client.Connect(true);
            lblMessage.Text = "Successfully connected to IMAP Mail server.<br><hr>";

            // get folders information
            ImapFolderInfoCollection folderInfoColl = client.ListFolders();
            gvFolders.DataSource = folderInfoColl;
            gvFolders.DataBind();

            //  disconnect from imap server
            client.Disconnect();
        }
        catch (Exception ex)
        {
            lblMessage.ForeColor = Color.Red;
            lblMessage.Text = "Error: " + ex.Message;
        }
    }
    private void ChangeReadStatus(string msgSequenceNumber, string status)
    {
        try
        {
            // initialize imap client
            ImapClient client = new ImapClient();
            client.Host = txtHost.Text;
            client.Port = int.Parse(txtPort.Text);
            client.Username = txtUsername.Text;
            client.Password = Session["Password"].ToString();

            // SSL Settings
            if (chSSL.Checked == true)
            {
                client.EnableSsl = true;
                client.SecurityMode = ImapSslSecurityMode.Implicit;
            }

            // connect to imap server and login
            client.Connect(true);
            client.SelectFolder(ImapFolderInfo.InBox);
            lblMessage.ForeColor = Color.Green;
            lblMessage.Text = "Successfully connected to Imap Mail server.<br><hr>";

            // change the message status
            if (status == "1") // mark as read
                client.AddMessageFlags(int.Parse(msgSequenceNumber), ImapMessageFlags.IsRead);
            else // mark as un-read
                client.RemoveMessageFlags(int.Parse(msgSequenceNumber), ImapMessageFlags.IsRead);

            client.Disconnect();
        }
        catch (Exception ex)
        {
            lblMessage.ForeColor = Color.Red;
            lblMessage.Text = "Error: " + ex.Message;
        }
    }
Example #44
0
        /// <summary>
        /// Searches the ac
        /// </summary>
        /// <param name="searchCriteria"></param>
        /// <param name="processMessages"></param>
        /// <returns></returns>
        public IEnumerable<IEmail> Search(EmailSearchCriteria searchCriteria, bool processMessages = true)
        {
            // create client
            var client = new ImapClient(_host, _port, _useSsl);

            // connect to host
            if (!client.Connection())
                throw new ImapException(string.Format("Failed to connect to server {0}", _host));

            // create result list
            var results = new List<IEmail>();

            try
            {
                // try to log in
                if (!client.LogIn(_userName, _password))
                    throw new LogInException(_host, _userName);

                // search either a single folder or all folders
                var folders = string.IsNullOrWhiteSpace(searchCriteria.Folder)
                                  ? (IEnumerable<Folder>)client.Folders
                                  : new[] {client.Folders[searchCriteria.Folder]};

                // search folders
                foreach (var folder in folders)
                {
                    // if folder is null, it was specified by name and not found
                    if (folder == null) throw new FolderNotFoundException(_host, _userName, searchCriteria.Folder);

                    // add results of search
                    results.AddRange(SearchFolder(folder, searchCriteria));
                }

                // download messages if indicated
                if (processMessages) results.ForEach(m => m.Download());
            }
            finally
            {
                // disconnect after search is done
                client.Disconnect();
            }

            return results;
        }