FileExplorer & Absolute Paths

[Edward]

Hi,
I have recently started using the FileExplorer control for a file manager within our backend. Our system works with absolute paths (instead of relative), hence I implemented a custom FileBrowserContentProvider.

Everything works fine except for one single thing: when renaming a file from, for example, 'NewFileName.jpg' to 'File1.jpg', the file is renamed to 'NewFileName.jpgFile1.jpg' (the old file name and new file name are concatenated). This issue is only present withfile renaming. File move, directory move and directory rename all work fine. The parameter newPath in the MoveFile function within the content provider is already being supplied in a wrong manner (already concatenated). When I implemented the OnClientMove JavaScript function, the args.get_newPath(), however, was being shown as the proper new final.

I have no idea what else I can check for this to see what's going wrong. I attached my custom FileBrowserContentProvider hoping it may help.

Thanks,
Edward

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Telerik.Web.UI.Widgets;
using System.Drawing.Imaging;
using System.Collections;
using System.IO;
using System.Drawing;
using Telerik.Web.UI;
using ICON.Management.Framework.LinqContexts;
using Icon.Common.Data;
using System.Text;

namespace ICON.Management.Framework.MediaLibrary
{
    public class IconFileBrowserContentProvider : FileBrowserContentProvider
    {
        #region DirectoryLister
        private class DirectoryLister
        {
            public DirectoryLister(IconFileBrowserContentProvider contentProvider, bool includeFiles, bool includeDirectories)
            {
                _contentProvider = contentProvider;

                _includeFiles = includeFiles;
                _includeDirectories = includeDirectories;
            }


            protected bool IsParentOf(string virtualParent, string virtualChild)
            {
                return _contentProvider.IsParentOf(virtualParent, virtualChild);
            }

            protected FileItem[] GetFiles(DirectoryInfo directory, PathPermissions permissions, string location)
            {
                ArrayList files = new ArrayList();
                Hashtable fileNames = new Hashtable();
                foreach (string searchPattern in _contentProvider.SearchPatterns)
                {
                    FileInfo[] fs = directory.GetFiles(searchPattern);
                    for (int i = 0; i < fs.Length; i++)
                    {
                        FileInfo file = fs[i];
                        if (!fileNames.ContainsKey(file.FullName) && _contentProvider.IsValid(file))
                        {
                            fileNames.Add(file.FullName, string.Empty);

                            //In list mode we need the tag because with the different folder structure
                            // we are unable to build proper urls for the files
                            string tag = IsListMode ? location + file.Name : string.Empty;

                            files.Add(new FileItem(file.Name, file.Extension, file.Length, string.Empty, string.Empty, tag, permissions));
                        }
                    }
                }
                return (FileItem[])files.ToArray(typeof(FileItem));
            }

            protected DirectoryItem[] GetDirectories(DirectoryInfo directory, string parentPath)
            {
                DirectoryInfo[] dirs = directory.GetDirectories();
                ArrayList directories = new ArrayList();
                for (int i = 0; i < dirs.Length; i++)
                {
                    DirectoryInfo dir = dirs[i];
                    if (_contentProvider.IsValid(dir))
                    {
                        directories.Add(GetDirectory(dir, VirtualPathUtility.AppendTrailingSlash(parentPath) + dir.Name));
                    }
                }
                return (DirectoryItem[])directories.ToArray(typeof(DirectoryItem));
            }


            public DirectoryItem GetDirectory(DirectoryInfo dir, string virtualName, string location, string fullPath, string tag)
            {
                PathPermissions permissions = _contentProvider.GetPermissions(fullPath);

                bool includeDirectories = IsListMode ? IncludeDirectories : IsParentOf(fullPath, SelectedUrl);
                bool includeFiles = IsParentOf(fullPath, SelectedUrl);

                DirectoryItem[] subdirectories = IncludeDirectories ? GetDirectories(dir, fullPath) : new DirectoryItem[] { };
                FileItem[] files = IncludeFiles ? GetFiles(dir, permissions, fullPath + "\\") : new FileItem[] { };

                DirectoryItem item = new DirectoryItem(virtualName, location, fullPath, tag, permissions, files, subdirectories);
                item.Attributes.Add("Date Created", DateTime.Now.ToString());

                return item;
            }

            public DirectoryItem GetDirectory(DirectoryInfo dir, string fullPath)
            {
                string tag = IsListMode ? fullPath : string.Empty;
                return GetDirectory(dir, dir.Name, string.Empty, fullPath, tag);
            }


            protected bool IsListMode
            {
                get
                {
                    return false;
                }
            }

