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;
        }
    }
Beispiel #2
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;
        }
 internal bool GmailAuthenticate(string username, string password)
 {
     var client = new ImapClient("imap.gmail.com", 993, true, true);
     client.Connect();
     bool result = client.Login(username,password);
     if (result) return true;
     else return false;
 }
    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;
            }
        }
    }
 /// <summary>
 /// Connects to the imap server.
 /// </summary>
 /// <param name="login">Login credidentials containing username and password of user</param>
 /// <param name="server">Server address to connect to</param>
 public void Connect(LoginCred login, string server)
 {
     imapc = new ImapClient(server, true);
       if (imapc.Connect())
     if (imapc.Login(login.Username, login.Password))
     {
       blnConnected = true;
       imapc.Behavior.AutoPopulateFolderMessages = true;
     }
 }
Beispiel #6
0
        //http://imapx.codeplex.com/documentation
        static void Main(string[] args)
        {
            // ApplicationTrustPolicy.TrustAll();

            string credientials = ConfigurationManager.AppSettings["credentials"];
            string imap_server = ConfigurationManager.AppSettings["imap_server"];
            string logfilename = ConfigurationManager.AppSettings["log"];
            string output_dir = ConfigurationManager.AppSettings["output_dir"];
            string email_folder = ConfigurationManager.AppSettings["email_folder"];

            var client = new ImapClient(imap_server, true,false);

            if (logfilename != null)
            {
                Logger.EnableLogger();
                Logger.WriteLine("logging to '" + logfilename + "'");
                Debug.Listeners.Add(new TextWriterTraceListener(logfilename));
                Debug.AutoFlush = true;
                client.IsDebug = true;
            }

            var files = Directory.GetFiles(credientials, "*.*");
            var user =  Path.GetFileName(files[0]);
            var pass = File.ReadAllLines(files[0])[0];
            Logger.WriteLine("about to connect:");
            if (client.Connect())
            {

                if (client.Login(user,pass))
                {
                    // login successful
                    Console.WriteLine("ok");
                    Logger.WriteLine("listing labels...");
                    foreach (var item in client.Folders)
                    {
                        Logger.WriteLine(item.Name);
                    }

                    var folder = client.Folders[email_folder];
                   folder.Messages.Download("UNSEEN", MessageFetchMode.Basic | MessageFetchMode.GMailExtendedData, 72);
                   var s = GetSerieData(folder);
                    var cbtt = "mpci";
                    var pcode="qp2";

                    string fn = "instant_" + cbtt + "_" + pcode + "_" + DateTime.Now.ToString("MMMdyyyyHHmmssfff") + ".txt";
                    fn = Path.Combine(output_dir, fn);
                   HydrometInstantSeries.WriteToHydrometFile(s, cbtt, pcode, "hydromet", fn);
                }
            }
            else
            {
                Logger.WriteLine("connection not successful");
            }
        }
    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;
        }
    }
Beispiel #8
0
        private static bool Connect(ImapClient client)
        {
            if (client.Connect())
            {
                //if (client.Login(MailLogin, MailPassword))
                if (client.Login("*****@*****.**", "1597534682"))
                {
                    return true;
                }
            }

            return false;
        }
Beispiel #9
0
        public void Check_ForUnseenMails()
        {
            try
            {
                //Connect
                Status = MainForm.myIni.Get_LanguageValue("messages", "connect_to").Replace("%1", Host);
                ImapClient myImapClient = new ImapClient(Host, Port, Username, Password, UseSsl, !UseSsl, ImapClient.AuthMethods.Login);
                try
                {
                    myImapClient.Connect();
                }
                catch
                {
                    Status = MainForm.myIni.Get_LanguageValue("messages", "host_unavailable").Replace("%1", Host);
                    return;
                }

                //Login
                try
                {
                    myImapClient.Login();
                }
                catch
                {
                    Status = MainForm.myIni.Get_LanguageValue("messages", "login_failed").Replace("%1", Host);
                    return;
                }

                //Retrieve unseen messages
                Status = MainForm.myIni.Get_LanguageValue("messages", "checking_mails").Replace("%1", Email);
                UnseenMessages = new List<UnseenMessage>();
                List<MailMessage> myMessages = Fetch_UnseenMails(myImapClient);
                foreach (MailMessage message in myMessages)
                {
                    string from_display_name = Examine_FromDisplayName(message);
                    string subject = message.Subject;
                    string body = Examine_Body(message);

                    UnseenMessages.Add(new UnseenMessage(message.MessageID, from_display_name, subject, body, message.Attachments.Count, message.Date));
                }

                Status = "";
                Finished = true;
            }
            catch (Exception e)
            {
                Status = e.Message;
            }
        }
 /// <summary>
 /// Initializes the ImapClient with the given server, account & password
 /// </summary>
 /// <param name="imap">Imap server to use</param>
 /// <param name="account">E-mail account</param>
 /// <param name="password">Password</param>
 /// <returns>True if connection was successful</returns>
 public bool InitializeImapClient(string imap, string account, string password)
 {
     client = new ImapClient(imap, true, false);
     if (client.Connect())
     {
         if (client.Login(account, password))
         {
             return true;
         }
         return false;
     }
     else
     {
         return false;
     }
 }
 internal async Task<List<MailItem>> GetEmailMessages(string user,string pass,int pageNo, int pageSize)
 {
     List<MailItem> returnResults = new List<MailItem>();
     var client = new ImapClient("imap.gmail.com", 993,true, true);
     client.Connect();
     client.Login(user,pass);
     var messages = client.Folders["INBOX"].Search("ALL",ImapX.Enums.MessageFetchMode.Basic| ImapX.Enums.MessageFetchMode.Flags, pageSize);
     foreach (ImapX.Message msg in messages)
     {
         MailItem item = new MailItem();
         item.Sender = msg.From.ToString();
         item.Body = msg.Body.Text;
         item.Subject = msg.Subject;
         item.Received = msg.Date;
         
         returnResults.Add(item);
         
     }
     return returnResults;
 }
    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;
        }
    }
Beispiel #15
0
        public void checkImap(ImapClient imap,TaskbarIcon icon)
        {
            if (imap.Connect())
            {
                int getMailCnt;
                if (type == MAIL_TYPE.GMAIL) getMailCnt = imap.GetMailList().Count();
                else getMailCnt = yMailCntGet(imap.GetMailBox());

                if (getMailCnt != mailCnt)
                {
                    if (getMailCnt > mailCnt)
                    {
                        int newCnt = getMailCnt - mailCnt;
                        icon.ShowBalloonTip("メールの通知", "新着メール " + newCnt + "件", BalloonIcon.Info);

                    }
                    mailCnt = getMailCnt;
                }
                //string msg = "getMailCnt:" + getMailCnt + "件\nmailCnt:" + mailCnt;
                //icon.ShowBalloonTip("メールの通知", msg, BalloonIcon.Info);
            }
            
        }
Beispiel #16
0
 public MailChecker(ImapClient imap)
 {
     if (imap.Connect())
     {
         if (imap.HostName.Contains("yahoo")) 
         {//Yahooメール処理
             if (imap.GetMailBox() != null)
             {
                 type = MAIL_TYPE.YMAIL;
                 mailCnt = yMailCntGet(imap.GetMailBox());
             }
             else MessageBox.Show("メールが存在しませぬ");
         }
         else
         {//GMail処理
             if (imap.GetMailList() != null)
             {
                 type = MAIL_TYPE.GMAIL;
                 mailCnt = imap.GetMailList().Count();
             }
             else MessageBox.Show("メールが存在しませぬ");
         }
     } else MessageBox.Show("失敗");
 }
Beispiel #17
0
        public override void onCommand(string[] args)
        {
            smtp.EnableSsl = true;

            if (args[1] == "server")
            {
                imap.Connect(args[2], 993, SecureSocketOptions.SslOnConnect);
                smtp.Host = args[3];
            }
            else if (args[1] == "login")
            {
                smtp.Credentials = new NetworkCredential(args[2], args[3]);
                imap.Authenticate(args[2], args[3]);

                email = args[2];
            }
            else if (args[1] == "send")
            {
                // Mail message object
                MailMessage message = new MailMessage();
                message.Sender = new MailAddress(email);
                message.From   = new MailAddress(email);

                // Read subject
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.Write("Enter reciver: ");
                Console.ResetColor();

                message.To.Add(Console.ReadLine());

                // Read subject
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.Write("Enter mail subject: ");
                Console.ResetColor();

                message.Subject = Console.ReadLine();

                // Read body
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("Enter mail body: ");
                Console.ResetColor();

                message.Body = Utils.MultiLineInput();

                smtp.Send(message);
            }
            else if (args[1] == "list")
            {
                imap.Inbox.Open(FolderAccess.ReadOnly);
                IList <UniqueId> uids = imap.Inbox.Search(SearchQuery.All);

                foreach (UniqueId id in uids)
                {
                    Console.WriteLine(id.Id.ToString() + ": " + imap.Inbox.GetMessage(id).Subject);
                }
            }
            else if (args[1] == "read")
            {
                var message = imap.Inbox.GetMessage(UniqueId.Parse(args[2]));

                Utils.ValueWrite(ConsoleColor.Cyan, "Subject: ", message.Subject);
                Utils.ValueWrite(ConsoleColor.Cyan, "From: ", message.From.ToString());

                Console.WriteLine();

                Console.WriteLine(message.Body.ToString().Replace("X-MimeKit-Warning: Do NOT use ToString() to serialize entities! Use one of the WriteTo() methods instead!", ""));
            }
        }
        public List<Email> GetMail()
        {
            string getAllMail = Config["GetMailType"].Equals("GETALLMAIL123") ? "ALL" : "UNSEEN";
            MessageCollection remoteEmails;
            List<Email> emails = new List<Email>();
            ImapClient imapClient = new ImapClient(Config["Host_Google"], true, false);
            bool imapConnected = false;
            bool imapLoggedIn = false;

            try
            {
                imapConnected = imapClient.Connect();
                imapLoggedIn = imapClient.Login(Config["User_Google"], Config["Password_Google"]);
                CurrentMailAccessIndicator = MailAccessIndicator.LoggedIn;
            }
            catch (Exception e)
            {
                Logger logger = LogManager.GetCurrentClassLogger();
                logger.Log(LogLevel.Error, "Connection to Google Mail server cannot be established.", e);
            }

            if (imapConnected && imapLoggedIn)
            {
                // Get messages from remote source
                ImapX.Folder InboxFolder = imapClient.Folders.Inbox;
                remoteEmails = InboxFolder.Messages;
                remoteEmails.Download(getAllMail);
                CurrentMailAccessIndicator = MailAccessIndicator.MailChecked;
                
                foreach (Message remoteEmail in remoteEmails)
                {
                    try
                    {
                        Email email = new Email
                        {
                            Date = remoteEmail.Date,
                            From = remoteEmail.From.Address.ToString(),
                            Subject = remoteEmail.Subject,
                            Body = remoteEmail.Body.Text
                        };

                        if (remoteEmail.Attachments.Length > 0)
                        {
                            email.Attachments = new List<Domain.Attachment>();

                            foreach (ImapX.Attachment anAttachment in remoteEmail.Attachments)
                            {
                                anAttachment.Download();
                                string attachmentFileName = DateTime.Now.ToString("yyyyMMddHHMMss.f") + anAttachment.FileName;
                                email.Attachments.Add(
                                    new Domain.Attachment {
                                        FileName = attachmentFileName,
                                        Content = anAttachment.FileData
                                    });
                            }
                        }
                        remoteEmail.Seen = Config["MarkAsSeen"].ToString().Equals("True") ? true : false;
                        emails.Add(email);
                    }
                    catch (Exception e)
                    {
                        Logger logger = LogManager.GetCurrentClassLogger();
                        logger.Log(LogLevel.Error, "Exception occurred when saving emails", e);
                        CurrentMailAccessIndicator = MailAccessIndicator.MailFetchError;

                    }
                    CurrentMailAccessIndicator = MailAccessIndicator.MailFetched;
                }
            }

            imapClient.Dispose();

            TimeLastChecked = DateTime.Now;
            return emails;
        }
