/// <summary>
        /// Routine that attempts to resend emails that previously failed.
        /// </summary>
        /// <returns>List of emails that were successfully resent.</returns>
        /// <remarks>Uses internally maintained queue of emails that failed to send.</remarks>
        public PFListEx <stEmailArchiveEntry> ResendEmails()
        {
            PFListEx <stEmailArchiveEntry> successfulResends = new PFListEx <stEmailArchiveEntry>();
            PFListEx <stEmailArchiveEntry> failedResends     = new PFListEx <stEmailArchiveEntry>();

            _emailResendQueue = PFListEx <stEmailArchiveEntry> .LoadFromXmlFile(_emailResendQueueFile);

            _emailLastResendList.Clear();

            foreach (stEmailArchiveEntry emailEntry in _emailResendQueue)
            {
                stEmailSendResult res = this.SendEmail(emailEntry.emailMessage, false);

                if (res.emailSendResult == enEmailSendResult.Success)
                {
                    stEmailArchiveEntry successEntry = new stEmailArchiveEntry(res, emailEntry.emailMessage);
                    successEntry.numRetries       = emailEntry.numRetries + 1;
                    successEntry.firstSendAttempt = emailEntry.firstSendAttempt;
                    successEntry.lastSendAttempt  = DateTime.Now;
                    successfulResends.Add(successEntry);
                }
                else
                {
                    stEmailArchiveEntry failedEntry = new stEmailArchiveEntry(res, emailEntry.emailMessage);
                    failedEntry.firstSendAttempt = emailEntry.firstSendAttempt;
                    failedEntry.lastSendAttempt  = DateTime.Now;
                    failedEntry.numRetries       = emailEntry.numRetries + 1;
                    failedResends.Add(failedEntry);
                }
            }

            _emailResendQueue.Clear();
            if (failedResends.Count > 0)
            {
                foreach (stEmailArchiveEntry entry in failedResends)
                {
                    if (entry.numRetries < _maxNumResendAttempts)
                    {
                        stEmailArchiveEntry newEntry = new stEmailArchiveEntry(entry.sendResult, entry.emailMessage);
                        newEntry.firstSendAttempt = entry.firstSendAttempt;
                        newEntry.lastSendAttempt  = entry.lastSendAttempt;
                        newEntry.numRetries       = entry.numRetries;
                        _emailResendQueue.Add(newEntry);
                    }
                    else
                    {
                        stEmailArchiveEntry lastEntry = new stEmailArchiveEntry(entry.sendResult, entry.emailMessage);
                        lastEntry.firstSendAttempt = entry.firstSendAttempt;
                        lastEntry.lastSendAttempt  = entry.lastSendAttempt;
                        lastEntry.numRetries       = entry.numRetries;
                        _emailLastResendList.Add(lastEntry);
                    }
                }
            }

            _emailResendQueue.SaveToXmlFile(_emailResendQueueFile);

            return(successfulResends);
        }
        private void InitInstance()
        {
            if (File.Exists(_emailResendQueueFile) == false)
            {
                _emailResendQueue.SaveToXmlFile(_emailResendQueueFile);
            }

            _emailResendQueue = PFListEx <stEmailArchiveEntry> .LoadFromXmlFile(_emailResendQueueFile);
        }
Exemple #3
0
        private void InitInstance(enLogFileStorageType logFileStorageType, string logFileConnectionString,
                                  enLogRetryQueueStorageType logRetryQueueStorageType, string logRetryQueueConnectionString)
        {
            _logFileStorageType            = logFileStorageType;
            _logFileConnectionString       = logFileConnectionString;
            _logRetryQueueStorageType      = logRetryQueueStorageType;
            _logRetryQueueConnectionString = logRetryQueueConnectionString;

            if (_logFileStorageType == enLogFileStorageType.Database)
            {
                string dbFilename = _logFileConnectionString.Replace("data source='", "").Replace("'", "");
                if (File.Exists(dbFilename) == false)
                {
                    CreateLogDb(_logFileConnectionString);
                }
            }
            else // (_logFileStorageType == enLogFileStorageType.TextFile)
            {
                if (File.Exists(_logFileConnectionString) == false)
                {
                    FileStream fs = File.Create(_logFileConnectionString);
                    fs.Close();
                }
            }

            if (_logRetryQueueStorageType == enLogRetryQueueStorageType.Database)
            {
                string dbFilename = _logRetryQueueConnectionString.Replace("data source='", "").Replace("'", "");
                if (File.Exists(dbFilename) == false)
                {
                    CreateRetryQueueDb(_logRetryQueueConnectionString);
                    SaveRetryQueue();
                }
                //_logRetryQueueDatabaseListName = Path.GetFileNameWithoutExtension(_applicationName) + "_" + _logRetryQueueDatabaseListName;
                //throw new System.Exception("Database retry queue not yet implemented.");
            }
            else // enLogRetryQueueStorageType.XmlFile
            {
                if (File.Exists(_logRetryQueueConnectionString) == false)
                {
                    //create the retry queue
                    _logRetryQueue.SaveToXmlFile(_logRetryQueueConnectionString);
                }
            }

            if (_logRetryQueueStorageType == enLogRetryQueueStorageType.Database)
            {
                _logRetryQueue = PFListEx <PFLogMessage> .LoadFromDatabase(_logRetryQueueConnectionString, _logRetryQueueDatabaseListName);
            }
            else
            {
                _logRetryQueue = PFListEx <PFLogMessage> .LoadFromXmlFile(_logRetryQueueConnectionString);
            }
        }
