/// <summary>
        /// Moves an exchange public folder from source to destination - the source and detsination URI must
        /// be in the same store. This creates a new folder and copies the items in the old folder to the new
        /// folder and finally deletes the original folder. It is done this way rather than just moving the 
        /// original folder so that the destination folder doesn't have to be mail enabled if the source
        /// folder is.
        /// </summary>
        /// <param name="cookies">The cookies returned from previously authenticating.</param>
        /// <param name="sourceURI">The URI for the folder to move (must not have a / at the end).</param>
        /// <param name="destinationURI">The URI of the destination.</param>
        /// <param name="mailEnableDest">Flag to determine whether the destination folder should be mail enabled
        /// (If it already exists and is already mail enabled, this *WONT* mail disable it).</param>
        public static void MoveExchangePublicFolder(CookieCollection cookies,
                                                    string sourceURI,
                                                    string destinationURI,
                                                    bool mailEnableDest)
        {
            // Check if the destination already exists, just assume the source does.
            int lastSlashIdx = destinationURI.LastIndexOf("/");
            if (!DoesFolderExist(cookies, destinationURI.Substring(0, lastSlashIdx), destinationURI.Substring(lastSlashIdx + 1)))
            {
                CreateExchangePublicFolder(cookies, destinationURI, mailEnableDest);
            }
            UpdateExchangePublicFolderPerms(cookies, sourceURI, destinationURI, null);
 
            // Get the display names of each item underneath the sourceURI
            StringBuilder propfind = new StringBuilder();
 
            propfind.Append("<?xml version=\"1.0\"?>");
            propfind.Append("<d:propfind xmlns:d=\"DAV:\">");
            propfind.Append("<d:prop>");
            propfind.Append("<d:displayName/>");
            propfind.Append("</d:prop>");
            propfind.Append("</d:propfind>");
 
            using (HttpWebResponse response = SendPropFindRequest(cookies, sourceURI, "1", propfind.ToString()))
            {
                using (Stream stream = response.GetResponseStream())
                {
                    XmlDocument xml = new XmlDocument();
                    xml.Load(stream);
 
                    XmlNamespaceManager xmlNsManager = new XmlNamespaceManager(xml.NameTable);
                    xmlNsManager.AddNamespace("a", "DAV:");
 
                    foreach (XmlNode node in xml.DocumentElement.ChildNodes)
                    {
                        XmlNode itemHrefNode = node.SelectSingleNode("a:href", xmlNsManager);
 
                        // Decode the item uri and remove a trailing slash if one exists (any folders will 
                        // have one)
                        string itemSourceUri = Uri.UnescapeDataString(itemHrefNode.InnerXml);
                        if (itemSourceUri.ToCharArray()[itemSourceUri.Length - 1] == '/')
                        {
                            itemSourceUri = itemSourceUri.Substring(0, itemSourceUri.Length - 1);
                        }
 
                        // The source folder will be returned by the propfind, so just ignore that as we have 
                        // already created it
                        if (itemSourceUri != sourceURI)
                        {
                            MoveExchangePublicFolderItem(
                                cookies,
                                itemHrefNode.InnerXml,
                                string.Concat(destinationURI, itemSourceUri.Substring(itemSourceUri.LastIndexOf("/"))));
                        }
                    }
                }
            }
 
            // Finally delete the source folder
            HttpWebResponse delResponse = SendRequest(cookies, sourceURI, "DELETE", null, null);
            delResponse.Close();
        }
 
        /// <summary>
        /// Moves an exchange item.
        /// </summary>
        /// <param name="cookies">The cookies returned from previously authenticating.</param>
        /// <param name="sourceURI">The URI of the thing to move.</param>
        /// <param name="destinationURI">The new URI.</param>
        private static void MoveExchangePublicFolderItem(CookieCollection cookies,
                                                         string sourceURI,
                                                         string destinationURI)
        {
            IDictionary<string, string> headers = new Dictionary<string, string>();
            headers.Add("Destination", destinationURI);
 
            HttpWebResponse response = SendRequest(cookies, sourceURI, "MOVE", headers, null);
            response.Close();
        }
 
        /// <summary>
        /// Checks whether a folder exists.
        /// </summary>
        /// <param name="cookies">The cookies returned from previously authenticating.</param>
        /// <param name="parentURI">The parent URI to check whether the folder exists beneath it.</param>
        /// <param name="displayName">The name of the folder to search for.</param>
        /// <returns>true if the folder exists.</returns>
        public static Boolean DoesFolderExist(CookieCollection cookies, string parentURI, string displayName)
        {
            using (HttpWebResponse response = SendPropFindRequest(cookies, parentURI, "1", null))
            {
                using (Stream stream = response.GetResponseStream())
                {
                    XmlDocument xmlDoc = new XmlDocument();
                    xmlDoc.Load(stream);
 
                    XmlNodeList nodes = xmlDoc.GetElementsByTagName("a:displayname");
 
                    foreach (XmlNode node in nodes)
                    {
                        if (node.InnerText == displayName)
                        {
                            return true;
                        }
                    }
                    return false;
                }
            }
        }