public bool RemoveResource(IStorageProviderSession session, ICloudFileSystemEntry resource, RemoveMode mode)
        {
            String url;
            Dictionary<String, String> parameters = null;

            if (mode == RemoveMode.FromParentCollection)
            {
                var pId = (resource.Parent != null ? resource.Parent.Id : GoogleDocsConstants.RootFolderId).ReplaceFirst("_", "%3a");
                url = String.Format("{0}/{1}/contents/{2}", GoogleDocsConstants.GoogleDocsFeedUrl, pId, resource.Id.ReplaceFirst("_", "%3a"));
            }
            else
            {
                url = String.Format(GoogleDocsConstants.GoogleDocsResourceUrlFormat, resource.Id.ReplaceFirst("_", "%3a"));
                parameters = new Dictionary<string, string> {{"delete", "true"}};
            }

            var request = CreateWebRequest(session, url, "DELETE", parameters);
            request.Headers.Add("If-Match", "*");

            try
            {
                var response = (HttpWebResponse)request.GetResponse();
                if (response.StatusCode == HttpStatusCode.OK)
                    return true;
            }
            catch (WebException)
            {
            }

            return false;
        }

 public static String GetResourcePath(ICloudFileSystemEntry parent, String nameOrId)
 {
     String path = parent != null ? parent.Id.Trim('/') : String.Empty;
     if (!String.IsNullOrEmpty(nameOrId) && !nameOrId.Equals("/"))
         path = String.Format("{0}/{1}", path, nameOrId.Trim('/'));
     return path.Trim('/');
 }

        public override bool DeleteResource(IStorageProviderSession session, ICloudFileSystemEntry entry)
        {
            // get the creds
            ICredentials creds = ((GenericNetworkCredentials) session.SessionToken).GetCredential(null, null);

            // generate the loca path
            String uriPath = GetResourceUrl(session, entry, null);

            // removed the file
            if (entry is ICloudDirectoryEntry)
            {
                // we need an empty directory
                foreach (ICloudFileSystemEntry child in (ICloudDirectoryEntry) entry)
                {
                    DeleteResource(session, child);
                }

                // remove the directory
                return _ftpService.FtpDeleteEmptyDirectory(uriPath, creds);
            }
            else
            {
                // remove the file
                return _ftpService.FtpDeleteFile(uriPath, creds);
            }
        }

        public override void RefreshResource(IStorageProviderSession session, ICloudFileSystemEntry resource)
        {
            // nothing to do for files
            if (!(resource is ICloudDirectoryEntry))
                return;

            // Refresh schild
            RefreshChildsOfDirectory(session, resource as ICloudDirectoryEntry);
        }

        public void RefreshResource(IStorageProviderSession session, ICloudFileSystemEntry resource)
        {
            var cached = FsCache.Get(GetSessionKey(session), GetCacheKey(session, null, resource), null) as ICloudDirectoryEntry;

            if (cached == null || cached.HasChildrens == nChildState.HasNotEvaluated)
            {
                _service.RefreshResource(session, resource);
                FsCache.Add(GetSessionKey(session), GetCacheKey(session, null, resource), resource);
            }
        }

 public static String GetResourcePath(ICloudFileSystemEntry parent, String nameOrId)
 {
     nameOrId = !String.IsNullOrEmpty(nameOrId) ? nameOrId.Trim('/') : String.Empty;
     var parentId = parent != null ? parent.Id.Trim('/') : String.Empty;
     if (String.IsNullOrEmpty(parentId))
         return nameOrId;
     if (String.IsNullOrEmpty(nameOrId))
         return parentId;
     return parentId + "/" + nameOrId;
 }

 public static void CopyProperties(ICloudFileSystemEntry src, ICloudFileSystemEntry dest)
 {
     if (!(dest is BaseFileEntry) || !(src is BaseFileEntry)) return;
     
     var destBase = dest as BaseFileEntry;
     var srcBase = src as BaseFileEntry;
     destBase.Name = srcBase.Name;
     destBase.Id = srcBase.Id;
     destBase.Modified = srcBase.Modified;
     destBase.Length = srcBase.Length;
     destBase[SkyDriveConstants.UploadLocationKey] = srcBase[SkyDriveConstants.UploadLocationKey];
     destBase.ParentID = srcBase.ParentID;
 }

        public static String GetResourcePath(ICloudFileSystemEntry entry)
        {
            var current = entry;
            var path = "";

            while (current != null)
            {
                if (current.Name != "/")
                {
                    if (path == String.Empty)
                        path = current.Id;
                    else
                        path = current.Id + "/" + path;
                }
                else
                    path = "/" + path;

                current = current.Parent;
            }

            return path;
        }

 public static bool OfGoogleDocsKind(ICloudFileSystemEntry entry)
 {
     var kind = entry.GetPropertyValue(GoogleDocsConstants.KindProperty);
     return kind.Equals("document") || kind.Equals("presentation") || kind.Equals("spreadsheet") || kind.Equals("drawing");
 }

 public static bool IsNoolOrRoot(ICloudFileSystemEntry dir)
 {
     return dir == null || ((dir is ICloudDirectoryEntry) && dir.Id.Equals(GoogleDocsConstants.RootFolderId));
 }

 protected File ToFile(ICloudFileSystemEntry fsEntry)
 {
     return fsEntry == null ? null
                : new File
                      {
                          ID = MakeId(fsEntry),
                          Access = FileShare.None,
                          ContentLength = fsEntry.Length,
                          CreateBy = SharpBoxProviderInfo.Owner,
                          CreateOn = fsEntry.Modified,
                          FileStatus = FileStatus.None,
                          FolderID = MakeId(fsEntry.Parent),
                          ModifiedBy = SharpBoxProviderInfo.Owner,
                          ModifiedOn = fsEntry.Modified,
                          NativeAccessor = fsEntry,
                          ProviderId = SharpBoxProviderInfo.ID,
                          ProviderName = SharpBoxProviderInfo.ProviderName,
                          Title = MakeTitle(fsEntry),
                          RootFolderId = MakeId(RootFolder()),
                          RootFolderType = SharpBoxProviderInfo.RootFolderType,
                          RootFolderCreator = SharpBoxProviderInfo.Owner,
                          Version = 1
                      };
 }

 protected string MakeId(ICloudFileSystemEntry entry)
 {
     var path = string.Empty;
     if (entry != null && !(entry is ErrorDirectoryEntry))
     {
         path = SharpBoxProviderInfo.Storage.GetFileSystemObjectPath(entry);
     }
     return string.Format("{0}{1}", PathPrefix, string.IsNullOrEmpty(path) || path == "/" ? "" : ("-" + path.Replace('/', '|')));
 }

        /// <summary>
        /// This method renames a given filesystem object (file or folder)
        /// </summary>
        /// <param name="fsentry"></param>
        /// <param name="newName"></param>
        /// <returns></returns>
        public bool RenameFileSystemEntry(ICloudFileSystemEntry fsentry, string newName)
        {
            // save the old name
            String renamedId = fsentry.Id;

            // rename the resource
            if (_Service.RenameResource(_Session, fsentry, newName))
            {
                // get the parent
                BaseDirectoryEntry p = fsentry.Parent as BaseDirectoryEntry;

                // remove the old childname
                p.RemoveChildById(renamedId);

                // readd the child
                p.AddChild(fsentry as BaseFileEntry);

                // go ahead
                return true;
            }
            else
                return false;
        }

 /// <summary>
 /// This method removes a given filesystem object from the cloud storage
 /// </summary>
 /// <param name="fsentry"></param>
 /// <returns></returns>
 public bool DeleteFileSystemEntry(ICloudFileSystemEntry fsentry)
 {
     return _Service.DeleteResource(_Session, fsentry);
 }

        public override bool CopyResource(IStorageProviderSession session, ICloudFileSystemEntry fsentry, ICloudDirectoryEntry newParent)
        {
            // build the targte url            
            String uriStringTarget = this.GetResourceUrl(session, newParent, null);
            uriStringTarget = PathHelper.Combine(uriStringTarget, fsentry.Name);

            if (!CopyResource(session, fsentry, uriStringTarget))
                return false;

            var newParentObject = newParent as BaseDirectoryEntry;
            if (newParentObject != null)
            {
                newParentObject.AddChild(fsentry as BaseFileEntry);   
            }

            return true;
        }

 public bool RenameFileSystemEntry(ICloudFileSystemEntry fsentry, string newName)
 {
     return _provider.RenameFileSystemEntry(fsentry, newName);
 }

 public string GetFileSystemObjectPath(ICloudFileSystemEntry fsObject)
 {
     return _provider.GetFileSystemObjectPath(fsObject);
 }

        /// <summary>
        /// Renames a webdave file or folder
        /// </summary>
        /// <param name="session"></param>
        /// <param name="fsentry"></param>
        /// <param name="newName"></param>
        /// <returns></returns>
        public override bool RenameResource(IStorageProviderSession session, ICloudFileSystemEntry fsentry, string newName)
        {
            // build the targte url
            String uriStringTarget = this.GetResourceUrl(session, fsentry.Parent, null);
            uriStringTarget = PathHelper.Combine(uriStringTarget, newName);

            if (MoveResource(session, fsentry, uriStringTarget))
            {
                // rename the fsentry
                BaseFileEntry fentry = fsentry as BaseFileEntry;
                fentry.Name = newName;

                // go ahead
                return true;
            }
            else
                // go ahead
                return false;
        }

 /// <summary>
 /// This method moves a specifc filesystem object from his current location
 /// into a new folder
 /// </summary>
 /// <param name="fsentry"></param>
 /// <param name="newParent"></param>
 /// <returns></returns>
 public bool CopyFileSystemEntry(ICloudFileSystemEntry fsentry, ICloudDirectoryEntry newParent)
 {
     return _Service.CopyResource(_Session, fsentry, newParent);
 }

        public override Stream CreateDownloadStream(IStorageProviderSession session, ICloudFileSystemEntry fileSystemEntry)
        {
            // build the url 
            string url = GetResourceUrl(session, fileSystemEntry, null);

            // get the session creds
            ICredentials creds = session.SessionToken as ICredentials;

            // Build the service
            DavService svc = new DavService();

            // create the webrequest
            WebRequest request = svc.CreateWebRequest(url, WebRequestMethodsEx.Http.Get, creds.GetCredential(null, null), false, null);

            // create the response
            WebResponse response = svc.GetWebResponse(request);

            // get the data 
            Stream orgStream = svc.GetResponseStream(response);

            BaseFileEntryDownloadStream dStream = new BaseFileEntryDownloadStream(orgStream, fileSystemEntry);

            // put the disposable on the stack
            dStream._DisposableObjects.Push(response);

            // go ahead
            return dStream;
        }