Exemple #4
0
        public static void ResendEmailsTest(MainForm frm)
        {
            PFEmailManager emMgr;
            string         connectionString = string.Empty;
            string         configValue      = string.Empty;

            try
            {
                _msg.Length = 0;
                _msg.Append("ResendEmailsTest started ...\r\n");
                Program._messageLog.WriteLine(_msg.ToString());

                configValue = AppConfig.GetStringValueFromConfigFile("EmailResendQueueDatabaseConnectionString", string.Empty);
                if (configValue.Length > 0)
                {
                    _emailResendQueueDatabaseConnectionString = configValue;
                }

                emMgr = new PFEmailManager(@"c:\temp\EmailResendQueue.xml");

                PFListEx <stEmailArchiveEntry> successfulResends = emMgr.ResendEmails();

                _msg.Length = 0;
                _msg.Append("Number of successful resends: ");
                _msg.Append(successfulResends.Count());
                Program._messageLog.WriteLine(_msg.ToString());


                _msg.Length = 0;
                _msg.Append("Number of failed resends:     ");
                _msg.Append(emMgr.EmailResendQueue.Count());
                Program._messageLog.WriteLine(_msg.ToString());

                for (int i = 0; i < emMgr.EmailResendQueue.Count; i++)
                {
                    stEmailArchiveEntry em = emMgr.EmailResendQueue[i];
                    _msg.Length = 0;
                    _msg.Append("Attempt to send email to server ");
                    _msg.Append(em.emailMessage.SMTPServer);
                    _msg.Append(" failed. Retry count = ");
                    _msg.Append(em.numRetries.ToString());
                    Program._messageLog.WriteLine(_msg.ToString());
                }

                _msg.Length = 0;
                _msg.Append("Number of last resends:       ");
                _msg.Append(emMgr.EmailLastResendList.Count());
                Program._messageLog.WriteLine(_msg.ToString());

                for (int i = 0; i < emMgr.EmailLastResendList.Count; i++)
                {
                    stEmailArchiveEntry em = emMgr.EmailLastResendList[i];
                    _msg.Length = 0;
                    _msg.Append("Final attempt to send email to server ");
                    _msg.Append(em.emailMessage.SMTPServer);
                    _msg.Append(" failed. Retry count = ");
                    _msg.Append(em.numRetries.ToString());
                    Program._messageLog.WriteLine(_msg.ToString());
                }
            }
            catch (System.Exception ex)
            {
                _msg.Length = 0;
                _msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
                Program._messageLog.WriteLine(_msg.ToString());
                AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
            }
            finally
            {
                _msg.Length = 0;
                _msg.Append("\r\n... ResendEmailsTest finished.");
                Program._messageLog.WriteLine(_msg.ToString());
            }
        }
