Пример #1
0
        /// <summary>
        /// Main constructor.
        /// </summary>
        /// <param name="config">The configuration instance to use for this client</param>
        /// <param name="logger">Custom logger to use with this client. Use null for default logger.</param>
        public IMAPClient(IMAPConfig config, IMAPLogger logger, int maxWorkers)
        {
            _config = config;
            _imap   = new IMAP();

            _logger = logger ?? new IMAPLogger(config);
            //_imap.InfoLogged += Log;
            _imap.Logger = _logger;
            _folders     = new IMAPFolderCollection();

            Log(IMAPBase.LogTypeEnum.IMAP, "------------------------------------------------------");
            Log(IMAPBase.LogTypeEnum.INFO, "InterIMAP Client Initialized");

            if (config.CacheFile != String.Empty)
            {
                this.UsingCache = true;
                Log(IMAPBase.LogTypeEnum.INFO, String.Format("Using Local Cache File: {0}", config.CacheFile));
            }

            if (config.AutoLogon)
            {
                Logon();
            }

            if (UsingCache)
            {
                FileInfo finfo = new FileInfo(config.CacheFile);
                if (finfo.Exists)
                {
                    // this config has a cache file specified. Load the cache into the object model

                    LoadCache();
                    if (!OfflineMode && config.AutoSyncCache)
                    {
                        SyncCache();
                    }
                }
                else
                {
                    _folders.Clear();
                    _folders = _imap.ProcessFolders(_config.DefaultFolderName);
                    //IMAPFolderCollection tempFolders = _imap.ProcessFolders(_config.DefaultFolderName);
                    foreach (IMAPFolder f in _folders)
                    {
                        f.SetClient(this);
                        if (_config.AutoGetMsgID)
                        {
                            f.GetMessageIDs(false);
                        }
                    }



                    BuildNewCache();
                }
            }
        }
Пример #2
0
 /// <summary>
 /// Alternate Constructor
 /// </summary>
 /// <param name="name"></param>
 /// <param name="parent"></param>
 public IMAPFolder(string name, string parent)
 {
     _subFolders       = new IMAPFolderCollection();
     _parentFolder     = null;
     _folderName       = name;
     _parentFolderName = parent;
     _folderPath       = String.Empty;
     _messages         = new IMAPMessageCollection();
     _quota            = new IMAPFolderQuota();
 }
Пример #3
0
 /// <summary>
 /// Helper method for recursively adding all folders from the source folder structure into the flat list
 /// </summary>
 /// <param name="currentFolder"></param>
 /// <param name="master"></param>
 private void FolderRecurser(IMAPFolder currentFolder, ref IMAPFolderCollection master)
 {
     if (currentFolder.SubFolders.Count > 0)
     {
         foreach (IMAPFolder f in currentFolder.SubFolders)
         {
             master.Add(f);
             FolderRecurser(f, ref master);
         }
     }
 }
Пример #4
0
        /// <summary>
        /// Takes the multi-level folder structure and flattens it into a single list of all folders
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        private IMAPFolderCollection FlattenFolderList(IMAPFolderCollection list)
        {
            IMAPFolderCollection newList = new IMAPFolderCollection();

            foreach (IMAPFolder f in list)
            {
                FolderRecurser(f, ref newList);

                newList.Add(f);
            }

            return(newList);
        }
Пример #5
0
        /// <summary>
        /// Searches the entire tree structure of the provided folder collection looking for a folder with
        /// the specified path. if it finds the folder, it is stored in the foundFolder parameter
        /// </summary>
        /// <param name="path"></param>
        /// <param name="sourceList"></param>
        /// <param name="foundFolder"></param>
        public void FindFolder(string path, ref IMAPFolderCollection sourceList, ref IMAPFolder foundFolder)
        {
            if (sourceList.Count == 0)
            {
                return;
            }

            foreach (IMAPFolder f in sourceList)
            {
                if (f.FolderPath.Equals(path))
                {
                    foundFolder = f;
                    return;
                }
                IMAPFolderCollection fc = f.SubFolders;
                FindFolder(path, ref fc, ref foundFolder);
            }
        }
Пример #6
0
        /// <summary>
        /// Loads the specified local cache into the object model
        /// </summary>
        public void LoadCache()
        {
            Log(IMAPBase.LogTypeEnum.INFO, "Loading Local Cache...");

            //try
            //{
            Stream     s = File.Open(_config.CacheFile, FileMode.Open);
            IMAPClient c = new IMAPClient();

            switch (_config.Format)
            {
            case CacheFormat.XML:
            {
                XmlSerializer xml = new XmlSerializer(typeof(IMAPClient));
                c = (IMAPClient)xml.Deserialize(s);
                break;
            }

            case CacheFormat.Binary:
            {
                BinaryFormatter b = new BinaryFormatter();
                c = (IMAPClient)b.Deserialize(s);
                break;
            }
            }

            this._folders = c.Folders;
            foreach (IMAPFolder f in _folders)
            {
                f.SetClient(this);
                f.SetParent(null);
            }

            s.Close();
            //}
            //catch (Exception e)
            //{
            //    throw e;
            //}

            Log(IMAPBase.LogTypeEnum.INFO, String.Format("Cache loaded ({0} messages found, in {1} folders)", this.TotalMessages, this.FolderCount));
        }
