FileExplorer & Absolute Paths

2 posts, 0 answers
  1. Edward
    Edward avatar
    1 posts
    Member since:
    May 2011

    Posted 18 May 2011 Link to this post

    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;
            }
     
             
        }
    }
  2. Dobromir
    Admin
    Dobromir avatar
    1633 posts

    Posted 20 May 2011 Link to this post

    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

    Browse the vast support resources we have to jump start your development with RadControls for ASP.NET AJAX. See how to integrate our AJAX controls seamlessly in SharePoint 2007/2010 visiting our common SharePoint portal.

  3. UI for ASP.NET Ajax is Ready for VS 2017
Back to Top