Exemple #5
0
        public static void KeyValueListMergeTest()
        {
            PFKeyValueListEx <int, string> list1 = new PFKeyValueListEx <int, string>();
            PFKeyValueListEx <int, string> list2 = new PFKeyValueListEx <int, string>();
            PFKeyValueListEx <int, string> list3 = new PFKeyValueListEx <int, string>();

            try
            {
                _msg.Length = 0;
                _msg.Append("KeyValueListMergeTest started ...\r\n");
                Program._messageLog.WriteLine(_msg.ToString());

                list1.Add(new pfKeyValuePair <int, string>(1, "First"));
                list1.Add(new pfKeyValuePair <int, string>(2, "Second"));
                list1.Add(new pfKeyValuePair <int, string>(3, "Third"));

                list2.Add(new pfKeyValuePair <int, string>(4, "fourth"));
                list2.Add(new pfKeyValuePair <int, string>(5, "fifth"));
                list2.Add(new pfKeyValuePair <int, string>(6, "sixth"));

                list3.Add(new pfKeyValuePair <int, string>(7, "Seventh"));
                list3.Add(new pfKeyValuePair <int, string>(8, "Eighth"));
                list3.Add(new pfKeyValuePair <int, string>(9, "Ninth"));
                list3.Add(new pfKeyValuePair <int, string>(10, "Tenth"));

                PFKeyValueListEx <int, string>[]           listArray   = { list1, list2, list3 };
                PFListEx <PFKeyValueListEx <int, string> > listOfLists = new PFListEx <PFKeyValueListEx <int, string> >();
                listOfLists.Add(list1);
                listOfLists.Add(list2);
                listOfLists.Add(list3);

                PFKeyValueListEx <int, string> concatListFromArray = PFKeyValueListEx <int, string> .ConcatenateLists(listArray);

                _msg.Length = 0;
                _msg.Append(Environment.NewLine);
                _msg.Append("Concatenated list from Array");
                _msg.Append(Environment.NewLine);
                _msg.Append(concatListFromArray.ToXmlString());
                Program._messageLog.WriteLine(_msg.ToString());


                PFKeyValueListEx <int, string> concatListFromList = PFKeyValueListEx <int, string> .ConcatenateLists(listOfLists);

                _msg.Length = 0;
                _msg.Append(Environment.NewLine);
                _msg.Append("Concatenated list from List");
                _msg.Append(Environment.NewLine);
                _msg.Append(concatListFromList.ToXmlString());
                Program._messageLog.WriteLine(_msg.ToString());

                PFKeyValueListEx <int, string> mergedList = list1.Merge(list2);
                _msg.Length = 0;
                _msg.Append(Environment.NewLine);
                _msg.Append("Merged list");
                _msg.Append(Environment.NewLine);
                _msg.Append(mergedList.ToXmlString());
                Program._messageLog.WriteLine(_msg.ToString());

                mergedList.Clear();
                mergedList = list3.Merge(new PFKeyValueListEx <int, string>[2] {
                    list1, list2
                });
                _msg.Length = 0;
                _msg.Append(Environment.NewLine);
                _msg.Append("Merged list from Array");
                _msg.Append(Environment.NewLine);
                _msg.Append(mergedList.ToXmlString());
                Program._messageLog.WriteLine(_msg.ToString());

                mergedList.Clear();
                mergedList = list3.Merge(new PFListEx <PFKeyValueListEx <int, string> > {
                    list2, list1
                });
                _msg.Length = 0;
                _msg.Append(Environment.NewLine);
                _msg.Append("Merged list from List");
                _msg.Append(Environment.NewLine);
                _msg.Append(mergedList.ToXmlString());
                Program._messageLog.WriteLine(_msg.ToString());
            }
            catch (System.Exception ex)
            {
                _msg.Length = 0;
                _msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
                Program._messageLog.WriteLine(_msg.ToString());
                AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
            }
            finally
            {
                _msg.Length = 0;
                _msg.Append("\r\n... KeyValueListMergeTest finished.");
                Program._messageLog.WriteLine(_msg.ToString());
            }
        }