Пример #7
0
        /// <summary>
        /// Login using currently specified connection settings. Called automatically if AutoLogon is true.
        /// </summary>
        public void Logon()
        {
            if (this.LoggedOn || this._config == null)
            {
                return;
            }



            if (!_imap.Login(_config.Host, _config.UserName, _config.Password, _config.UseSSL))
            {
                if (!UsingCache)
                {
                    Log(IMAPBase.LogTypeEnum.ERROR, "Cannot connect to server and no cache is available. System cannot proceed. Quiting...");
                    throw new IMAPException(IMAPException.IMAPErrorEnum.IMAP_ERR_CONNECT);
                }
                OfflineMode = true;
                Log(IMAPBase.LogTypeEnum.WARN, "Login Failed. Switching to Offline Mode");
                return;
            }

            Log(IMAPBase.LogTypeEnum.INFO, "Login Successful");

            if (!UsingCache)
            {
                XmlDocument doc = new XmlDocument();
                _folders.Clear();
                _folders = _imap.ProcessFolders(_config.DefaultFolderName);
                foreach (IMAPFolder f in _folders)
                {
                    f.SetClient(this);
                    if (_config.AutoGetMsgID)
                    {
                        f.GetMessageIDs(false);
                    }
                }
            }
        }
Пример #8
0
        /// <summary>
        /// Synchronizes the local cache with the server
        /// </summary>
        public void SyncCache()
        {
            if (this.OfflineMode)
            {
                return;
            }

            if (!this.UsingCache)
            {
                return;
            }

            // to synchronize the cache without having to download everything all over again,
            // we first get the folder list from the server. We then look at each folder in the server list
            // and see if it already exists in the client list. if it does not, we add it and pull
            // the message UIDs for it.

            // then we check the client list and see if all of those folders are still on the server
            // if not, the folder on the client side is removed, all with all of its messages

            // keep track of newly added folders so their contents can be downloaded.

            // next we iterate through all the existing folders and check for any new messages.
            // this is accomplished by simply calling the GetMessageIDs method on the folder. this will
            // update the folder with any UIDs that dont already exist.
            // the messages content will be loaded automatically when it is serialized.
            Log(IMAPBase.LogTypeEnum.INFO, "Synching Cache...");
            IMAPFolderCollection serverFolderList = _imap.RawFolderList;
            IMAPFolderCollection clientFolderList = FlattenFolderList(_folders);

            IMAPFolderCollection newFolderList = new IMAPFolderCollection();
            IMAPFolderCollection oldFolderList = new IMAPFolderCollection();


            foreach (IMAPFolder f in serverFolderList)
            {
                bool found = false;

                foreach (IMAPFolder cf in clientFolderList)
                {
                    if (cf.FolderPath.Equals(f.FolderPath))
                    {
                        found = true;
                    }
                }

                if (!found)
                {
                    newFolderList.Add(f);
                }
            }

            foreach (IMAPFolder f in clientFolderList)
            {
                bool found = false;

                foreach (IMAPFolder sf in serverFolderList)
                {
                    if (sf.FolderPath.Equals(f.FolderPath))
                    {
                        found = true;
                    }
                }

                if (!found)
                {
                    oldFolderList.Add(f);
                }
            }

            if (oldFolderList.Count > 0)
            {
                Log(IMAPBase.LogTypeEnum.INFO, String.Format("{0} old folders found", newFolderList.Count));
                foreach (IMAPFolder f in oldFolderList)
                {
                    IMAPFolder temp = null;
                    FindFolder(f.FolderPath, ref _folders, ref temp);

                    if (temp != null)
                    {
                        if (temp.ParentFolder == null)
                        {
                            _folders.Remove(temp);
                        }
                        else
                        {
                            temp.ParentFolder.SubFolders.Remove(temp);
                        }
                    }
                }
            }

            if (newFolderList.Count > 0)
            {
                Log(IMAPBase.LogTypeEnum.INFO, String.Format("{0} new folders found", newFolderList.Count));

                // now we need to put these new folders into the proper locations in the tree.
                foreach (IMAPFolder f in newFolderList)
                {
                    f.GetMessageIDs(false);
                    foreach (IMAPFolder sf in serverFolderList)
                    {
                        if (sf.FolderName.Equals(f.ParentFolderName))
                        {
                            f.ParentFolder = sf;
                            break;
                        }
                    }
                    // if the new folder has no parent assigned to it then we just add it to the root folders
                    if (f.ParentFolderName == String.Empty)
                    {
                        _folders.Add(f);
                    }
                    else
                    {
                        // otherwise we just loop through the flat list we created
                        // and find the folder that is the parent of the current new folder
                        // we then add the new folder to the sub folders of its parent
                        foreach (IMAPFolder cf in clientFolderList)
                        {
                            if (cf.FolderPath.Equals(f.ParentFolder.FolderPath))
                            {
                                cf.SubFolders.Add(f);
                                f.ParentFolder = cf;
                                break;
                            }
                        }
                    }
                }
            }

            foreach (IMAPFolder f in clientFolderList)
            {
                // this will get the UIDs of any new messages that have been added to the folder on the server
                f.GetMessageIDs(false);
            }

            UpdateCache(false);
            Log(IMAPBase.LogTypeEnum.INFO, "Cache Synchronization Complete");
        }
Пример #9
0
 /// <summary>
 /// Default constructor. Only used for deserialization purposes.
 /// </summary>
 public IMAPClient()
 {
     _config  = null;
     _imap    = new IMAP();
     _folders = new IMAPFolderCollection();
 }