            protected string SelectedUrl
            {
                get
                {
                    return _contentProvider.SelectedUrl;
                }
            }


            protected bool IncludeFiles
            {
                get
                {
                    return _includeFiles;
                }
            }

            protected bool IncludeDirectories
            {
                get
                {
                    return _includeDirectories;
                }
            }

            private IconFileBrowserContentProvider _contentProvider;
            private bool _includeFiles;
            private bool _includeDirectories;
        }

        #endregion

        #region DirectoryFlattener
        private class DirectoryFlattener
        {
            private ArrayList _directories = new ArrayList();

            public DirectoryFlattener(DirectoryItem item)
            {
                if (item == null)
                {
                    return;
                }

                Flatten(item);

                _directories.Add(item);
            }

            private void Flatten(DirectoryItem item)
            {
                foreach (DirectoryItem subdirectory in item.Directories)
                {
                    Flatten(subdirectory);
                }

                _directories.AddRange(item.Directories);

                item.ClearDirectories();
            }

            public DirectoryItem[] Directories
            {
                get
                {
                    return (DirectoryItem[])_directories.ToArray(typeof(DirectoryItem));
                }
            }
        }

        #endregion

        public IconFileBrowserContentProvider(HttpContext context, string[] searchPatterns, string[] viewPaths, string[] uploadPaths, string[] deletePaths, string selectedUrl, string selectedItemTag)
            : base(context, searchPatterns, viewPaths, uploadPaths, deletePaths, selectedUrl, selectedItemTag)
        {
            ProcessPaths(ViewPaths);
            ProcessPaths(UploadPaths);
            ProcessPaths(DeletePaths);
            SelectedUrl = RemoveProtocolNameAndServerName(GetAbsolutePath(SelectedUrl));
        }


        protected virtual bool IsValid(FileInfo file)
        {
            return true;
        }

        protected virtual bool IsValid(DirectoryInfo directory)
        {
            return true;
        }

        public override DirectoryItem ResolveRootDirectoryAsTree(string path)
        {
            string physicalPath = path;

            DirectoryInfo info = new DirectoryInfo(path);

            if (!info.Exists)
            {
                return null;
            }

            string virtualName = info.Name;

            if (UploadPaths.Contains(path)
                || ViewPaths.Contains(path)
                || DeletePaths.Contains(path))
            {
                using (IconStorageCentralContext context = DbUtils.IconStorageCentralDataContext)
                {
                    virtualName = (from libraries in context.Libraries
                                    where libraries.Id == int.Parse(info.Name)
                                     select libraries.Name).Single();
                }
            }

            string virtualParentPath = info.Parent.FullName;

            DirectoryLister directoryLister = new DirectoryLister(this, false, true);

            return directoryLister.GetDirectory(info, virtualName, virtualParentPath, path, string.Empty);
        }


        public override DirectoryItem ResolveDirectory(string path)
        {
            string physicalPath = path;

            DirectoryInfo dir = new DirectoryInfo(physicalPath);
            if (!dir.Exists)
            {
                return null;
            }

            DirectoryLister directoryLister = new DirectoryLister(this, true, false);

            return directoryLister.GetDirectory(dir, path);
        }

        public override bool CanCreateDirectory
        {
            get
            {
                return true;
            }
        }

        public override string GetFileName(string url)
        {
            return Path.GetFileName(RemoveProtocolNameAndServerName(GetAbsolutePath(url)));
        }

        public override string GetPath(string url)
        {
            string virtualPath = RemoveProtocolNameAndServerName(GetAbsolutePath(url));

            return virtualPath;
        }

        public override Stream GetFile(string url)
        {
            string physicalPath = url;

            if (!System.IO.File.Exists(physicalPath))
            {
                return null;
            }

            return System.IO.File.OpenRead(physicalPath);
        }

        public override string StoreBitmap(Bitmap bitmap, string url, ImageFormat format)
        {
            bitmap.Save(url, format);

            return url;
        }

        public override string StoreFile(UploadedFile file, string path, string name, params string[] arguments)
        {
            string targetFullPath = Path.Combine(path, name);
            if (System.IO.File.Exists(targetFullPath))
            {
                System.IO.File.Delete(targetFullPath);
            }
            //normalize slashes
            file.SaveAs(targetFullPath);
            return targetFullPath;
        }

