KindEditor编辑器在ASP.NET中的使用

KindEditor编辑器在ASP.NET中的使用

最近做的项目中都有用到富文本编辑器，一直在寻找最后用的富文本编辑器，之前用过CKEditor，也用过UEditor，这次打算用 一下KindEditor。

KindEditor简介：

KindEditor是一套开源的HTML可视化编辑器，主要用于让用户在网站上获得所见即所得编辑效果，兼容IE、Firefox、Chrome、Safari、Opera等主流浏览器。KindEditor使用JavaScript编写，可以无缝的于Java、.NET、PHP、ASP等程序接合。 KindEditor非常适合在CMS、商城、论坛、博客、Wiki、电子邮件等互联网应用上使用，2006年7月首次发布2.0以来，KindEditor依靠出色的用户体验和领先的技术不断扩大编辑器市场占有率，目前在国内已经成为最受欢迎的编辑器之一。[来自百度百科]

官网简介、 官网下载 、官方文档 、官网Demo演示

KindEditor使用：

1. 将开发包导入到项目

   将下载的开发包中不需要的删掉，只保留项目需要的文件，我的项目是ASP.NET项目，所引用的开发包资源如下图所示

   

2. 在页面中添加引用

   

3. 页面初始化

   html设置：

   

   js初始化：

   

4. 获取和设置编辑器的值

   获取编辑器的值：

   1. 直接通过editor获取

   var html = editor.html();

   1. 先把数据同步到textarea中，再获取textarea的值

      editor.sync();

      //原生js获取

      var html = document.getElementById("editor").value;

      //jquery获取

      var html =$("#editor").val();

      //KindEditor 方式

      var html = K('#editor').val();

设置编辑器的值：

editor.html('html内容');

上传文件处理程序：

参考所给的示例，只是对示例加以验证，验证是否有上传权限

上传文件列表处理程序：

