OnClientFileOpen in RADFILEEXPLORER(How to open file in with their original extension.)

2 posts, 1 answers
  1. Ajay
    Ajay avatar
    66 posts
    Member since:
    May 2009

    Posted 06 Oct 2009 Link to this post

    Hi Telerik !

    Iam using the RAD FILE EXPLROER in one of my project. I have uploade the files with the following extensions :-

    .docx,
    .doc, .xslx
    .pdf & many images file such as .jpeg,.jpg,.gif,.bmp.

    I have implemented the following javascript function in order to open the file in the context menu:-

     function OnClientFileOpen(oExplorer, args) {  
                debugger;  
                var item = args.get_item();  
                var fileExtension = item.get_extension();  
     
                //var fileDownloadMode = document.getElementById("chkbxDownoaldFile").checked;  
                if ((fileExtension == "jpg" || fileExtension == "gif") && fileExtension == "xlsx" || fileExtension == "docx") {// Download the file   
                    // File is a image document, do not open a new window  
                    args.set_cancel(true);  
     
                    // Tell browser to open file directly  
                    var requestImage = "FileSystemHandler.ashx?path=" + item.get_url();  
                    document.location = requestImage;  
                //}  
            }  
     
     
     
     I have the following code implemented on to my FileSystemHandler.ashx file :-
    <%@ WebHandler Language="C#" Class="Handler" %> 
    using System;  
    using System.Data;  
    using System.Configuration;  
    using System.Web;  
    using System.IO;  
    using System.Collections.Generic;  
    using System.Xml;  
     
    public class Handler : IHttpHandler  
    {  
        #region IHttpHandler Members  
     
        string pathToConfigFile = "~/App_Data/MappingFile.mapping";  
        private HttpContext _context;  
        private HttpContext Context  
        {  
            get  
            {  
                return _context;  
            }  
            set  
            {  
                _context = value;  
            }  
        }  
     
     
        public void ProcessRequest(HttpContext context)  
        {  
            Context = context;  
     
            if (context.Request.QueryString["path"] == null)  
            {  
                return;  
            }  
     
            string virtualPathToFile = Context.Server.HtmlDecode(context.Request.QueryString["path"]);  
            string physicalPathToFile = "";  
            Dictionary<string, string> mappedPathsInConfigFile = this.GetMappingsFromConfigFile();  
            foreach (KeyValuePair<string, string> mappedPath in mappedPathsInConfigFile)  
            {  
                if (virtualPathToFile.ToLower().StartsWith(mappedPath.Key.ToLower()))  
                {  
                    // Build the physical path to the file ;  
                    physicalPathToFile = virtualPathToFile.Replace(mappedPath.Key, mappedPath.Value).Replace("/", "\\");  
     
                    break;// Brak the foreach loop ;  
                }  
            }  
     
            if (physicalPathToFile == null)  
            {  
                return;  
            }  
     
            System.IO.StreamReader streamReader = new System.IO.StreamReader(physicalPathToFile);  
            System.IO.BinaryReader br = new System.IO.BinaryReader(streamReader.BaseStream);  
     
            byte[] bytes = new byte[streamReader.BaseStream.Length];  
     
            br.Read(bytes, 0, (int)streamReader.BaseStream.Length);  
     
            if (bytes == null)  
            {  
                return;  
            }  
     
            streamReader.Close();  
            br.Close();  
            string extension = System.IO.Path.GetExtension(physicalPathToFile);  
            string fileName = System.IO.Path.GetFileName(physicalPathToFile);  
     
            if (extension == ".jpg")  
            { // Handle *.jpg and  
                WriteFile(bytes, fileName, "image/jpeg jpeg jpg jpe", context.Response);  
            }  
            else if (extension == ".gif")  
            {// Handle *.gif  
                WriteFile(bytes, fileName, "image/gif gif", context.Response);  
            }  
        }  
        private void WriteFile(byte[] content, string fileName, string contentType, HttpResponse response)  
        {  
            response.Buffer = true;  
            response.Clear();  
            response.ContentType = contentType;  
     
            response.AddHeader("content-disposition", "attachment; filename=" + fileName);  
     
            response.BinaryWrite(content);  
            response.Flush();  
            response.End();  
        }  
          
          
        public bool IsReusable  
        {  
            get  
            {  
                return false;  
            }  
        }  
     
     
        /// <summary> 
        /// Retrieves the mapping for view paths ;  
        /// </summary> 
        /// <param name="virtualPathToConfigFile">The fvirtual path to the config file </param> 
        /// <returns>The mappings </returns> 
        private Dictionary<string, string> GetMappingsFromConfigFile()  
        {  
            XmlDocument configFile = new XmlDocument();  
            string physicalPathToConfigFile = Context.Server.MapPath(this.pathToConfigFile);  
            configFile.Load(physicalPathToConfigFile);// Load the configuration file ;  
     
            XmlElement rootElement = configFile.DocumentElement;  
            XmlNode mappingsSection = rootElement.GetElementsByTagName("Mappings")[0]; // get all mappings ;  
     
            Dictionary<string, string> mappingsFromConfigFile = new Dictionary<string, string>();  
            foreach (XmlNode mapping in mappingsSection.ChildNodes)  
            {  
                XmlNode virtualPathAsNode = mapping.SelectSingleNode("child::VirtualPath");  
                XmlNode physicalPathAsNode = mapping.SelectSingleNode("child::PhysicalPath");  
                mappingsFromConfigFile.Add(this.AddSlashAtEndOfVirtualPath(virtualPathAsNode.InnerText), this.AddSlashAtEndOfPhysicalPath(physicalPathAsNode.InnerText));  
            }  
     
            return mappingsFromConfigFile;  
        }  
     
        /// <summary> 
        /// Gets the path to the generic handler. It should be a virtual path  
        /// </summary> 
        /// <returns>Path to the generic handler</returns> 
        private string GetPathTogenericHandler()  
        {  
            XmlDocument configFile = new XmlDocument();  
            string physicalPathToConfigFile = Context.Server.MapPath(this.pathToConfigFile);  
            configFile.Load(physicalPathToConfigFile);// Load the configuration file ;  
     
            XmlElement rootElement = configFile.DocumentElement;  
            XmlNode handlerPathSection = rootElement.GetElementsByTagName("genericHandlerPath")[0]; // get all mappings ;  
     
            return handlerPathSection.InnerText;  
        }  
     
        //////////////////////////////////////////////////////////////////////////////////////////////////////////  
        //  The custom methods   
        //////////////////////////////////////////////////////////////////////////////////////////////////////////  
        /// <summary> 
        /// Adds a backslash at the end of a physical path if the slash does not exists ;  
        /// </summary> 
        /// <param name="physicalPath">Physical path</param> 
        /// <returns></returns>  
        private string AddSlashAtEndOfPhysicalPath(string physicalPath)  
        {  
     
            if (!physicalPath.EndsWith("\\"))  
            {  
                return physicalPath + "\\";  
            }  
            else  
            {  
                return physicalPath;  
            }  
        }  
     
        /// <summary> 
        /// Adds a backslash at the end of a virtual path if the slash does not exists ;  
        /// </summary> 
        /// <param name="virtualPath">Virtual path</param> 
        /// <returns></returns>  
        private string AddSlashAtEndOfVirtualPath(string virtualPath)  
        {  
     
            if (!virtualPath.EndsWith("/"))  
            {  
                return virtualPath + "/";  
            }  
            else  
            {  
                return virtualPath;  
            }  
        }  
        #endregion  
        } 
    Also, I have used the following in the ASPX Page :-

    <telerik:RadFileExplorer runat="server" ID="DocumentsRadFileExplorer" Width="734px" 
                        Height="400px" VisibleControls="All" EnableCreateNewFolder="true" EnableCopy="true" EnableOpenFile="true" 
                        OnClientMove="OnClientMove" OnClientFileOpen="OnClientFileOpen" OnClientDelete="OnClientDelete" OnClientLoad="attachHandlers" > 
                 <Configuration SearchPatterns="*.*"></Configuration> 
                    </telerik:RadFileExplorer> 
    Now whenever I try to open the file with .doc or .docx or .pdf extension file does not get open in MS word format. PDF file opens ups but with its name changed as FileHandler.pdf.

    Apart form that, I have used all the sample that has been sent by all your member earlier but all in vain.

    Below is the list of javascript function that I have used so far :-
           function OnClientFileOpen(sender, args)      
    {  
       var item = args.get_item();  
       if (item && !item.isDirectory() && (item.get_extension() == "docx") && (item.get_extension() == "doc"))  
       {  
           //file is a MS Office document, do not open a new window.    
           args.set_cancel(true);  
             
           //tell browser to open file directly  
           //window.location.href = item.get_url();  
           var requestImage = "Handler.ashx?path=" + item.get_url();  
           window.location.href = requestImage;  
             
       }  
    }   
          
            function OnExplorerFileOpen(oExplorer, args) {  
                var item = args.get_item();  
                var fileExt = item.get_extension();  
                if (fileExt == "jpg") {  
                    var oWindowManager = oExplorer.get_windowManager();  
                    args.set_cancel(true);  
                    var newURL = "Popup.aspx?path=" + item.get_path();  
                    var oWindow = oWindowManager.open(newURL, "RadWindow1");  
                    oWindow.setSize(500, 500);  
                }  
                else if (fileExt == "pdf") {  
                    setTimeout(  
                            function() {  
                                var oWindow = oExplorer.get_windowManager().getActiveWindow();  
                                oWindow.setSize(500, 600);  
                            }, 500);  
                }  
            }  
     
     
            function OnClientFileOpen(sender, args) {  
                LogEvent("Item open: " + args.get_item().get_name());  
            }  
     
            function LogEvent(text) {  
                var d = new Date();  
                var ddateStr = d.getHours() + ":" + d.getMinutes() + ":" + d.getSeconds() + "." + d.getMilliseconds();  
                var eventConsole = $get("eventConsole");  
                eventConsole.innerHTML += "[" + dateStr + "] " + text + "<br/>";  
            }  
     
            function OnClientFileOpen(oExplorer, args) {  
                debugger;  
                var item = args.get_item();  
                var fileExtension = item.get_extension();  
     
                //var fileDownloadMode = document.getElementById("chkbxDownoaldFile").checked;  
                if ((fileExtension == "jpg" || fileExtension == "gif") && fileExtension == "xlsx" || fileExtension == "docx") {// Download the file   
                    // File is a image document, do not open a new window  
                    args.set_cancel(true);  
     
                    // Tell browser to open file directly  
                    var requestImage = "FileSystemHandler.ashx?path=" + item.get_url();  
                    document.location = requestImage;  
                //}  
            }  
     


    Please help me to solve my problem .

    Thanks & Regards

    Ajay Jamwal 
  2. Answer
    Fiko
    Admin
    Fiko avatar
    1406 posts

    Posted 06 Oct 2009 Link to this post

    Hi Ajay,

    I believe that the information in this KB article will be of help.

    All the best,
    Fiko
    the Telerik team

    Instantly find answers to your questions on the new Telerik Support Portal.
    Watch a video on how to optimize your support resource searches and check out more tips on the blogs.
  3. UI for ASP.NET Ajax is Ready for VS 2017
Back to Top