Beispiel #19
0
        public void Read(String subject = "")
        {
            if (_settings == null)
            {
                return;
            }

            using (var client = new ImapClient())
            {
                client.ServerCertificateValidationCallback = (s, c, h, e) => true;

                client.Connect(_settings.Host, _settings.Port, _settings.isSSL);
                client.Authenticate(_settings.EmailAddress, _settings.EmailPassword);

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

                // let's search for all messages received after Jan 12, 2013 with "MailKit" in the subject...
                DateTime today     = DateTime.Now;
                DateTime scopeDate = today.AddDays(-5);
                var      query     = SearchQuery.DeliveredAfter(scopeDate)
                                     .And(SearchQuery.SubjectContains(subject));

                // And (SearchQuery.Seen)

                foreach (var uid in inbox.Search(query))
                {
                    var message = inbox.GetMessage(uid);

                    foreach (MimeEntity attachment in message.Attachments)
                    {
                        var fileName = Path.Combine(Utils.InitPath("temp"), attachment.ContentType.Name);

                        if (File.Exists(fileName))
                        {
                            File.Delete(fileName);
                        }
                        Console.WriteLine(fileName);

                        using (var stream = File.Create(fileName)) {
                            if (attachment is MessagePart)
                            {
                                var rfc822 = (MessagePart)attachment;

                                rfc822.Message.WriteTo(stream);
                            }
                            else
                            {
                                var part = (MimePart)attachment;

                                part.Content.DecodeTo(stream);
                            }
                        }
                    }

                    // Delete Message from inbox.
                    inbox.AddFlags(uid, MessageFlags.Deleted, true);
                }

                inbox.Expunge();
                client.Disconnect(true);
            }
        }