获取上传文件列表同样的，首先进行权限验证：

 public class UploadFileHandler : IHttpHandler, IRequiresSessionState
     {
         private static HttpResponse Response = null;
         //最大文件大小
         const int MAXFILESIZE = *;

         public void ProcessRequest(HttpContext context)
         {
             //验证上传权限
             if (context.Session["User"] == null)
             {
                 context.Response.Write("no permission");
                 context.Response.End();
                 return;
             }
             Response = context.Response;
             string flag = context.Request["customUpload"];
             //从配置文件中获取网站首页路径
             String aspxUrl = Common.ConfigurationHelper.AppSetting("HomeUrlInfo");
             //文件保存目录路径
             System.Text.StringBuilder savePath = new System.Text.StringBuilder("/Upload/");
             try
             {
                 //定义允许上传的文件扩展名
                 Hashtable extTable = new Hashtable();
                 extTable.Add("image", "jpg,jpeg,png,bmp");
                 extTable.Add("flash", "swf,flv");
                 extTable.Add("media", "swf,flv,mp3,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb");
                 extTable.Add("file", "doc,docx,xls,xlsx,ppt,pptx,txt,zip,rar");
                 //获取上传文件
                 HttpPostedFile imgFile = context.Request.Files["imgFile"];
                 if (imgFile == null)
                 {
                     imgFile = context.Request.Files["Filedata"];
                 }
                 //当前时间字符串
                 string timeString = DateTime.Now.ToString("yyyyMMddHHmmssfff");
                 //设置存储目录
                 String dirName = context.Request.QueryString["dir"];
                 if (String.IsNullOrEmpty(dirName))
                 {
                     dirName = "image";
                 }
                 if (!extTable.ContainsKey(dirName))
                 {
                     showError("目录名不正确");
                 }
                 if (imgFile.InputStream == null || imgFile.InputStream.Length > MAXFILESIZE)
                 {
                     showError("上传文件大小超过限制");
                 }
                 //获取文件扩展名
                 string fileExt = Path.GetExtension(imgFile.FileName).ToLower();
                 if (String.IsNullOrEmpty(fileExt) || Array.IndexOf(((String)extTable[dirName]).Split(','), fileExt.Substring().ToLower()) == -)
                 {
                     showError("上传文件扩展名是不允许的扩展名。\n只允许" + ((String)extTable[dirName]) + "格式。");
                 }
                 //创建文件夹
                 savePath.Append(dirName + "/");
                 string serverPath = Common.PathHelper.MapPath(savePath.ToString());
                 if (!Directory.Exists(serverPath))
                 {
                     Directory.CreateDirectory(serverPath);
                 }
                 String newFileName = timeString + fileExt;
                 String filePath = serverPath + newFileName;
                 //保存到服务器端
                 imgFile.SaveAs(filePath);
                 savePath.Append(newFileName);
                 //文件相对网站的虚拟路径
                 String fileUrl = savePath.ToString();
                 if (String.IsNullOrEmpty(flag))
                 {
                     fileUrl = aspxUrl + savePath.ToString();
                 }
                 Hashtable hash = new Hashtable();
                 hash["error"] = ;
                 hash["url"] = fileUrl;
                 context.Response.AddHeader("Content-Type", "text/html; charset=UTF-8");
                 context.Response.Write(Common.ConverterHelper.ObjectToJson(hash));
                 context.Response.End();

             }
             catch (System.Threading.ThreadAbortException)
             {

             }
             catch (HttpException ex)
             {
                 //context.Response.Write("Error");
                 //记录日志
                 new Common.LogHelper(typeof(UploadFileHandler)).Error(ex);
             }
             catch (Exception ex)
             {
                 //context.Response.Write("Error");
                 //记录日志
                 new Common.LogHelper(typeof(UploadFileHandler)).Error(ex);
             }
         }

         private void showError(string message)
         {
             Hashtable hash = new Hashtable();
             hash["error"] = ;
             hash["message"] = message;
             Response.AddHeader("Content-Type", "text/html; charset=UTF-8");
             Response.Write(Common.ConverterHelper.ObjectToJson(hash));
             Response.End();
         }

UploadFileHandler Code

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Text.RegularExpressions;
 using System.Web;
 using System.Web.SessionState;

 namespace WebApplication1.Admin
 {
     public class FileManagerHandler : IHttpHandler,IRequiresSessionState
     {
         public void ProcessRequest(HttpContext context)
         {
             //验证权限
             if (context.Session["User"] == null)
             {
                 context.Response.Write("no permission");
                 context.Response.End();
                 return;
             }
             //从配置文件中读取网址信息
             String aspxUrl = Common.ConfigurationHelper.AppSetting("HomeUrlInfo");
             //根目录路径，相对路径
             String rootPath = "/Upload/";
             //根目录URL，可以指定绝对路径，比如 http://www.yoursite.com/attached/
             String rootUrl = aspxUrl + "Upload/";
             //图片扩展名
             String fileTypes = "jpg,jpeg,png,bmp";
             String currentPath = "";
             String currentUrl = "";
             String currentDirPath = "";
             String moveupDirPath = "";
             try
             {
                 String dirPath = context.Server.MapPath(rootPath);
                 String dirName = context.Request.QueryString["dir"];
                 if (!String.IsNullOrEmpty(dirName))
                 {
                     if (Array.IndexOf("image,flash,media,file".Split(','), dirName) == -)
                     {
                         context.Response.Write("Invalid Directory name.");
                         context.Response.End();
                     }
                     dirPath += dirName + "/";
                     rootUrl += dirName + "/";
                     if (!Directory.Exists(dirPath))
                     {
                         Directory.CreateDirectory(dirPath);
                     }
                 }

                 //根据path参数，设置各路径和URL
                 String path = context.Request.QueryString["path"];
                 path = String.IsNullOrEmpty(path) ? "" : path;
                 if (path == "")
                 {
                     currentPath = dirPath;
                     currentUrl = rootUrl;
                     currentDirPath = "";
                     moveupDirPath = "";
                 }
                 else
                 {
                     currentPath = dirPath + path;
                     currentUrl = rootUrl + path;
                     currentDirPath = path;
                     moveupDirPath = Regex.Replace(currentDirPath, @"(.*?)[^\/]+\/$", "$1");
                 }

                 //排序形式，name or size or type
                 String order = context.Request.QueryString["order"];
                 order = String.IsNullOrEmpty(order) ? "" : order.ToLower();

                 //不允许使用..移动到上一级目录
                 if (Regex.IsMatch(path, @"\.\."))
                 {
                     context.Response.Write("Access is not allowed.");
                     context.Response.End();
                 }
                 //最后一个字符不是/
                 if (path != "" && !path.EndsWith("/"))
                 {
                     context.Response.Write("Parameter is not valid.");
                     context.Response.End();
                 }
                 //目录不存在或不是目录
                 if (!Directory.Exists(currentPath))
                 {
                     context.Response.Write("Directory does not exist.");
                     context.Response.End();
                 }

                 //遍历目录取得文件信息
                 string[] dirList = Directory.GetDirectories(currentPath);
                 string[] fileList = Directory.GetFiles(currentPath);
                 //排序方式
                 switch (order)
                 {
                     case "size":
                         Array.Sort(dirList, new NameSorter());
                         Array.Sort(fileList, new SizeSorter());
                         break;
                     case "type":
                         Array.Sort(dirList, new NameSorter());
                         Array.Sort(fileList, new TypeSorter());
                         break;
                     case "name":
                     default:
                         Array.Sort(dirList, new NameSorter());
                         Array.Sort(fileList, new NameSorter());
                         break;
                 }
                 Hashtable result = new Hashtable();
                 result["moveup_dir_path"] = moveupDirPath;
                 result["current_dir_path"] = currentDirPath;
                 result["current_url"] = currentUrl;
                 result["total_count"] = dirList.Length + fileList.Length;
                 List<Hashtable> dirFileList = new List<Hashtable>();
                 result["file_list"] = dirFileList;
                 for (int i = ; i < dirList.Length; i++)
                 {
                     DirectoryInfo dir = new DirectoryInfo(dirList[i]);
                     Hashtable hash = new Hashtable();
                     hash["is_dir"] = true;
                     hash["has_file"] = (dir.GetFileSystemInfos().Length > );
                     hash["filesize"] = ;
                     hash["is_photo"] = false;
                     hash["filetype"] = "";
                     hash["filename"] = dir.Name;
                     hash["datetime"] = dir.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss");
                     dirFileList.Add(hash);
                 }
                 for (int i = ; i < fileList.Length; i++)
                 {
                     FileInfo file = new FileInfo(fileList[i]);
                     Hashtable hash = new Hashtable();
                     hash["is_dir"] = false;
                     hash["has_file"] = false;
                     hash["filesize"] = file.Length;
                     hash["is_photo"] = (Array.IndexOf(fileTypes.Split(','), file.Extension.Substring().ToLower()) >= );
                     hash["filetype"] = file.Extension.Substring();
                     hash["filename"] = file.Name;
                     hash["datetime"] = file.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss");
                     dirFileList.Add(hash);
                 }
                 context.Response.AddHeader("Content-Type", "application/json; charset=UTF-8");
                 context.Response.Write(Common.ConverterHelper.ObjectToJson(result));
                 context.Response.End();
             }
             catch (IOException ex)
             {
                 context.Response.Write("Error");
                 //记录日志
                 new Common.LogHelper(typeof(FileManagerHandler)).Error(ex);
             }
             catch (SystemException ex)
             {
                 context.Response.Write("Error");
                 //记录日志
                 new Common.LogHelper(typeof(FileManagerHandler)).Error(ex);
             }
             catch (Exception ex)
             {
                 context.Response.Write("Error");
                 //记录日志
                 new Common.LogHelper(typeof(FileManagerHandler)).Error(ex);
             }
         }

         public bool IsReusable
         {
             get
             {
                 return true;
             }
         }

     }

     class NameSorter : IComparer
     {
         public int Compare(object x, object y)
         {
             if (x == null && y == null)
             {
                 return ;
             }
             if (x == null)
             {
                 return -;
             }
             if (y == null)
             {
                 return ;
             }
             FileInfo xInfo = new FileInfo(x.ToString());
             FileInfo yInfo = new FileInfo(y.ToString());

             return xInfo.FullName.CompareTo(yInfo.FullName);
         }
     }

     class SizeSorter : IComparer
     {
         public int Compare(object x, object y)
         {
             if (x == null && y == null)
             {
                 return ;
             }
             if (x == null)
             {
                 return -;
             }
             if (y == null)
             {
                 return ;
             }
             FileInfo xInfo = new FileInfo(x.ToString());
             FileInfo yInfo = new FileInfo(y.ToString());

             return xInfo.Length.CompareTo(yInfo.Length);
         }
     }

     class TypeSorter : IComparer
     {
         public int Compare(object x, object y)
         {
             if (x == null && y == null)
             {
                 return ;
             }
             if (x == null)
             {
                 return -;
             }
             if (y == null)
             {
                 return ;
             }
             FileInfo xInfo = new FileInfo(x.ToString());
             FileInfo yInfo = new FileInfo(y.ToString());

             return xInfo.Extension.CompareTo(yInfo.Extension);
         }
     }
 }

FileManagerHandler Code