        public override string DeleteFile(string path)
        {
            string physicalPath = path;
            try
            {
                if (System.IO.File.Exists(physicalPath))
                {
                    if ((System.IO.File.GetAttributes(physicalPath) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                    {
                        return "FileReadOnly";
                    }
                    System.IO.File.Delete(physicalPath);
                }
            }
            catch (UnauthorizedAccessException)
            {
                return "NoPermissionsToDeleteFile";
            }
            return string.Empty;
        }

        public override string DeleteDirectory(string path)
        {
            string physicalPath = path;
            try
            {
                if (Directory.Exists(physicalPath))
                {
                    Directory.Delete(physicalPath, true);
                }
            }
            catch (UnauthorizedAccessException)
            {
                return "NoPermissionsToDeleteFolder";
            }
            return string.Empty;
        }

        public override string CreateDirectory(string path, string name)
        {
            if (name.IndexOfAny(Path.GetInvalidPathChars()) >= 0)
            {
                return "InvalidCharactersInPath";
            }
            string newFolderPath = (path + name);
            if (Directory.Exists(newFolderPath))
            {
                return "DirectoryAlreadyExists";
            }
            try
            {
                Directory.CreateDirectory(newFolderPath);
            }
            catch (UnauthorizedAccessException)
            {
                return "NoPermissionsToCreateFolder";
            }
            catch (Exception e)
            {
                return e.Message;
            }
            return string.Empty;
        }

        public override string MoveDirectory(string path, string newPath)
        {
            string oldPhysicalPath = path;
            string newPhysicalPath = newPath;
            try
            {
                Directory.Move(oldPhysicalPath, newPhysicalPath);
            }
            catch (Exception e)
            {
                return e.Message;
            }
            return string.Empty;
        }

        public override string MoveFile(string path, string newPath)
        {
            string oldPhysicalPath = path;
            string newPhysicalPath = newPath;
            if (!System.IO.File.Exists(oldPhysicalPath))
                return "FileNotFound";
            if (System.IO.File.Exists(newPhysicalPath))
                return "NewFileAlreadyExists";
            try
            {
                System.IO.File.Move(oldPhysicalPath, newPhysicalPath);
            }
            catch (UnauthorizedAccessException)
            {
                return "NoPermissionsToMoveFile";
            }
            return string.Empty;
        }

        public void ProcessPaths(string[] paths)
        {
            for (int i=0; i < paths.Length; i++)
            {
                paths[i] = GetAbsolutePath(paths[i]);
            }
        }


        protected string GetAbsolutePath(string path)
        {
            if (path.StartsWith("~"))
            {
                path = VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.AppendTrailingSlash(Context.Request.ApplicationPath) + path.Substring(2));

                return path.Substring(0, path.Length - 1);
            }
            return path;
        }


        protected bool IsParentOf(string virtualParent, string virtualChild)
        {
            //original function did not cover all cases - e.g. parent="/test" and child="/testing" should return false
            if (virtualChild.ToLower().StartsWith(virtualParent.ToLower()))
            {
                if (virtualParent.Length == virtualChild.Length)
                {
                    return true;
                }
                else
                {
                    //if the parent ends with slash, or the child has a slash after the parent part
                    //we should be OK
                    int len = virtualParent.Length;
                    if (virtualChild[len] == '/' || virtualChild[len] == '\\' ||
                        virtualChild[len - 1] == '/' || virtualChild[len - 1] == '\\')
                        return true;
                }
            }
            return false;
        }

        protected PathPermissions GetPermissions(string path)
        {
            PathPermissions permissions = PathPermissions.Read;
            if (CanUpload(path))
                permissions |= PathPermissions.Upload;
            if (CanDelete(path))
                permissions |= PathPermissions.Delete;

            return permissions;
        }

        protected bool CanUpload(string path)
        {
            foreach (string uploadPath in UploadPaths)
            {
                if (IsParentOf(uploadPath, path))
                {
                    return true;
                }
            }
            return false;
        }

        protected bool CanDelete(string path)
        {
            foreach (string deletePath in DeletePaths)
            {
                if (IsParentOf(deletePath, path))
                {
                    return true;
                }
            }
            return false;
        }


    }
}

[Dobromir]

Hi Edward,

I tried to run the provided code of the content provider but was unable to do so due to missing dependencies.

The most possible reason for this issue to occur is if the GetPath() method of the content provider returns the full path of the item (including the file name). Could you try modifying this method to the following and see if the problem still exists?

public override string GetPath(string url)
{
    string virtualPath = RemoveProtocolNameAndServerName(GetAbsolutePath(url));

    virtualPath = VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.GetDirectory(virtualPath).Replace("\\", "/")));

    return virtualPath;
}

If the problem still occurs, could you please open a formal support ticket and provide fully runnable sample project reproducing the problem so we can investigate it further?

Regards,
Dobromir
the Telerik team