Exemple #6
0
        //tests

        public static void GenericListTest()
        {
            PFListEx <string> testList         = new PFListEx <string>();
            PFListEx <string> testList2        = new PFListEx <string>();
            PFListEx <string> testList3        = new PFListEx <string>();
            PFListEx <string> testList4        = new PFListEx <string>();
            string            testListXmlFile  = @"c:\temp\testlist.xml";
            string            connectionString = string.Empty;
            string            configValue      = string.Empty;

            try
            {
                _msg.Length = 0;
                _msg.Append("GenericListTest started ...");
                Program._messageLog.WriteLine(_msg.ToString());

                configValue = AppConfig.GetStringValueFromConfigFile("ListsDatabaseFile", string.Empty);
                if (configValue.Length > 0)
                {
                    connectionString = configValue;
                }
                else
                {
                    connectionString = _listsDatabaseConnectionString;
                }


                _msg.Length = 0;
                _msg.Append("First = ");
                _msg.Append(testList.FirstItem == null ? "<null>" : testList.FirstItem);
                Program._messageLog.WriteLine(_msg.ToString());

                testList.Add("First item");
                testList.Add("Second item");
                testList.Add("Third item");

                _msg.Length = 0;
                _msg.Append("Number of items in list: ");
                Program._messageLog.WriteLine(_msg.ToString());

                foreach (string s in testList)
                {
                    _msg.Length = 0;
                    _msg.Append(s);
                    Program._messageLog.WriteLine(_msg.ToString());
                }

                _msg.Length = 0;
                _msg.Append("First = ");
                _msg.Append(testList.FirstItem);
                Program._messageLog.WriteLine(_msg.ToString());

                _msg.Length = 0;
                _msg.Append("Last = ");
                _msg.Append(testList.LastItem);
                Program._messageLog.WriteLine(_msg.ToString());


                _msg.Length = 0;
                _msg.Append("NextItem loop: ");
                Program._messageLog.WriteLine(_msg.ToString());

                string res = testList.FirstItem;
                while (!testList.EOF)
                {
                    _msg.Length = 0;
                    _msg.Append(res);
                    Program._messageLog.WriteLine(_msg.ToString());
                    res = testList.NextItem;
                }

                _msg.Length = 0;
                _msg.Append("PrevItem loop: ");
                Program._messageLog.WriteLine(_msg.ToString());

                res = testList.LastItem;
                while (!testList.EOF)
                {
                    _msg.Length = 0;
                    _msg.Append(res);
                    Program._messageLog.WriteLine(_msg.ToString());
                    res = testList.PrevItem;
                }

                _msg.Length = 0;
                _msg.Append("ToString Test: ");
                Program._messageLog.WriteLine(_msg.ToString());

                _msg.Length = 0;
                _msg.Append(testList.ToString());
                Program._messageLog.WriteLine(_msg.ToString());

                _msg.Length = 0;
                _msg.Append("SaveToXmlFile Test: ");
                _msg.Append(testListXmlFile);
                Program._messageLog.WriteLine(_msg.ToString());

                testList.SaveToXmlFile(testListXmlFile);

                _msg.Length = 0;
                _msg.Append("LoadFromXmlFile Test: ");
                _msg.Append(testListXmlFile);
                Program._messageLog.WriteLine(_msg.ToString());

                testList2 = PFListEx <string> .LoadFromXmlFile(testListXmlFile);

                _msg.Length = 0;
                _msg.Append("testList2 ToString Test: ");
                Program._messageLog.WriteLine(_msg.ToString());
                _msg.Length = 0;
                _msg.Append(testList2.ToString());
                Program._messageLog.WriteLine(_msg.ToString());

                //save and read to database tests next
                testList.SaveToDatabase(connectionString, "TestprogListObjects_testList");

                testList3 = PFListEx <string> .LoadFromDatabase(connectionString, "TestprogListObjects_testList");

                _msg.Length = 0;
                _msg.Append("testList3 ToXmlString Test: ");
                Program._messageLog.WriteLine(_msg.ToString());
                _msg.Length = 0;
                _msg.Append(testList3.ToXmlString());
                Program._messageLog.WriteLine(_msg.ToString());


                _msg.Length = 0;
                _msg.Append(Environment.NewLine);
                _msg.Append("testList4 Sort Test: ");
                Program._messageLog.WriteLine(_msg.ToString());

                testList4.Add("First item");
                testList4.Add("ZFourth item");
                testList4.Add("Third item");
                testList4.Add("Second item");

                _msg.Length = 0;
                _msg.Append("Number of items in list4: ");
                Program._messageLog.WriteLine(_msg.ToString());

                _msg.Length = 0;
                _msg.Append("List4 Before Sort: ");
                Program._messageLog.WriteLine(_msg.ToString());

                foreach (string s in testList4)
                {
                    _msg.Length = 0;
                    _msg.Append(s);
                    Program._messageLog.WriteLine(_msg.ToString());
                }

                testList4.Sort();

                _msg.Length = 0;
                _msg.Append(Environment.NewLine);
                _msg.Append("List4 After Sort: ");
                Program._messageLog.WriteLine(_msg.ToString());

                foreach (string s in testList4)
                {
                    _msg.Length = 0;
                    _msg.Append(s);
                    Program._messageLog.WriteLine(_msg.ToString());
                }

                Program._messageLog.WriteLine(Environment.NewLine);
            }
            catch (System.Exception ex)
            {
                _msg.Length = 0;
                _msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
                Program._messageLog.WriteLine(_msg.ToString());
                AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog);
            }
            finally
            {
                _msg.Length = 0;
                _msg.Append("... GenericListTest finished.");
                Program._messageLog.WriteLine(_msg.ToString());
            }
        }//end GenericListTest