Beispiel #20
0
        public async Task GetTickerFromEmail(string emailAccount, string emailPwd, string bucketName)
        {
            List <string> fileNames           = new List <string>();
            string        localInboxFolder    = "/tmp/screen3_temp_files/inbox/";
            string        localInboxZipFolder = "/tmp/screen3_temp_files/inbox_zip/";
            string        zipFileName         = "";

            FileHelper.ClearDirectory(localInboxFolder, true);
            FileHelper.ClearDirectory(localInboxZipFolder, true);

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

                // The Inbox folder is always available on all IMAP servers...
                var inbox = client.Inbox;
                inbox.Open(FolderAccess.ReadWrite);
                foreach (var uid in inbox.Search(SearchQuery.NotSeen))
                {
                    var message = inbox.GetMessage(uid);
                    if (message.Subject.IndexOf("Daily Historical Data") >= 0)
                    {
                        foreach (MimeEntity attachment in message.Attachments)
                        {
                            var fileName = localInboxFolder + attachment.ContentDisposition?.FileName ?? attachment.ContentType.Name;

                            using (var stream = File.Create(fileName))
                            {
                                if (attachment is MessagePart)
                                {
                                    var rfc822 = (MessagePart)attachment;
                                    rfc822.Message.WriteTo(stream);
                                }
                                else
                                {
                                    var part = (MimePart)attachment;
                                    part.Content.DecodeTo(stream);
                                }
                            }
                            fileNames.Add(fileName);
                        }
                    }

                    inbox.AddFlags(uid, MessageFlags.Seen, true);
                }

                client.Disconnect(true);

                if (fileNames.Count > 0)
                {
                    S3Service.S3Service service = new S3Service.S3Service();

                    zipFileName = DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss") + ".zip";
                    var zipFilePath = localInboxZipFolder + zipFileName;

                    ZipFile.CreateFromDirectory(localInboxFolder, zipFilePath);

                    await service.UploadFileToS3Async(bucketName, "source/" + zipFileName, zipFilePath);
                }
            }
        }
        private void Send_Click(object sender, RoutedEventArgs e)
        {
            var message = new MimeMessage();

            message.From.Add(new MailboxAddress(eMail));
            message.To.Add(new MailboxAddress(to.Text));
            message.Subject = theme.Text;

            var builder = new BodyBuilder();

            Crypto crypto = new Crypto();

            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            string[] temps = crypto.ReturnEncryptRijndaelString(SentText.Text).Split(new string[] { "^&*" }, StringSplitOptions.None);

            string pbKey = keyY.Text;

            //File.ReadAllText("C:/KursachMailClient/" + user + "/Public.txt");  /*"Берём public ключ из базы"*/

            temps[1] = crypto.Encrypt(temps[1], pbKey);   /*Шифруем ключ при помощи алгоритма RSA*/

            string EncryptText = "";

            for (int i = 0; i < temps.Length; i++)    /*Формируем конечную строку*/
            {
                if (i < temps.Length - 1)
                {
                    EncryptText += $"{temps[i]}^&*";
                }
                else
                {
                    EncryptText += temps[i];
                }
            }

            builder.TextBody = EncryptText;

            string temp = "";

            if (AttachFiles.Count != 0)
            {
                for (int i = 0; i < AttachFiles.Count; i++)
                {
                    temp = AttachFiles[i];
                }
                builder.Attachments.Add(temp);
            }

            //foreach (var file in AttachFiles)
            //{
            //    byte[] buff = null;
            //    FileStream fs = new FileStream(file,
            //    FileMode.Open,
            //    FileAccess.Read);
            //    BinaryReader br = new BinaryReader(fs);
            //    long numBytes = new FileInfo(file).Length;
            //    buff = br.ReadBytes((int)numBytes);
            //}

            message.Body = builder.ToMessageBody();

            try
            {
                using (var client = new SmtpClient())
                {
                    client.ServerCertificateValidationCallback = (s, c, h, ex) => true;
                    client.Connect("smtp." + getSuffix(), 465, true);
                    client.Authenticate(eMail, pWord);
                    client.Send(message);

                    using (var _client = new ImapClient())
                    {
                        string IMapAddress = "imap." + getSuffix();
                        _client.ServerCertificateValidationCallback = (s, c, h, z) => true;
                        _client.Connect(IMapAddress, 993, true);
                        _client.Authenticate(eMail, pWord);
                        var folder = _client.GetFolder(SpecialFolder.Sent);
                        folder.Append(message);
                        //folder.MoveTo(message, _client.GetFolder(SpecialFolder.Trash));
                        _client.Disconnect(true);
                    }

                    client.Disconnect(true);

                    MessageBoxResult dialogResult = MessageBox.Show("Отправлено. Закрыть?", "Закрыть?",
                                                                    MessageBoxButton.YesNo, MessageBoxImage.Question);
                    if (dialogResult == MessageBoxResult.Yes)
                    {
                        this.Close();
                    }
                    else
                    {
                        to.Clear();
                        theme.Clear();
                        SentText.Clear();
                        attachment.Items.Clear();
                        AttachFiles.Clear();
                        number.Content = "0";
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        /// <summary>
        /// Данная функция является точкой входа.
        /// <summary>
        public void Execute(Context context)
        {
            if (context.MessageTexts == null)
            {
                context.MessageTexts = new List <string>();
            }
            if (context.Attachments == null)
            {
                context.Attachments = new List <FileInfo>();
            }
            Directory.CreateDirectory(context.WorkDirectory);

            /*
             * Это лишь один из возможных вариантов. В текущем примере мы просто
             * получаем списки текстов и вложений. Но они по сути никак не связаны.
             * Пока мы не можем использовать в контексте нестандартные типы в списке
             * и не можем хранить в одном элементе структуру, подсписки разного типа и т.д.
             * Но как вариант можно генерировать строку для одного письма, где будет
             * содержаться текст письма и пути к сохраненным файлам вложений и потом
             * в других местах парсить это.
             * Еще как вариант можно всю информацию сохранять в папке по каждому письму,
             * а в контекст хранить пути к папкам, далее работаем с этим.
             */

            using (ImapClient client = new ImapClient())
            {
                // В данном примере предполагается, что все данные для подключения
                // и аудентификации есть в контексте робота.
                client.Connect(context.Host, (int)context.Port.Value, context.UseSsl.Value);
                client.Authenticate(context.UserName, context.Password);

                // Бучем читать из стандартной папки "Входящие", "Inbox" и т.п.
                IMailFolder inbox = client.Inbox;
                // Нужны права и на запись для помечания прочитанных
                inbox.Open(FolderAccess.ReadWrite);

                // Важный для нас этап - настройка запроса (фильтрация)
                // 1. Нам нужны те, которые мы еще не прочитали и которые не удалены
                var query = SearchQuery.NotSeen.And(SearchQuery.NotDeleted);
                // 2. Далее нам нужно добавить поиск по тексту темы.
                if (!string.IsNullOrEmpty(context.SubjectText))
                {
                    query = query.And(SearchQuery.SubjectContains(context.SubjectText));
                }
                // 2. Далее нам нужно добавить поиск по тексту отправителя (например, email).
                if (!string.IsNullOrEmpty(context.SenderText))
                {
                    query = query.And(SearchQuery.HeaderContains("FROM", context.SenderText));
                }

                // Далее выполняем запрос и получаем уникальные идентификаторы писем,
                // которые должны соответветствовать запросу.
                IList <UniqueId> uids = client.Inbox.Search(query);

                // Проходимся по письмам и получаем текст с вложениями
                foreach (UniqueId uid in uids)
                {
                    string subDirectory = Path.Combine(context.WorkDirectory, uid.Id.ToString());
                    Directory.CreateDirectory(subDirectory);
                    MimeMessage message = client.Inbox.GetMessage(uid);
                    // Обращаем внимание, что тут можно указывать формат
                    context.MessageTexts.Add(message.GetTextBody(MimeKit.Text.TextFormat.Text));

                    foreach (MimeEntity attachment in message.Attachments)
                    {
                        var fileName = attachment.ContentDisposition?.FileName ?? attachment.ContentType.Name;
                        fileName = Path.Combine(subDirectory, fileName);

                        using (var stream = File.Create(fileName))
                        {
                            if (attachment is MessagePart)
                            {
                                var mssagePart = (MessagePart)attachment;

                                mssagePart.Message.WriteTo(stream);
                            }
                            else
                            {
                                var part = (MimePart)attachment;

                                part.Content.DecodeTo(stream);
                            }
                        }

                        context.Attachments.Add(new FileInfo(fileName));
                    }
                }

                // Помечаем как прочитанные. Не забываем,
                // что может понадобиться права на запись в папке
                inbox.AddFlags(uids, MessageFlags.Seen, true);
            }
        }
Beispiel #23
0
        private Task GetSignal(CurrencyPair currencyPair)
        {
            UniqueId uid;

            return(Task.Run(async() =>
            {
                while (!_cts.IsCancellationRequested)
                {
                    using (var client = new ImapClient())
                    {
                        try
                        {
                            client.Connect("outlook.office365.com", 993, true);
                            client.Authenticate(ConfigurationManager.AppSettings["username"], ConfigurationManager.AppSettings["password"]);

                            var folder = client.GetFolder("_tradingview").GetSubfolder($"{currencyPair.QuoteCurrency}usdt");
                            folder.Open(FolderAccess.ReadWrite);

                            DeleteOldMessages(folder);
                            MarkAllMessagesAsSeen(folder);

                            while (true)
                            {
                                uid = folder.Search(SearchQuery.NotSeen).LastOrDefault();

                                if (uid.IsValid)
                                {
                                    //GetBalance(CurrencyPair);
                                    System.Media.SystemSounds.Exclamation.Play();
                                    MimeMessage message = folder.GetMessage(uid);
                                    _signalSubject.OnNext(GetLastState(message, lastState));
                                    DeleteOldMessages(folder);
                                    MarkAllMessagesAsSeen(folder);
                                }

                                client.NoOp();
                                await Task.Delay(5000);
                            }
                        }
                        // erreurs connues:
                        catch (IOException ex)
                        {
                            Debug.WriteLine($"{DateTime.Now} - GetSignal() - {ex.Message}");
                        }
                        catch (FolderNotFoundException ex)
                        {
                            _cts.Cancel();
                            Debug.WriteLine($"{DateTime.Now} - GetSignal() - {ex.Message}");
                        }
                        catch (Exception ex)
                        {
                            Debug.WriteLine($"{DateTime.Now} - GetSignal() - {ex.Message}");
                        }
                        finally
                        {
                            client.Disconnect(true);
                            client.Dispose();
                            await Task.Delay(5000);
                        }
                    }
                }

                _signalSubject.OnCompleted();
            }));
        }
Beispiel #24
0
        public static void DownloadBodyParts()
        {
            using (var client = new ImapClient()) {
                client.Connect("imap.gmail.com", 993, SecureSocketOptions.SslOnConnect);

                client.Authenticate("username", "password");

                client.Inbox.Open(FolderAccess.ReadOnly);

                // search for messages where the Subject header contains either "MimeKit" or "MailKit"
                var query = SearchQuery.SubjectContains("MimeKit").Or(SearchQuery.SubjectContains("MailKit"));
                var uids  = client.Inbox.Search(query);

                // fetch summary information for the search results (we will want the UID and the BODYSTRUCTURE
                // of each message so that we can extract the text body and the attachments)
                var items = client.Inbox.Fetch(uids, MessageSummaryItems.UniqueId | MessageSummaryItems.BodyStructure);

                foreach (var item in items)
                {
                    // determine a directory to save stuff in
                    var directory = Path.Combine(baseDirectory, item.UniqueId.ToString());

                    // create the directory
                    Directory.CreateDirectory(directory);

                    // IMessageSummary.TextBody is a convenience property that finds the 'text/plain' body part for us
                    var bodyPart = item.TextBody;

                    // download the 'text/plain' body part
                    var body = (TextPart)client.Inbox.GetBodyPart(item.UniqueId, bodyPart);

                    // TextPart.Text is a convenience property that decodes the content and converts the result to
                    // a string for us
                    var text = body.Text;

                    File.WriteAllText(Path.Combine(directory, "body.txt"), text);

                    // now iterate over all of the attachments and save them to disk
                    foreach (var attachment in item.Attachments)
                    {
                        // download the attachment just like we did with the body
                        var entity = client.Inbox.GetBodyPart(item.UniqueId, attachment);

                        // attachments can be either message/rfc822 parts or regular MIME parts
                        if (entity is MessagePart)
                        {
                            var rfc822 = (MessagePart)entity;

                            var path = Path.Combine(directory, attachment.PartSpecifier + ".eml");

                            rfc822.Message.WriteTo(path);
                        }
                        else
                        {
                            var part = (MimePart)entity;

                            // note: it's possible for this to be null, but most will specify a filename
                            var fileName = part.FileName;

                            var path = Path.Combine(directory, fileName);

                            // decode and save the content to a file
                            using (var stream = File.Create(path))
                                part.Content.DecodeTo(stream);
                        }
                    }
                }

                client.Disconnect(true);
            }
        }
Beispiel #25
0
        public static void Capabilities()
        {
            using (var client = new ImapClient()) {
                client.Connect("imap.gmail.com", 993, SecureSocketOptions.SslOnConnect);

                var mechanisms = string.Join(", ", client.AuthenticationMechanisms);
                Console.WriteLine("The IMAP server supports the following SASL authentication mechanisms: {0}", mechanisms);

                client.Authenticate("username", "password");

                if (client.Capabilities.HasFlag(ImapCapabilities.Id))
                {
                    var clientImplementation = new ImapImplementation {
                        Name = "MailKit", Version = "1.0"
                    };
                    var serverImplementation = client.Identify(clientImplementation);

                    Console.WriteLine("Server implementation details:");
                    foreach (var property in serverImplementation.Properties)
                    {
                        Console.WriteLine("  {0} = {1}", property.Key, property.Value);
                    }
                }

                if (client.Capabilities.HasFlag(ImapCapabilities.Acl))
                {
                    Console.WriteLine("The IMAP server supports Access Control Lists.");

                    Console.WriteLine("The IMAP server supports the following access rights: {0}", client.Rights);

                    Console.WriteLine("The Inbox has the following access controls:");
                    var acl = client.Inbox.GetAccessControlList();
                    foreach (var ac in acl)
                    {
                        Console.WriteLine("  {0} = {1}", ac.Name, ac.Rights);
                    }

                    var myRights = client.Inbox.GetMyAccessRights();
                    Console.WriteLine("Your current rights for the Inbox folder are: {0}", myRights);
                }

                if (client.Capabilities.HasFlag(ImapCapabilities.Quota))
                {
                    Console.WriteLine("The IMAP server supports quotas.");

                    Console.WriteLine("The current quota for the Inbox is:");
                    var quota = client.Inbox.GetQuota();

                    if (quota.StorageLimit.HasValue && quota.StorageLimit.Value)
                    {
                        Console.WriteLine("  Limited by storage space. Using {0} out of {1} bytes.", quota.CurrentStorageSize.Value, quota.StorageLimit.Value);
                    }

                    if (quota.MessageLimit.HasValue && quota.MessageLimit.Value)
                    {
                        Console.WriteLine("  Limited by the number of messages. Using {0} out of {1} bytes.", quota.CurrentMessageCount.Value, quota.MessageLimit.Value);
                    }

                    Console.WriteLine("The quota root is: {0}", quota.QuotaRoot);
                }

                if (client.Capabilities.HasFlag(ImapCapabilities.Thread))
                {
                    if (client.ThreadingAlgorithms.Contains(ThreadingAlgorithm.OrderedSubject))
                    {
                        Console.WriteLine("The IMAP server supports threading by subject.");
                    }
                    if (client.ThreadingAlgorithms.Contains(ThreadingAlgorithm.References))
                    {
                        Console.WriteLine("The IMAP server supports threading by references.");
                    }
                }

                client.Disconnect(true);
            }
        }
        public ActionResult Index(int currentPageNumber, int nextPageNumber)
        {
            int startSerialNumber = ((nextPageNumber - 1) * 30) + 1;
            int endSerialNumber   = ((nextPageNumber) * 30);

            List <Email> emails = new List <Email>();

            try
            {
                userGmailConfig = FetchUserGmailProfile();
                using (ImapClient client = new ImapClient())
                {
                    client.Connect(userGmailConfig.IncomingServerAddress, userGmailConfig.IncomingServerPort, true);
                    client.Authenticate(new NetworkCredential(userGmailConfig.GmailUsername, userGmailConfig.GmailPassword));

                    var inbox = client.Inbox;
                    inbox.Open(FolderAccess.ReadOnly);

                    if (inbox.Count > 0)
                    {
                        int pageEndIndex   = Math.Max(inbox.Count - startSerialNumber, 0);
                        int pageStartIndex = Math.Max(inbox.Count - endSerialNumber, 0);

                        var messages = inbox.Fetch(pageStartIndex, pageEndIndex, MessageSummaryItems.Envelope);

                        messages = messages.OrderByDescending(message => message.Envelope.Date.Value.DateTime).ToList();

                        foreach (var message in messages)
                        {
                            if (startSerialNumber <= endSerialNumber)
                            {
                                Email tempEmail = new Email()
                                {
                                    SerialNo        = startSerialNumber,
                                    Uid             = message.UniqueId,
                                    FromDisplayName = message.Envelope.From.First().Name,
                                    FromEmail       = message.Envelope.From.First().ToString(),
                                    To            = message.Envelope.To.ToString(),
                                    Subject       = message.NormalizedSubject,
                                    TimeReceived  = message.Envelope.Date.Value.DateTime,
                                    HasAttachment = message.Attachments.Count() > 0 ? true : false
                                };
                                emails.Add(tempEmail);
                                startSerialNumber++;
                            }
                        }
                    }
                }

                ViewBag.EmailId    = userGmailConfig.GmailUsername;
                ViewBag.NoOfEmails = endSerialNumber;
                if (currentPageNumber > nextPageNumber)
                {
                    ViewBag.PageNumber = currentPageNumber - 1;
                }
                else
                {
                    ViewBag.PageNumber = currentPageNumber + 1;
                }
            }
            catch (Exception ex)
            {
                ViewBag.ErrorMessage = "There was an error in processing your request. Exception: " + ex.Message;
            }

            return(View(emails));
        }
        static void Main(string[] args)
        {
            //Если существует файл с настройками
            if (File.Exists("settings.json"))
            {
                //Считываем файл настроек
                string settings_file = File.ReadAllText("settings.json");

                //Создаем объект типа jobject
                JObject settings = JObject.Parse(settings_file);

                //Создадим объект класса ImapX
                var client = new ImapClient(settings["IMAP"].ToString(), Convert.ToInt32(settings["Port"]), true);
                
                //Объявляем регулярное выражение для поиска нужной ссылки
                var find_url = new Regex("style=\"background:#799905;\"><a href=\"(.*)\"> <span style=\"border-radius:2px;");

                //Проверим успешно ли подключились
                if (client.Connect())
                {
                    //Выводим информацию в консоль, что подключились
                    Console.WriteLine("Successfully connected");

                    //Пробуем войти в почтовый ящик
                    if (client.Login(settings["Mail"].ToString(), settings["Password"].ToString()))
                    {
                        //Пишем в консоль, что вошли успешно
                        Console.WriteLine("Login successfully");

                        //Теперь будем постоянно обновлять нашу почту - раз в N секунд
                        while (true)
                        {
                            //Выведем в консоль что пошла новая проверка
                            Console.WriteLine("{0} - Checking mailbox...", DateTime.Now);

                            //Пробежимся по всем непрочитанным письмам
                            foreach (var mess in client.Folders["INBOX"].Search("UNSEEN"))
                            {
                                //Если это сообщение от стима
                                if (mess.Subject == "Steam Trade Confirmation")
                                {
                                    //Пробуем найти ссылку
                                    try
                                    {
                                        //Выводим сообщение, что нашли новое письмо
                                        Console.WriteLine("Find new unred message from " + mess.From);

                                        //Найдем совпадения
                                        Match match = find_url.Match(mess.Body.Html.ToString());

                                        //Преобразуем ссылку в правильный формат
                                        string url = match.Groups[1].Value.Replace("&amp;", "&");

                                        //Если проверим нашло ли вообще ссылку
                                        if (String.IsNullOrEmpty(url))
                                        {
                                            //Отправим подтверждение
                                            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
                                            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                                        }
                                    }
                                    catch(Exception e)
                                    {
                                        Console.Write("Url was not found");
                                    }

                                    //Отметим письмо как прочитанное
                                    mess.Seen = true;
                                }
                            }

                            //Поставим паузу на нужное количесво сепкунд
                            Thread.Sleep(Convert.ToInt32(settings["UpdateTime"]) * 1000);
                        }
                    }
                    else
                        Console.WriteLine("Bad login/password");
                }
                else
                    Console.WriteLine("Connection error");
            }
        }
        public void LoadTrashMessages(string email, string suf)
        {
            var Mails = File.ReadLines("C:/KursachMailClient/" + Login + "/Boxes.txt").ToList();
            int ind   = Mails.IndexOf(email);
            var PW    = File.ReadLines("C:/KursachMailClient/" + Login + "/Data.txt").ToList();

            Password = PW[ind];

            using (var client = new ImapClient())
            {
                string IMapAddress = "imap." + getMailSuffix.GetSuffix(suf);
                client.ServerCertificateValidationCallback = (s, c, h, z) => true;
                client.Connect(IMapAddress, IMapPort, true);
                client.Authenticate(email, Password);

                if (start_letter < 0)
                {
                    start_letter = 0;
                }
                last_index = start_letter;

                var inbox = client.GetFolder(SpecialFolder.Trash);

                inbox.Open(FolderAccess.ReadWrite);

                int count = inbox.Count;

                var ListID = File.ReadAllLines("C:/KursachMailClient/" + Login + "/" + email
                                               + "/" + "Корзина" + "/ID.txt").ToList();

                if (start_letter + count <= inbox.Count)
                {
                    for (int i = ListID.Count; i < count; i++)
                    {
                        var message = inbox.GetMessage(i);

                        if (message.Subject != "")
                        {
                            if (!ListID.Contains(Convert.ToString(message.MessageId)))
                            {
                                Theme.Add(message.Subject);
                                FromWho.Add(message.From.ToString());
                                Dates.Add(Convert.ToString(message.Date));
                                ID.Add(Convert.ToString(message.MessageId));
                                HTML.Add(message.Body.ToString());
                            }
                        }
                        else
                        {
                            if (!ListID.Contains(Convert.ToString(message.MessageId)))
                            {
                                Theme.Add(message.Subject);
                                FromWho.Add(message.From.ToString());
                                Dates.Add(Convert.ToString(message.Date));
                                ID.Add(Convert.ToString(message.MessageId));
                                HTML.Add(message.Body.ToString());
                            }
                        }
                    }
                    start_letter = count + start_letter;
                }
                else
                {
                    for (int i = ListID.Count; i < count; i++)
                    {
                        var message = inbox.GetMessage(i);

                        if (message.Subject != "")
                        {
                            if (!ListID.Contains(Convert.ToString(message.MessageId)))
                            {
                                Theme.Add(message.Subject);
                                FromWho.Add(message.From.ToString());
                                Dates.Add(Convert.ToString(message.Date));
                                ID.Add(Convert.ToString(message.MessageId));
                                HTML.Add(message.Body.ToString());
                            }
                        }
                        else
                        {
                            if (!ListID.Contains(Convert.ToString(message.MessageId)))
                            {
                                Theme.Add(message.Subject);
                                FromWho.Add(message.From.ToString());
                                Dates.Add(Convert.ToString(message.Date));
                                ID.Add(Convert.ToString(message.MessageId));
                                HTML.Add(message.Body.ToString());
                            }
                        }
                    }
                    start_letter = inbox.Count - start_letter;
                }

                File.AppendAllLines("C:/KursachMailClient/" + Login + "/" + email + "/" + "Корзина" + "/Theme.txt", Theme);
                File.AppendAllLines("C:/KursachMailClient/" + Login + "/" + email + "/" + "Корзина" + "/FromWho.txt", FromWho);
                File.AppendAllLines("C:/KursachMailClient/" + Login + "/" + email + "/" + "Корзина" + "/Date.txt", Dates);
                File.AppendAllLines("C:/KursachMailClient/" + Login + "/" + email + "/" + "Корзина" + "/ID.txt", ID);


                // List<string> Temp = new List<string>();
                string Temp;
                for (int i = 0; i < HTML.Count; i++)
                {
                    Temp = (HTML[i]);
                    //File.AppendAllLines("C:/KursachMailClient/" + login + "/" + email + "/" + "Корзина/Письма/" + ID[i] + ".txt", Temp);
                    using (var sw = new StreamWriter("C:/KursachMailClient/" + Login + "/" + email + "/" + "Корзина/Письма/" + ID[i] + ".txt",
                                                     true, System.Text.Encoding.ASCII))
                    {
                        sw.Write(Temp);
                    }
                    Temp = "";
                }

                start_letter = 0;
                count_back   = 0;
                last_index   = 0;
                ClearLists();
                ListID.Clear();
            }
        }
Beispiel #29
0
        public int ImportEmailBilag()
        {
            MimeMessage message;
            int         antalbilag = 0;
            clsParam    objParam   = null;

            using (var imap_client = new ImapClient())
            {
                imap_client.Connect("outlook.office365.com", 993, true);
                imap_client.AuthenticationMechanisms.Remove("XOAUTH");
                imap_client.Authenticate(clsApp.ImapUser, clsApp.ImapPW);
                var HafsjoldDataBilag      = imap_client.GetFolder("_HafsjoldDataBilag");
                var HafsjoldDataBilagArkiv = imap_client.GetFolder("_HafsjoldDataBilagArkiv");
                //var Puls3060Bilag = imap_client.GetFolder("_TestPuls3060Bilag");          // <-----------------------------------TEST
                //var Puls3060BilagArkiv = imap_client.GetFolder("_TestPuls3060BilagArkiv");// <-----------------------------------TEST
                HafsjoldDataBilag.Open(FolderAccess.ReadWrite);

                var results = HafsjoldDataBilag.Search(SearchQuery.All);
                antalbilag = results.Count();
                foreach (var result in results)
                {
                    message = HafsjoldDataBilag.GetMessage(result);

                    var msMail = Message2Pdf(message);

                    List <VouchersClient> documents = new List <VouchersClient>();
                    VouchersClient        mail      = new VouchersClient()
                    {
                        Fileextension     = FileextensionsTypes.PDF,
                        Text              = "e-Mail",
                        VoucherAttachment = msMail.ToArray(),
                        DocumentDate      = DateTime.Now,
                    };
                    var task1 = m_api.Insert(mail);
                    task1.Wait();
                    var res1 = task1.Result;
                    documents.Add(mail);

                    foreach (var msg_attachment in message.Attachments)
                    {
                        if (msg_attachment is MimePart)
                        {
                            FileextensionsTypes type = FileextensionsTypes.PDF;
                            switch (msg_attachment.ContentType.MediaSubtype.ToUpper())
                            {
                            case "PDF":
                                type = FileextensionsTypes.PDF;
                                break;

                            case "JPEG":
                                type = FileextensionsTypes.JPEG;
                                break;

                            case "TXT":
                                type = FileextensionsTypes.TXT;
                                break;

                            case "PLAIN":
                                type = FileextensionsTypes.TXT;
                                break;

                            case "MSWORD":
                                type = FileextensionsTypes.DOC;
                                break;

                            case "VND.OPENXMLFORMATS-OFFICEDOCUMENT.SPREADSHEETML.SHEET":
                                type = FileextensionsTypes.XLSX;
                                break;

                            default:
                                type = FileextensionsTypes.UNK;
                                break;
                            }
                            var          part     = (MimePart)msg_attachment;
                            MemoryStream msstream = new MemoryStream();
                            part.ContentObject.DecodeTo(msstream);
                            byte[] arrStream = msstream.ToArray();
                            if (type == FileextensionsTypes.UNK)
                            {
                                if (arrStream[0] == 0x25 && arrStream[1] == 0x50 && arrStream[2] == 0x44 && arrStream[3] == 0x46) // PDF Magic number
                                {
                                    type = FileextensionsTypes.PDF;
                                }
                            }
                            VouchersClient attm = new VouchersClient()
                            {
                                Fileextension     = type,
                                Text              = (msg_attachment as MimePart).FileName,
                                VoucherAttachment = arrStream,
                                DocumentDate      = DateTime.Now,
                            };
                            var task3 = m_api.Insert(attm);
                            task3.Wait();
                            var res3 = task3.Result;
                            documents.Add(attm);
                        }
                        else if (msg_attachment is MessagePart)
                        {
                            var msgpart     = msg_attachment as MessagePart;
                            var MessageBody = msgpart.Message.HtmlBody;
                            if (string.IsNullOrEmpty(MessageBody))
                            {
                                MessageBody = msgpart.Message.TextBody;
                            }
                            var      msgtext     = Regex.Replace(MessageBody, "<[^>]*>", String.Empty).Replace("&nbsp;", String.Empty).Trim();
                            string[] splitstring = { "\r\n" };
                            string[] arrParams   = msgtext.Split(splitstring, StringSplitOptions.RemoveEmptyEntries);
                            objParam = new clsParam(arrParams);
                        }
                    }

                    if (documents.Count > 0)
                    {
                        VouchersClient folder = new VouchersClient()
                        {
                            _Fileextension = FileextensionsTypes.DIR,
                            _Text          = message.Subject,
                            _DocumentDate  = DateTime.Now,
                        };
                        var ref3  = folder.PrimaryKeyId;
                        var task4 = m_api.Insert(folder);
                        task4.Wait();
                        var res4 = task4.Result;
                        var ref1 = folder.PrimaryKeyId;

                        DocumentAPI docapi = new DocumentAPI(m_api);
                        var         task5  = docapi.CreateFolder(folder, documents);
                        task5.Wait();
                        var res5 = task5.Result;
                        var ref2 = folder.PrimaryKeyId;

                        int DocumentRef = ref2;

                        if (ref1 != ref2) //Delete ref1
                        {
                            var crit = new List <PropValuePair>();
                            var pair = PropValuePair.GenereteWhereElements("PrimaryKeyId", typeof(int), ref1.ToString());
                            crit.Add(pair);
                            var task6 = m_api.Query <VouchersClient>(null, crit);
                            task6.Wait();
                            var col = task6.Result;
                            if (col.Count() == 1)
                            {
                                var rec = col[0];
                                m_api.DeleteNoResponse(rec);
                            }
                        }

                        if (objParam == null)
                        {
                            objParam = new clsParam()
                            {
                                Delsystem    = "Finans",
                                Tekst        = "Ukendt post",
                                Kontotype    = "Finans",
                                Konto        = "5820",
                                Modkontotype = "Finans",
                                Modkonto     = "9900",
                                Kredit       = 0.00
                            };
                        }

                        switch (objParam.Delsystem.ToLower())
                        {
                        case "finans":
                            InsertFinansJournal(message, DocumentRef, objParam);
                            break;

                        case "kreditor":
                            InsertKøbsOrder(message, DocumentRef, objParam);
                            break;

                        default:
                            break;
                        }
                        // move email to arkiv
                        var newId = HafsjoldDataBilag.MoveTo(result, HafsjoldDataBilagArkiv);
                    }
                }

                HafsjoldDataBilag.Close();
                imap_client.Disconnect(true);
            }
            return(antalbilag);// message;
        }
Beispiel #30
0
        private void Options_OK_Click(object sender, EventArgs ea)
        {
            Options_Cancel.Enabled = false;
            Options_OK.Enabled     = false;

            /// DMS
            ///
            RegSetting.DMS_Enable = checkBox_DMSEnable.Checked;

            if (RegSetting.DMS_Enable && (textBox_DMS_UserID.Text.Length <= 0 || textBox_DMS_Password.Text.Length <= 0))
            {
                MessageBox.Show("Need DMS UserID and Password to enable AutoDMS.\r\nPlease provide correct UserID and Password in AutoDMS page.");
                this.DialogResult      = DialogResult.None;
                Options_Cancel.Enabled = true;
                Options_OK.Enabled     = true;
                return;
            }

            RegSetting.DMS_TriggerAt      = dateTimePicker_DMS_TriggerAt.Value;
            RegSetting.DMS_Setting.From   = dateTimePicker_DMS_From.Value;
            RegSetting.DMS_Setting.To     = dateTimePicker_DMS_To.Value;
            RegSetting.DMS_Setting.UserID = textBox_DMS_UserID.Text;
            RegSetting.DMS_Setting.setPassword(textBox_DMS_Password.Text);
            RegSetting.DMS_Setting.Items   = (int)numericUpDown_DMS_Items.Value;
            RegSetting.DMS_Setting.Action  = textBox_DMS_Action.Text;
            RegSetting.DMS_Setting.Target  = textBox_DMS_Target.Text;
            RegSetting.DMS_Setting.Event   = textBox_DMS_Event.Text;
            RegSetting.DMS_Setting.project = comboBox_DMS_Projects.SelectedValue?.ToString();
            KeyValuePair <string, string> selected = (KeyValuePair <string, string>)comboBox_DMS_Projects.SelectedItem;

            RegSetting.DMS_Setting.projectname = selected.Value;


            /// Advanced
            ///
            RegSetting.LogLevel            = (FConstants.FreyaLogLevel)comboBox_LogLevel.SelectedItem;
            RegSetting.SMTPLogWriterEnable = checkBox_SMTPLogWriterEnable.Checked;

            /// Mail
            ///
            if (textBox_Email.Text.Length > 0)
            {
                RegSetting.EMail = textBox_Email.Text;
            }

            if (textBox_Password.Text.Length > 0)
            {
                RegSetting.setPassword(textBox_Password.Text);
            }

            if (textBox_SMTPServer.Text.Length > 0)
            {
                RegSetting.SMTPServerIP = textBox_SMTPServer.Text;
            }

            if (textBox_WebService.Text.Length > 0)
            {
                RegSetting.WebServiceIP = textBox_WebService.Text;
            }

            if (textBox_IMAPServer.Text.Length > 0)
            {
                RegSetting.IMAPServerIP = textBox_IMAPServer.Text;
            }

            RegSetting.SMTPLogLevel = (string)comboBox_SMTPLogLevel.SelectedItem;

            /// Check IMAP account
            string IMAPAuthResult = string.Empty;

            if (sw_needIMAPAuthCheck && !(RegSetting.hasRight(FConstants.FeatureByte.Hide) || RegSetting.hasRight(FConstants.FeatureByte.Odin)))
            {
                new FormWait(() =>
                {
                    // Start IMAP authenticate
                    using (var client = new ImapClient())
                    {
                        try
                        {
                            client.ServerCertificateValidationCallback = (s, c, h, e) => true;
                            client.Connect(RegSetting.IMAPServerIP, 993, SecureSocketOptions.SslOnConnect);

                            // Bug of MailKit
                            // https://stackoverflow.com/questions/39573233/mailkit-authenticate-to-imap-fails
                            client.AuthenticationMechanisms.Remove("NTLM");

                            client.Authenticate(RegSetting.EMail, RegSetting.getPassword());

                            client.Disconnect(true);
                        }
                        catch (Exception ex)
                        {
                            IMAPAuthResult = ex.Message.ToString();
                        }
                    }
                }).SetMessage("Validating IMAP account...").ShowDialog();
            }

            if (IMAPAuthResult.Length > 0)
            {
                MessageBox.Show("Email or Password may be wrong, please check again.\r\n\r\n" + IMAPAuthResult);
                this.DialogResult      = DialogResult.None;
                Options_Cancel.Enabled = true;
                Options_OK.Enabled     = true;
                return;
            }
            else
            {
                string RegJSON = JsonConvert.SerializeObject(RegSetting);
                radioClient.Send(JsonConvert.SerializeObject(new FMsg {
                    Type = "CMD", Data = "WriteRegistry", Data2 = RegJSON
                }));
            }
        }
Beispiel #31
0
        public void imapSaveAttachedFile(dbData3060DataContext p_dbData3060, string filename, byte[] data, bool bTilPBS)
        {
            string local_filename = filename.Replace('.', '_') + ".txt";

            MimeMessage message = new MimeMessage();
            TextPart    body;

            message.To.Add(new MailboxAddress(@"*****@*****.**", @"Regnskab Puls3060"));
            message.From.Add(new MailboxAddress(@"*****@*****.**", @"Regnskab Puls3060"));

            if (bTilPBS)
            {
#if (DEBUG)
                message.Subject = "Test Til PBS: " + local_filename;
                body            = new TextPart("plain")
                {
                    Text = @"Test Til PBS: " + local_filename
                };
#else
                message.Subject = "Til PBS: " + local_filename;
                body            = new TextPart("plain")
                {
                    Text = @"Til PBS: " + local_filename
                };
#endif
            }
            else
            {
#if (DEBUG)
                message.Subject = "Test Fra PBS: " + local_filename;
                body            = new TextPart("plain")
                {
                    Text = @"Test Fra PBS: " + local_filename
                };
#else
                message.Subject = "Fra PBS: " + local_filename;
                body            = new TextPart("plain")
                {
                    Text = @"Fra PBS: " + local_filename
                };
#endif
            }

            var attachment = new MimePart("text", "plain")
            {
                ContentObject           = new ContentObject(new MemoryStream(data), ContentEncoding.Default),
                ContentDisposition      = new ContentDisposition(ContentDisposition.Attachment),
                ContentTransferEncoding = ContentEncoding.Base64,
                FileName = local_filename
            };

            var multipart = new Multipart("mixed");
            multipart.Add(body);
            multipart.Add(attachment);

            message.Body = multipart;

            using (var client = new ImapClient())
            {
                client.Connect("imap.gigahost.dk", 993, true);
                client.AuthenticationMechanisms.Remove("XOAUTH");
                client.Authenticate(@"*****@*****.**", "1234West+");

                var PBS = client.GetFolder("INBOX.PBS");
                PBS.Open(FolderAccess.ReadWrite);
                PBS.Append(message);
                PBS.Close();

                client.Disconnect(true);
            }
        }
        public void SaveAttachments(int total, string path)
        {
            void GetChildren(IMailFolder parent_folder, List <IMailFolder> list)
            {
                foreach (var f in parent_folder.GetSubfolders())
                {
                    list.Add(f);
                    GetChildren(f, list);
                }
            }

            using (ImapClient client = new ImapClient())
            {
                // Вход на сервер.

                client.Connect(HostName, Port, UseSsl);
                client.Authenticate(UserName, Password);

                var list = new List <IMailFolder>();


                var main_folders = client.GetFolder(client.PersonalNamespaces[0]).GetSubfolders();
                foreach (var mf in main_folders)
                {
                    list.Add(mf);
                    GetChildren(mf, list);
                }

                // Скачивание вложений.

                foreach (var f in list)
                {
                    void Display()
                    {
                        Console.Clear();
                        Console.WriteLine($"Downloaded {_downloaded} files of total size {SizeToString(_size)}");
                        Console.WriteLine($"Processed {_processed}/{total} {(int)((double)_processed / total * 100)}% messages");
                        Console.WriteLine($"Downloading {last_downloaded}");
                    }

                    f.Open(FolderAccess.ReadOnly);
                    for (int i = 0; i <= f.Count - 1; i++)
                    {
                        if (_processed == 1721 || _processed == 0)
                        {
                            Console.WriteLine("Debug");
                        }
                        _processed++;
                        MimeMessage msg = f.GetMessage(i);
                        if (msg.Attachments.Count() != 0)
                        {
                            foreach (MimeEntity attachement in msg.Attachments)
                            {
                                string fileName = GetFileName(attachement, path);

                                using (var stream = File.Create(fileName))
                                {
                                    if (attachement is MessagePart)
                                    {
                                        var rfc822 = (MessagePart)attachement;
                                        rfc822.WriteTo(stream);
                                    }
                                    else
                                    {
                                        var part = (MimePart)attachement;
                                        part.Content.DecodeTo(stream);
                                    }
                                    _downloaded++;
                                    _size          += stream.Length;
                                    last_downloaded = fileName;
                                }
                                Display();
                            }
                        }
                        Display();
                    }
                }
                Console.WriteLine("\nCompleted! ");
            }
        }
Beispiel #33
0
        public async Task <IActionResult> replyOnMail(MailReply email)
        {
            MimeMessage message = new MimeMessage();

            // Retrieve searched email.
            MailMessage originalMessage;

            using (ImapClient imap = new ImapClient())
            {
                imap.Connect("smtp.gmail.com", 993, true);
                imap.Authenticate("*****@*****.**", "Rstest123456");

                //imap.SelectInbox();


                var inbox = imap.Inbox;
                await inbox.OpenAsync(FolderAccess.ReadWrite);


                //string search = @"SUBJECT ""Subj za test""";

                //originalMessage = imap.GetMessage(imap.SearchMessageNumbers(search).First());

                var results = await inbox.SearchAsync(SearchOptions.All, SearchQuery.SubjectContains(email.Subject)).ConfigureAwait(false);

                foreach (var uniqueId in results.UniqueIds)
                {
                    message = inbox.GetMessage(uniqueId);
                }



                //Create reply email with sender and receiver addresses swapped.
                //InternetAddressList temp = message.To;

                MailMessage replyMessage = new MailMessage();
                replyMessage.From = new MailAddress(message.From.ToString());
                replyMessage.To.Add(email.From.ToString());



                //if (!string.IsNullOrEmpty(message.MessageId))
                //{
                //    replyMessage.ReplyTo= message.MessageId;
                //    foreach (var id in message.References)
                //        replyMessage.References.Add(id);
                //    replyMessage.References.Add(message.MessageId);
                //}



                replyMessage.Headers.Add("Message-Id", message.MessageId);


                // Add 'In-Reply-To' and 'References' header.
                //replyMessage.Headers.Add(
                //new Header(HeaderId.InReplyTo, message.MessageId));
                //replyMessage.Headers.Add(
                //    new Header(HeaderId.References, message.MessageId));


                // Set subject.

                replyMessage.Subject = $"Re: { message.Subject }";


                // Set reply message message.
                replyMessage.Body = email.Message;

                // Append original message text.
                replyMessage.Body +=
                    $"<div>On {message.Date.LocalDateTime}, {message.From} </div>" +
                    $"<blockquote>{message.TextBody}</blockquote>";


                replyMessage.IsBodyHtml = true;



                // Send reply email.
                using (SmtpClient smtp = new SmtpClient("smtp.gmail.com"))
                {
                    //smtp.Connect();
                    //smtp.Authenticate("<USERNAME>", "<PASSWORD>");
                    //smtp.SendMessage(replyMessage);

                    smtp.Port = 587;
                    smtp.UseDefaultCredentials = false;
                    smtp.Credentials           = new System.Net.NetworkCredential("*****@*****.**", "Rstest123456");
                    smtp.EnableSsl             = true;
                    smtp.Send(replyMessage);
                }
            }



            return(Ok());
        }
Beispiel #34
0
        public void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
        {
            button1.Enabled = false;
            button2.Enabled = false;
            button3.Enabled = true;

            label8.Select();

            rozszerzenia = textBox6.Text;
            string[] rozszerzenia2 = rozszerzenia.Split(';', ',');

            var l = from s in rozszerzenia2
                    select s;
            int b = l.Count();

            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);

            var inbox  = client.Inbox;
            var inbox2 = client.Inbox;

            inbox.Open(FolderAccess.ReadOnly);

            label2.Text = inbox.Count.ToString();
            //progressBar1.Maximum = inbox.Count;
            //progressBar1.Value = 0;

            //System.Threading.Thread.Sleep(100);

            var messages = client.Inbox.Fetch(0, -1, MessageSummaryItems.Full | MessageSummaryItems.UniqueId);
            int unnamed  = 0;

            foreach (var message in messages)
            {
                var multipart  = message.Body as BodyPartMultipart;
                var basic      = message.Body as BodyPartBasic;
                var temat      = message.NormalizedSubject;
                var data       = message.Date.DateTime;
                var ticks_data = message.Date.Ticks;

                //MessageBox.Show(ticks_data.ToString());

                if (multipart != null)
                {
                    foreach (var attachment in multipart.BodyParts.OfType <BodyPartBasic>())
                    {
                        var mime = (MimePart)client.Inbox.GetBodyPart(message.UniqueId, attachment);

                        var fileName = mime.FileName;
                        var sciezka  = Directory.GetCurrentDirectory() + @"\attachments\" + ticks_data + "_" + mime.FileName;
                        //MessageBox.Show(b);

                        if (string.IsNullOrEmpty(fileName))
                        {
                            richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nnie znaleziono załącznika. \r\n\r\n";
                        }
                        else if (File.Exists(sciezka) != true & sprawdz_baza(ticks_data.ToString(), data.ToString(), mime.FileName.ToString()) == 0)
                        {
                            switch (b)
                            {
                            case 1:
                                if ((fileName.Contains("." + rozszerzenia2[0])))
                                {
                                    using (var stream = File.Create(sciezka))
                                        mime.ContentObject.DecodeTo(stream);
                                    data_pliku(sciezka, data.ToString());
                                    richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n\r\n";
                                    wiadomosci        = wiadomosci + 1;
                                    label7.Text       = wiadomosci.ToString();
                                    dodaj_baza(ticks_data.ToString(), data.ToString(), mime.FileName.ToString());

                                    //if (progressBar1.Maximum < progressBar1.Value + 1)
                                    //{
                                    //    progressBar1.Value = progressBar1.Value + 1;
                                    //}
                                }
                                break;

                            case 2:
                                if ((fileName.Contains("." + rozszerzenia2[0])) | (fileName.Contains("." + rozszerzenia2[1])))
                                {
                                    using (var stream = File.Create(sciezka))
                                        mime.ContentObject.DecodeTo(stream);
                                    data_pliku(sciezka, data.ToString());
                                    richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n\r\n";
                                    wiadomosci        = wiadomosci + 1;
                                    label7.Text       = wiadomosci.ToString();
                                    dodaj_baza(ticks_data.ToString(), data.ToString(), mime.FileName.ToString());

                                    //if (progressBar1.Maximum < progressBar1.Value + 1)
                                    //{
                                    //    progressBar1.Value = progressBar1.Value + 1;
                                    //}
                                }
                                break;

                            case 3:
                                if ((fileName.Contains("." + rozszerzenia2[0])) | (fileName.Contains("." + rozszerzenia2[1])) | (fileName.Contains("." + rozszerzenia2[2])))
                                {
                                    using (var stream = File.Create(sciezka))
                                        mime.ContentObject.DecodeTo(stream);
                                    data_pliku(sciezka, data.ToString());
                                    richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n\r\n";
                                    wiadomosci        = wiadomosci + 1;
                                    label7.Text       = wiadomosci.ToString();
                                    dodaj_baza(ticks_data.ToString(), data.ToString(), mime.FileName.ToString());

                                    //if (progressBar1.Maximum < progressBar1.Value + 1)
                                    //{
                                    //    progressBar1.Value = progressBar1.Value + 1;
                                    //}
                                }
                                break;

                            case 4:
                                if ((fileName.Contains("." + rozszerzenia2[0])) | (fileName.Contains("." + rozszerzenia2[1])) | (fileName.Contains("." + rozszerzenia2[2])) | (fileName.Contains("." + rozszerzenia2[3])))
                                {
                                    using (var stream = File.Create(sciezka))
                                        mime.ContentObject.DecodeTo(stream);
                                    data_pliku(sciezka, data.ToString());
                                    richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n\r\n";
                                    wiadomosci        = wiadomosci + 1;
                                    label7.Text       = wiadomosci.ToString();
                                    dodaj_baza(ticks_data.ToString(), data.ToString(), mime.FileName.ToString());

                                    //if (progressBar1.Maximum < progressBar1.Value + 1)
                                    //{
                                    //    progressBar1.Value = progressBar1.Value + 1;
                                    //}
                                }
                                break;
                            }
                        }
                        else
                        {
                            richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n -- DUPLIKAT (W PLIKU/BAZIE) -- \r\n\r\n";


                            //switch (b)
                            //{
                            //    case 1:
                            //        if (fileName.Contains("." + rozszerzenia2[0]))
                            //        {
                            //            richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n -- DUPLIKAT -- \r\n\r\n";

                            //            //if (progressBar1.Maximum < progressBar1.Value + 1)
                            //            //{
                            //            //    progressBar1.Value = progressBar1.Value + 1;
                            //            //}
                            //        }
                            //        break;
                            //    case 2:
                            //        if ((fileName.Contains("." + rozszerzenia2[0])) | (fileName.Contains("." + rozszerzenia2[1])))
                            //        {
                            //            richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n -- DUPLIKAT -- \r\n\r\n";

                            //            //if (progressBar1.Maximum < progressBar1.Value + 1)
                            //            //{
                            //            //    progressBar1.Value = progressBar1.Value + 1;
                            //            //}
                            //        }
                            //        break;
                            //    case 3:
                            //        if ((fileName.Contains("." + rozszerzenia2[0])) | (fileName.Contains("." + rozszerzenia2[1])) | (fileName.Contains("." + rozszerzenia2[2])))
                            //        {
                            //            richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n -- DUPLIKAT -- \r\n\r\n";

                            //            //if (progressBar1.Maximum < progressBar1.Value + 1)
                            //            //{
                            //            //    progressBar1.Value = progressBar1.Value + 1;
                            //            //}
                            //        }
                            //        break;
                            //    case 4:
                            //        if ((fileName.Contains("." + rozszerzenia2[0])) | (fileName.Contains("." + rozszerzenia2[1])) | (fileName.Contains("." + rozszerzenia2[2])) | (fileName.Contains("." + rozszerzenia2[3])))
                            //        {
                            //            richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + " ----- Data: " + data + "\r\nZałącznik: " + fileName.ToString() + "\r\n -- DUPLIKAT -- \r\n\r\n";

                            //            //if (progressBar1.Maximum < progressBar1.Value + 1)
                            //            //{
                            //            //    progressBar1.Value = progressBar1.Value + 1;
                            //            //}
                            //        }
                            //        break;
                            //}
                        }
                    }
                }
                else if (basic != null && basic.IsAttachment)
                {
                    var liczba = inbox2.Count - 1;
                    label2.Text = liczba.ToString();

                    var mime     = (MimePart)client.Inbox.GetBodyPart(message.UniqueId, basic);
                    var fileName = mime.FileName;
                    var sciezka  = Directory.GetCurrentDirectory() + @"\attachments\" + mime.FileName;

                    if (string.IsNullOrEmpty(fileName))
                    {
                        fileName = string.Format("unnamed-{0}", ++unnamed);
                    }

                    using (var stream = File.Create(sciezka))
                        mime.ContentObject.DecodeTo(stream);
                    wiadomosci        = wiadomosci + 1;
                    label7.Text       = wiadomosci.ToString();
                    richTextBox1.Text = richTextBox1.Text + "Temat: " + temat + "\r\nZałącznik: " + fileName.ToString() + "\r\n\r\n";
                    //progressBar1.Value = progressBar1.Value + 1;
                }
            }

            //richTextBox1.Text = richTextBox1.Text + "========== OCZEKIWANIE ========== ";
        }
Beispiel #35
0
        protected override void Execute(NativeActivityContext context)
        {
            string username   = Email.Get(context);             //发送端账号
            string password   = Password.Get(context);          //发送端密码(这个客户端重置后的密码)
            string server     = Server.Get(context);            //邮件服务器
            Int32  port       = Port.Get(context);              //端口号
            Int32  counts     = Counts.Get(context);            //检索邮件数
            string mainFolder = MainFolder.Get(context);        //邮件文件夹

            string mailTopicKey    = MailTopicKey.Get(context);
            string mailSenderKey   = MailSenderKey.Get(context);
            string mailTextBodyKey = MailTextBodyKey.Get(context);

            List <object>      configList = new List <object>();
            List <MimeMessage> emails     = new List <MimeMessage>();
            ImapClient         client     = new ImapClient();
            SearchQuery        query;
            IList <UniqueId>   uidss;

            try
            {
                client.CheckCertificateRevocation          = false;
                client.ServerCertificateValidationCallback = (s, c, h, e) => true;
                client.Connect(server, port, SecureConnection);
                client.Authenticate(username, password);

                if (OnlyUnreadMessages || _AllUnreadMessages)
                {
                    query = SearchQuery.NotSeen;
                }
                else
                {
                    query = SearchQuery.All;
                }

                List <IMailFolder> mailFolderList = client.GetFolders(client.PersonalNamespaces[0]).ToList();
                IMailFolder        folder         = client.GetFolder(mainFolder);
                folder.Open(FolderAccess.ReadWrite);
                emails = new List <MimeMessage>();
                if (_AllUnreadMessages)
                {
                    query = SearchQuery.NotSeen;
                    uidss = folder.Search(query);
                    for (int i = uidss.Count - 1; i >= 0; i--)
                    {
                        MimeMessage message = folder.GetMessage(new UniqueId(uidss[i].Id));
                        emails.Add(message);
                        if (MarkAsRead)
                        {
                            folder.AddFlags(new UniqueId(uidss[i].Id), MessageFlags.Seen, true);//如果设置为true,则不会发出MessageFlagsChanged事件
                        }
                        if (DeleteMessages)
                        {
                            folder.AddFlags(new UniqueId(uidss[i].Id), MessageFlags.Deleted, true);//如果设置为true,则不会发出MessageFlagsChanged事件
                        }
                    }
                }
                else
                {
                    uidss = folder.Search(query);
                    for (int i = uidss.Count - 1, j = 0; i >= 0 && j < counts; i--, j++)
                    {
                        MimeMessage message = folder.GetMessage(new UniqueId(uidss[i].Id));

                        InternetAddressList Sender = message.From;
                        string SenderStr           = Sender.Mailboxes.First().Address;
                        string Topic = message.Subject;
                        if (mailTopicKey != null && mailTopicKey != "")
                        {
                            if (Topic == null || Topic == "")
                            {
                                j--;
                                continue;
                            }
                            if (!Topic.Contains(mailTopicKey))
                            {
                                j--;
                                continue;
                            }
                        }
                        if (mailSenderKey != null && mailSenderKey != "")
                        {
                            if (SenderStr == null || SenderStr == "")
                            {
                                j--;
                                continue;
                            }
                            if (!SenderStr.Contains(mailSenderKey))
                            {
                                j--;
                                continue;
                            }
                        }
                        if (mailTextBodyKey != null && mailTextBodyKey != "")
                        {
                            if (message.TextBody == null || message.TextBody == "")
                            {
                                j--;
                                continue;
                            }
                            if (!message.TextBody.Contains(mailTextBodyKey))
                            {
                                j--;
                                continue;
                            }
                        }

                        emails.Add(message);
                        if (MarkAsRead)
                        {
                            folder.AddFlags(new UniqueId(uidss[i].Id), MessageFlags.Seen, true);//如果设置为true,则不会发出MessageFlagsChanged事件
                        }
                        if (DeleteMessages)
                        {
                            folder.AddFlags(new UniqueId(uidss[i].Id), MessageFlags.Deleted, true);//如果设置为true,则不会发出MessageFlagsChanged事件
                        }
                    }
                }

                //获取搜索结果的摘要信息(我们需要UID和BODYSTRUCTURE每条消息,以便我们可以提取文本正文和附件)(获取全部邮件)
                //var items = folder.Fetch(uidss, MessageSummaryItems.UniqueId | MessageSummaryItems.BodyStructure);
                MailMsgList.Set(context, emails);
                client.Disconnect(true);

                configList.Add(server);
                configList.Add(port);
                configList.Add(SecureConnection);
                configList.Add(username);
                configList.Add(password);
                configList.Add(mainFolder);
            }
            catch (Exception e)
            {
                client.Disconnect(true);
                SharedObject.Instance.Output(SharedObject.enOutputType.Error, "获取IMAP邮件失败", e.Message);
            }
            if (Body != null)
            {
                object[] buff = configList.ToArray();
                context.ScheduleAction(Body, emails, client, buff);
            }
        }
Beispiel #36
0
        public void DownloadEmailAttachment()
        {
            ImapClient imapClient = new ImapClient(host);

            imapClient.IsDebug = true;

            if (imapClient.Connect())
            {
                Console.WriteLine("Connect to {0} OK", host);
            }
            else
            {
                Console.WriteLine("Connect to {0} FAILED", host);
                Console.ReadKey();
                return;
            }


            if (imapClient.Login(this.EmailAccount, this.password))
            {
                Console.WriteLine("Login OK");
            }
            else
            {
                Console.ReadKey();
                return;
            }

            Folder testFolder = imapClient.Folders["其他文件夹"].SubFolders["比利时"];

            testFolder.Messages.Download("ALL", ImapX.Enums.MessageFetchMode.Full);

            Console.WriteLine("Messages downloaded! Messages count:{0}", testFolder.Messages.Count());


            List<Message> list = new List<Message>();

            foreach (var message in testFolder.Messages)
            {
                Console.WriteLine("===Message Start===");

                Console.WriteLine("Message Title : {0}", message.Subject);

                Console.WriteLine("Message Header : {0}", string.Join(",", message.Headers.Select(x => x.Key + "->" + x.Value)));

                Console.WriteLine("Message Body : ");

                Console.WriteLine(message.Body.Text);

                Console.WriteLine("Message Attachments");

                foreach (var file in message.Attachments)
                {
                    Console.WriteLine(file.FileName);
                    Console.WriteLine(file.FileSize);
                    Console.WriteLine("--");

                    file.Save(@"T:\");
                }


                Console.WriteLine("===Message End===");

                list.Add(message);
            }


            foreach (var message in list)
            {
                if (message.MoveTo(imapClient.Folders["其他文件夹"].SubFolders["比利时完成"]))
                {
                    Console.WriteLine("Message moved OK");
                }
                else
                {
                    Console.WriteLine("Message moved FAILED");
                }
            }

            var keyInfo = Console.ReadKey(true);


            


            imapClient.Logout();
        }
        public void SyncUsingMimeKit(string workspace, string project)
        {
            DynamicJsonObject toCreate = new DynamicJsonObject();

            toCreate[RALLY.WorkSpace] = workspace;
            toCreate[RALLY.Project]   = project;
            DynamicJsonObject attachmentContent   = new DynamicJsonObject();
            DynamicJsonObject attachmentContainer = new DynamicJsonObject();
            CreateResult      createUserStory;
            CreateResult      attachmentContentCreateResult;
            CreateResult      attachmentContainerCreateResult;

            string[] allAttachments;
            Dictionary <string, string> attachmentsDictionary = new Dictionary <string, string>();
            string emailSubject;
            string emailBody;
            string userStoryReference;
            int    anotherOne = 0;
            string base64String;
            string attachmentFileName;
            string fileName;

            EnsureRallyIsAuthenticated();

            using (var client = new ImapClient())
            {
                client.ServerCertificateValidationCallback = (s, c, ch, e) => true;
                client.Connect(EMAIL.GoogleImapHost, EMAIL.ImapPort, SecureSocketOptions.SslOnConnect);
                client.AuthenticationMechanisms.Remove(EMAIL.GoogleOAuth);
                client.Authenticate(EMAIL.GoogleUsername, EMAIL.GenericPassword);

                client.Inbox.Open(FolderAccess.ReadWrite);
                IMailFolder      inboxFolder = client.GetFolder("Inbox");
                IList <UniqueId> uids        = client.Inbox.Search(SearchQuery.All);

                foreach (UniqueId uid in uids)
                {
                    MimeMessage message = inboxFolder.GetMessage(uid);
                    emailSubject = message.Subject;
                    emailBody    = message.TextBody;

                    if (emailSubject.IsEmpty())
                    {
                        emailSubject = "<No Subject User Story>";
                    }

                    toCreate[RALLY.Name]        = (emailSubject);
                    toCreate[RALLY.Description] = (emailBody);
                    createUserStory             = _rallyRestApi.Create(RALLY.HierarchicalRequirement, toCreate);

                    foreach (MimeEntity attachment in message.BodyParts)
                    {
                        string attachmentFile     = attachment.ContentDisposition?.FileName ?? attachment.ContentType.Name;
                        string attachmentFilePath = Concat(STORAGE.MimeKitAttachmentsDirectory, Path.GetFileName(attachmentFile));

                        if (!IsNullOrWhiteSpace(attachmentFile))
                        {
                            if (File.Exists(attachmentFilePath))
                            {
                                string extension = Path.GetExtension(attachmentFilePath);
                                string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(attachmentFilePath);
                                attachmentFile = Format(fileNameWithoutExtension + "-{0}" + "{1}", ++anotherOne,
                                                        extension);
                                attachmentFilePath = Path.Combine(STORAGE.MimeKitAttachmentsDirectory,
                                                                  attachmentFile);
                            }

                            using (var attachmentStream = File.Create(attachmentFilePath))
                            {
                                MimeKit.MimePart part = (MimeKit.MimePart)attachment;
                                part.ContentObject.DecodeTo(attachmentStream);
                            }

                            Console.WriteLine("Downloaded: " + attachmentFile);
                        }
                    }

                    allAttachments = Directory.GetFiles(STORAGE.MimeKitAttachmentsDirectory);
                    foreach (string file in allAttachments)
                    {
                        base64String       = FileToBase64(file);
                        attachmentFileName = Path.GetFileName(file);
                        fileName           = Empty;

                        if (!(attachmentsDictionary.TryGetValue(base64String, out fileName)))
                        {
                            Console.WriteLine("Added to Dictionary: " + file);
                            attachmentsDictionary.Add(base64String, attachmentFileName);
                        }

                        File.Delete(file);
                    }

                    //for each email message - upload it to Rally
                    foreach (KeyValuePair <string, string> attachmentPair in attachmentsDictionary)
                    {
                        try
                        {
                            //create attachment content
                            attachmentContent[RALLY.Content] = attachmentPair.Key;
                            attachmentContentCreateResult    = _rallyRestApi.Create(RALLY.AttachmentContent,
                                                                                    attachmentContent);
                            userStoryReference = attachmentContentCreateResult.Reference;

                            //create attachment contianer
                            attachmentContainer[RALLY.Artifact]    = createUserStory.Reference;
                            attachmentContainer[RALLY.Content]     = userStoryReference;
                            attachmentContainer[RALLY.Name]        = attachmentPair.Value;
                            attachmentContainer[RALLY.Description] = RALLY.EmailAttachment;
                            attachmentContainer[RALLY.ContentType] = "file/";

                            //Create & associate the attachment
                            attachmentContainerCreateResult = _rallyRestApi.Create(RALLY.Attachment,
                                                                                   attachmentContainer);
                        }
                        catch (WebException e)
                        {
                            Console.WriteLine("Attachment: " + e.Message);
                        }
                    }
                    attachmentsDictionary.Clear();

                    Console.WriteLine("User Story: " + message.Subject);
                }
            }
        }
 public static void CheckNewEmail(BotUser user, bool isServiceCall)
 {
     try
     {
         Task.Factory.StartNew(() =>
         {
             var va                   = VirtualAssistant.Instance;
             var dispatcher           = VirtualAssistant.Instance.Components.Get <Dispatcher>();
             const string hostAddress = "imap.gmail.com";
             var client               = new ImapClient(hostAddress, true);
             if (client.Connect())
             {
                 var settings     = va.SettingsManager["Email"];
                 var userEmailId  = settings["Bot-Email"].Value;
                 var userPassword = SynUtility.Security.Decrypt(settings["Password"].Value);
                 //If login is successful.
                 if (client.Login(userEmailId, userPassword))
                 {
                     var message = client.Folders.Inbox.Search("UNSEEN", MessageFetchMode.Full, 1);
                     //If there are any Unseen messages.
                     if (message.Any())
                     {
                         var emailMessage = message[0];
                         dispatcher.Invoke(() =>
                         {
                             SetUserVars(user, emailMessage);
                             LastEmail = emailMessage;
                             user.Bot.Trigger("Email-New");
                             emailMessage.Seen = true;
                             message[0].Remove();
                         });
                     }
                     else //No unseen message found.
                     {
                         dispatcher.Invoke(() =>
                         {
                             if (!isServiceCall)
                             {
                                 user.Bot.Trigger("Email-No-New");
                             }
                         });
                     }
                 }
                 else
                 {
                     if (!isServiceCall)
                     {
                         dispatcher.Invoke(() =>
                         {
                             user.Bot.Trigger("Email-Login-failed");
                         });
                     }
                 }
             }
             else
             {
                 if (!isServiceCall)
                 {
                     dispatcher.Invoke(() =>
                     {
                         user.Bot.Trigger("Email-Connection-failed");
                     });
                 }
             }
         });
     }
     catch (Exception exception)
     {
         VirtualAssistant.Instance.Logger.Error(exception);
     }
 }
Beispiel #39
0
        public void ExecutePostConnectionTask()
        {
            if (File.Exists(lastMailTimestampFilename))
            {
                DateTime lastTime      = new DateTime(Convert.ToInt64(File.ReadAllText(lastMailTimestampFilename)));
                TimeSpan sinceLastTime = DateTime.Now - lastTime;
                if (sinceLastTime.TotalMinutes < 11)
                {
                    return;
                }
            }


            AzusaContext context = AzusaContext.GetInstance();

            if (!context.Ini.ContainsKey(iniCategoryName))
            {
                return;
            }

            if (context.Ini[iniCategoryName].ContainsKey("enabled"))
            {
                bool isEnabled = Convert.ToInt32(context.Ini[iniCategoryName]["enabled"]) > 0;
                if (!isEnabled)
                {
                    return;
                }
            }

            bool   allcerts = Convert.ToInt32(context.Ini[iniCategoryName]["acceptAllCerts"]) > 0;
            string server   = context.Ini[iniCategoryName]["server"];
            int    port     = context.Ini[iniCategoryName].ContainsKey(portName) ? Convert.ToUInt16(context.Ini[iniCategoryName][portName]) : 143;
            bool   useSsl   = Convert.ToInt32(context.Ini[iniCategoryName]["ssl"]) > 0;
            string username = context.Ini[iniCategoryName]["username"];
            string password = context.Ini[iniCategoryName].ContainsKey(passwordName) ? context.Ini[iniCategoryName][passwordName] : "";

            if (string.IsNullOrEmpty(password))
            {
                password = PasswordManagement.Boundary.PasswordManagement.TryGetPassword(server, username);
            }

            if (string.IsNullOrEmpty(password))
            {
                context.Splash.Invoke((MethodInvoker) delegate { password = TextInputForm.PromptPassword(String.Format("Passwort für {0} auf {1}?", username, server), context.Splash); });
                if (string.IsNullOrEmpty(password))
                {
                    return;
                }
            }


            ImapClient client = new ImapClient(new MailProtocolLogger());

            if (allcerts)
            {
                client.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
            }
            client.SslProtocols = System.Security.Authentication.SslProtocols.Tls12;
            client.Connect(server, port, useSsl);
            client.AuthenticationMechanisms.Remove("XOAUTH2");
            client.Authenticate(username, password);
            FolderNamespace     rootFolderNamespace = client.PersonalNamespaces[0];
            IList <IMailFolder> folders             = client.GetFolders(rootFolderNamespace);

            foreach (IMailFolder folder in folders)
            {
                Folder child = new Folder();
                child.id       = MakeId(folder);
                child.name     = folder.Name;
                child.parentId = MakeId(folder.ParentFolder);
                bool created = FolderService.CreateIfNotExists(child);
                CopyFolder(folder, child, !created, password);
            }
            client.Disconnect(true);

            File.WriteAllText(lastMailTimestampFilename, DateTime.Now.Ticks.ToString());
        }
Beispiel #40
0
        private async void receiveTimer_Tick(object sender, EventArgs e)
        {
            logger.Debug("Receive Timer Tick");

            bool anyPending = false;

            lock (mailItems)
            {
                foreach (MailItem mailItem in mailItems)
                {
                    if (mailItem.Status == MailItem.StatusType.Sent)
                    {
                        anyPending = true;
                        break;
                    }
                }
            }
            if (!anyPending)
            {
                logger.Debug("No pending messages to receive, returning");
                return;
            }

            receiveInfoToolStripStatusLabel.Text = "Receiving...";

            Task receiveTask = Task.Run(() =>
            {
                using (ImapClient client = Properties.Settings.Default.imapLoggingEnabled ? new ImapClient(new ProtocolLogger(Properties.Settings.Default.imapLoggingFile)) : new ImapClient())
                {
                    client.Timeout = Decimal.ToInt32(Properties.Settings.Default.imapNetworkTimeout) * 1000;
                    client.ServerCertificateValidationCallback = NoSslCertificateValidationCallback;

                    try
                    {
                        if (Properties.Settings.Default.imapSSL)
                        {
                            client.Connect(Properties.Settings.Default.imapHost, Decimal.ToInt32(Properties.Settings.Default.imapPort), MailKit.Security.SecureSocketOptions.Auto);
                        }
                        else
                        {
                            client.Connect(Properties.Settings.Default.imapHost, Decimal.ToInt32(Properties.Settings.Default.imapPort), false);
                        }

                        client.Authenticate(Properties.Settings.Default.imapLoginUsername, Properties.Settings.Default.imapLoginPassword);

                        client.Inbox.Open(FolderAccess.ReadWrite);

                        lock (mailItems)
                        {
                            foreach (MailItem mailItem in mailItems)
                            {
                                if (mailItem.Status == MailItem.StatusType.Sent)
                                {
                                    logger.Debug("Search...");
                                    IList <UniqueId> mailList = client.Inbox.Search(SearchQuery.SubjectContains(String.Format("Mail Check Client {0}", mailItem.Ticks)));
                                    if (mailList.Count == 1)
                                    {
                                        DateTime now = DateTime.Now;

                                        if (DateTime.Compare(mailItem.TimeoutTimestamp, now) < 0)
                                        {
                                            client.Inbox.AddFlags(mailList.First(), MessageFlags.Flagged, true);
                                            mailItem.Status = MailItem.StatusType.TimedOut;
                                            logger.Warn(String.Format("Found timed out mail tick {0}, mark flagged", mailItem.Ticks));
                                        }
                                        else
                                        {
                                            client.Inbox.AddFlags(mailList.First(), MessageFlags.Seen, true);
                                            mailItem.Status = MailItem.StatusType.Received;
                                            logger.Info(String.Format("Found in time mail tick {0}, mark read", mailItem.Ticks));
                                        }

                                        Action operation = () => {
                                            updateMailListViewItem(mailItem);
                                        };
                                        Invoke(operation);
                                    }
                                    else if (mailList.Count > 1)
                                    {
                                        logger.Error(String.Format("More than 1 search result for mail tick {0}!!!???", mailItem.Ticks));
                                    }
                                    else
                                    {
                                        logger.Debug(String.Format("Did not find mail tick {0} yet", mailItem.Ticks));
                                    }
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        logger.Error("Receiving mail failed", ex);
                    }
                    finally
                    {
                        client.Disconnect(true);
                    }
                }
            });

            await(receiveTask);
            receiveTask.Dispose();

            receiveInfoToolStripStatusLabel.Text = "";
        }