--commit editor service

src/main/java/com/ekexiu/portal/editor/Controller.java

@@ -0,0 +1,273 @@
package com.ekexiu.portal.editor;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jfw.apt.annotation.Autowrie;
import org.jfw.apt.annotation.Bean;
import org.jfw.util.ConstData;
import org.jfw.util.json.JsonService;
import org.jfw.util.web.fileupload.Item;
import org.jfw.util.web.fileupload.UploadItemIterator;
import org.jfw.util.web.fileupload.impl.UploadItemIteratorImpl;
import com.ekexiu.portal.editor.define.BaseState;
import com.ekexiu.portal.editor.define.State;
@Bean
public class Controller {
    @Autowrie
    private EditorConfig config;
    public EditorConfig getConfig() {
        return config;
    }
    public void setConfig(EditorConfig config) {
        this.config = config;
    }
    public void service(HttpServletRequest req, HttpServletResponse res, int _viewType) throws javax.servlet.ServletException, java.io.IOException {
        req.setCharacterEncoding("utf-8");
        res.setHeader("Content-Type", "text/html");
        String callbackName = req.getParameter("callback");
        String ret = null;
        if (callbackName != null) {
            if (!validCallbackName(callbackName)) {
                ret = new BaseState(false, 401).toJSONString();
            } else {
                ret = callbackName + "(" + invoke(req) + ");";
            }
        } else {
            ret = invoke(req);
        }
        Writer out = res.getWriter();
        try {
            out.write(ret);
        } finally {
            out.close();
        }
    }
    public String invoke(HttpServletRequest req) {
        String actionType = req.getParameter("action");
        if ((actionType == null) || (!mapping.containsKey(actionType))) {
            return new BaseState(false, 101).toJSONString();
        }
        State state = new BaseState(false, 101);
        int actionCode = getType(actionType);
        switch (actionCode) {
        case 0:
            return JsonService.toJson(this.config.getAllConfig());
        case 1:
        case 2:
        case 3:
        case 4:
            state = this.upload(req, actionCode);
            break;
        }
        return state.toJSONString();
    }
    public boolean validCallbackName(String name) {
        if (name.matches("^[a-zA-Z_]+[\\w0-9_]*$")) {
            return true;
        }
        return false;
    }
    private State upload(HttpServletRequest req, int actionCode) {
        if (2 == actionCode) {
            return this.uploadBase64(req);
        }
        boolean isAjaxUpload = req.getHeader("X_Requested_With") != null;
        if (!UploadItemIteratorImpl.isMultipartContent(req)) {
            return new BaseState(false, 5);
        }
        try {
            if (isAjaxUpload) {
                req.setCharacterEncoding("UTF-8");
            }
            String savePath = this.config.getImagePathFormat();
            long maxSize = this.config.getImageMaxSize();
            String afs = this.config.getImageAllowFiles();
            if (actionCode == 3) {
                savePath = this.config.getVideoPathFormat();
                maxSize = this.config.getVideoMaxSize();
                afs = this.config.getVideoAllowFiles();
            }
            if (actionCode == 4) {
                savePath = this.config.getFilePathFormat();
                maxSize = this.config.getFileMaxSize();
                afs = this.config.getFileAllowFiles();
            }
            List<String> afList = this.config.addDot(this.config.from(afs));
            UploadItemIterator it = UploadItemIteratorImpl.build(req);
            try {
                while (it.hasNext()) {
                    Item item = it.next();
                    if (!item.isFormField()) {
                        String filename = item.getName();
                        String suffix = filename.substring(filename.lastIndexOf(".")).toLowerCase();
                        if (!afList.contains(suffix)) {
                            return new BaseState(false, 8);
                        }
                        filename = filename.substring(0, filename.length() - suffix.length());
                        savePath = savePath + suffix;
                        savePath = PathFormat.parse(savePath, filename);
                        State storageState = this.saveFileByInputStream(item.getInputStream(), savePath, maxSize);
                        if (storageState.isSuccess()) {
                            storageState.putInfo("url", PathFormat.format(savePath));
                            storageState.putInfo("type", suffix);
                            storageState.putInfo("original", filename + suffix);
                        }
                        return storageState;
                    }
                }
                return new BaseState(false, 7);
            } finally {
                it.clean();
            }
        } catch (IOException e) {
        }
        return new BaseState(false, 4);
    }
    private static boolean validSize(byte[] data, long length) {
        return data.length <= length;
    }
    private State uploadBase64(HttpServletRequest req) {
        String fn = this.config.getScrawlFieldName();
        String content = req.getParameter(fn);
        byte[] data = org.jfw.apt.util.Base64.decodeBase64(content.getBytes(ConstData.UTF8));
        long maxSize = this.config.getScrawlMaxSize();
        if (!validSize(data, maxSize)) {
            return new BaseState(false, 1);
        }
        String suffix = ".jpg";
        String savePath = PathFormat.parse(this.config.getScrawlPathFormat(), "scrawl");
        savePath = savePath + suffix;
        State storageState = saveBinaryFile(data, savePath);
        if (storageState.isSuccess()) {
            storageState.putInfo("url", PathFormat.format(savePath));
            storageState.putInfo("type", suffix);
            storageState.putInfo("original", "");
        }
        return storageState;
    }
    public static int getType(String key) {
        return ((Integer) mapping.get(key)).intValue();
    }
    public static final int BUFFER_SIZE = 8192;
    public State saveBinaryFile(byte[] data, String path) {
        File file = new File(this.config.getRootPath(), path);
        State state = valid(file);
        if (!state.isSuccess()) {
            return state;
        }
        try {
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
            bos.write(data);
            bos.flush();
            bos.close();
        } catch (IOException ioe) {
            return new BaseState(false, 4);
        }
        state = new BaseState(true, file.getAbsolutePath());
        state.putInfo("size", data.length);
        state.putInfo("title", file.getName());
        return state;
    }
    public State saveFileByInputStream(InputStream is, String path, long maxSize) {
        State state = null;
        File file = new File(this.config.getRootPath(), path);
        if (file.exists()) {
            return new BaseState(false, 2);
        }
        File parent = file.getParentFile();
        if(!parent.exists()){
            if(!parent.mkdirs())return new BaseState(false, 3);
        }
        byte[] dataBuf = new byte[4096];
        BufferedInputStream bis = new BufferedInputStream(is, 8192);
        try {
            try {
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file), 8192);
                int count = 0;
                while ((count = bis.read(dataBuf)) != -1) {
                    bos.write(dataBuf, 0, count);
                }
                bos.flush();
                bos.close();
                if (file.length() > maxSize) {
                    file.delete();
                    return new BaseState(false, 1);
                }
                state = new BaseState(true);
                state.putInfo("size", file.length());
                state.putInfo("title", file.getName());
                return state;
            } finally {
                is.close();
            }
        } catch (IOException localIOException) {
        }
        return new BaseState(false, 4);
    }
    private static State valid(File file) {
        File parentPath = file.getParentFile();
        if ((!parentPath.exists()) && (!parentPath.mkdirs())) {
            return new BaseState(false, 3);
        }
        if (!parentPath.canWrite()) {
            return new BaseState(false, 2);
        }
        return new BaseState(true);
    }
    public static final Map<String, Integer> mapping = new HashMap<String, Integer>();
    public static final int CONFIG = 0;
    public static final int UPLOAD_IMAGE = 1;
    public static final int UPLOAD_SCRAWL = 2;
    public static final int UPLOAD_VIDEO = 3;
    public static final int UPLOAD_FILE = 4;
    static {
        mapping.put("config", CONFIG);
        mapping.put("uploadimage", UPLOAD_IMAGE);
        mapping.put("uploadscrawl", UPLOAD_SCRAWL);
        mapping.put("uploadvideo", UPLOAD_VIDEO);
        mapping.put("uploadfile", UPLOAD_FILE);
    }
}

src/main/java/com/ekexiu/portal/editor/EditorConfig.java

@@ -0,0 +1,656 @@
package com.ekexiu.portal.editor;
import java.io.File;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.jfw.apt.annotation.Bean;
import org.jfw.util.ListUtil;
@Bean
public class EditorConfig {
    private File rootPath;
    
    /* 执行上传图片的action名称 */
    private String imageActionName = "uploadimage";
    /* 提交的图片表单名称 */
    private String imageFieldName = "upfile";
    /* 上传大小限制，单位B */
    private long imageMaxSize = 2048000;
    /* 上传图片格式显示 */
    private String imageAllowFiles = "png,jpg,jpeg,gif,bmp";
    /* 是否压缩图片,默认是true */
    private boolean imageCompressEnable = true;
    /* 图片压缩最长边限制 */
    private long imageCompressBorder = 1600;
    /* 插入的图片浮动方式 */
    private String imageInsertAlign = "none";
    /* 图片访问路径前缀 */
    private String imageUrlPrefix = "";
    /* 上传保存路径,可以自定义保存路径和文件名格式 */
    /* {filename} 会替换成原文件名,配置这项需要注意中文乱码问题 */
    /* {rand:6} 会替换成随机数,后面的数字是随机数的位数 */
    /* {time} 会替换成时间戳 */
    /* {yyyy} 会替换成四位年份 */
    /* {yy} 会替换成两位年份 */
    /* {mm} 会替换成两位月份 */
    /* {dd} 会替换成两位日期 */
    /* {hh} 会替换成两位小时 */
    /* {ii} 会替换成两位分钟 */
    /* {ss} 会替换成两位秒 */
    /* 非法字符 \ : * ? " < > | */
    /* 具请体看线上文档: fexbaiducom/ueditor/#use-format_upload_filename */
    private String imagePathFormat = "/data/editor/image/{yyyy}{mm}{dd}/{time}{rand:6}";
    /* 涂鸦图片上传配置项 */
    /* 执行上传涂鸦的action名称 */
    private String scrawlActionName = "uploadscrawl";
    /* 提交的图片表单名称 */
    private String scrawlFieldName = "upfile";
    /* 上传保存路径,可以自定义保存路径和文件名格式 */
    private String scrawlPathFormat = "/data/editor/image/{yyyy}{mm}{dd}/{time}{rand:6}";
    /* 上传大小限制，单位B */
    private long scrawlMaxSize = 2048000;
    private String scrawlUrlPrefix = "";
    /* 图片访问路径前缀 */
    private String scrawlInsertAlign = "none";
    /* 截图工具上传 */
    /* 执行上传截图的action名称 */
    private String snapscreenActionName = "uploadimage";
    /* 上传保存路径,可以自定义保存路径和文件名格式 */
    private String snapscreenPathFormat = "/data/editor/image/{yyyy}{mm}{dd}/{time}{rand:6}";
    /* 图片访问路径前缀 */
    private String snapscreenUrlPrefix = "";
    /* 插入的图片浮动方式 */
    private String snapscreenInsertAlign = "none";
    /* 抓取远程图片配置 */
    private String catcherLocalDomain = "127001,localhost,imgbaiducom";
    /* 执行抓取远程图片的action名称 */
    private String catcherActionName = "catchimage";
    /* 提交的图片列表表单名称 */
    private String catcherFieldName = "source";
    /* 上传保存路径,可以自定义保存路径和文件名格式 */
    private String catcherPathFormat = "/data/editor/image/{yyyy}{mm}{dd}/{time}{rand:6}";
    /* 图片访问路径前缀 */
    private String catcherUrlPrefix = "";
    /* 上传大小限制，单位B */
    private long catcherMaxSize = 2048000;
    /* 抓取图片格式显示 */
    private String catcherAllowFiles = "png,jpg,jpeg,gif,bmp";
    /* 上传视频配置 */
    /* 执行上传视频的action名称 */
    private String videoActionName = "uploadvideo";
    /* 提交的视频表单名称 */
    private String videoFieldName = "upfile";
    /* 上传保存路径,可以自定义保存路径和文件名格式 */
    private String videoPathFormat = "/data/editor/video/{yyyy}{mm}{dd}/{time}{rand:6}";
    /* 视频访问路径前缀 */
    private String videoUrlPrefix = "";
    /* 上传大小限制，单位B，默认100MB */
    private long videoMaxSize = 102400000;
    /* 上传视频格式显示 */
    private String videoAllowFiles = "flv,swf,mkv,avi,rm,rmvb,mpeg,mpg,ogg,ogv,mov,wmv,mp4,webm,mp3,wav,mid";
    /* 上传文件配置 */
    /* controller里,执行上传视频的action名称 */
    private String fileActionName = "uploadfile";
    /* 提交的文件表单名称 */
    private String fileFieldName = "upfile";
    /* 上传保存路径,可以自定义保存路径和文件名格式 */
    private String filePathFormat = "/data/editor/file/{yyyy}{mm}{dd}/{time}{rand:6}";
    /* 文件访问路径前缀 */
    private String fileUrlPrefix = "";
    /* 上传大小限制，单位B，默认50MB */
    private long fileMaxSize = 51200000;
    /* 上传文件格式显示 */
    private String fileAllowFiles = "png,jpg,jpeg,gif,bmp,flv,swf,mkv,avi,rm,rmvb,mpeg,mpg,ogg,ogv,mov,wmv,mp4,webm,mp3,wav,mid,rar,zip,tar,gz,7z,bz2,cab,iso,doc,docx,xls,xlsx,ppt,pptx,pdf,txt,md,xml";
    /* 列出指定目录下的图片 */
    /* 执行图片管理的action名称 */
    private String imageManagerActionName = "listimage";
    /* 指定要列出图片的目录 */
    private String imageManagerListPath = "/data/editor/image/";
    /* 每次列出文件数量 */
    private long imageManagerListSize = 20;
    /* 图片访问路径前缀 */
    private String imageManagerUrlPrefix = "";
    /* 插入的图片浮动方式 */
    private String imageManagerInsertAlign = "none";
    /* 列出的文件类型 */
    private String imageManagerAllowFiles = "png,jpg,jpeg,gif,bmp";
    /* 列出指定目录下的文件 */
    /* 执行文件管理的action名称 */
    private String fileManagerActionName = "listfile";
    /* 指定要列出文件的目录 */
    private String fileManagerListPath = "/data/editor/upload/file/";
    /* 文件访问路径前缀 */
    private String fileManagerUrlPrefix = "";
    /* 每次列出文件数量 */
    private long fileManagerListSize = 20;
    /* 列出的文件类型 */
    private String fileManagerAllowFiles = "png,jpg,jpeg,gif,bmp,flv,swf,mkv,avi,rm,rmvb,mpeg,mpg,ogg,ogv,mov,wmv,mp4,webm,mp3,wav,mid,rar,zip,tar,gz,7z,bz2,cab,iso,doc,docx,xls,xlsx,ppt,pptx,pdf,txt,md,xml";
    public String getImageActionName() {
        return imageActionName;
    }
    public void setImageActionName(String imageActionName) {
        this.imageActionName = imageActionName;
    }
    public String getImageFieldName() {
        return imageFieldName;
    }
    public void setImageFieldName(String imageFieldName) {
        this.imageFieldName = imageFieldName;
    }
    public long getImageMaxSize() {
        return imageMaxSize;
    }
    public void setImageMaxSize(long imageMaxSize) {
        this.imageMaxSize = imageMaxSize;
    }
    public String getImageAllowFiles() {
        return imageAllowFiles;
    }
    public void setImageAllowFiles(String imageAllowFiles) {
        this.imageAllowFiles = imageAllowFiles;
    }
    public boolean isImageCompressEnable() {
        return imageCompressEnable;
    }
    public void setImageCompressEnable(boolean imageCompressEnable) {
        this.imageCompressEnable = imageCompressEnable;
    }
    public long getImageCompressBorder() {
        return imageCompressBorder;
    }
    public void setImageCompressBorder(long imageCompressBorder) {
        this.imageCompressBorder = imageCompressBorder;
    }
    public String getImageInsertAlign() {
        return imageInsertAlign;
    }
    public void setImageInsertAlign(String imageInsertAlign) {
        this.imageInsertAlign = imageInsertAlign;
    }
    public String getImageUrlPrefix() {
        return imageUrlPrefix;
    }
    public void setImageUrlPrefix(String imageUrlPrefix) {
        this.imageUrlPrefix = imageUrlPrefix;
    }
    public String getImagePathFormat() {
        return imagePathFormat;
    }
    public void setImagePathFormat(String imagePathFormat) {
        this.imagePathFormat = imagePathFormat;
    }
    public String getScrawlActionName() {
        return scrawlActionName;
    }
    public void setScrawlActionName(String scrawlActionName) {
        this.scrawlActionName = scrawlActionName;
    }
    public String getScrawlFieldName() {
        return scrawlFieldName;
    }
    public void setScrawlFieldName(String scrawlFieldName) {
        this.scrawlFieldName = scrawlFieldName;
    }
    public String getScrawlPathFormat() {
        return scrawlPathFormat;
    }
    public void setScrawlPathFormat(String scrawlPathFormat) {
        this.scrawlPathFormat = scrawlPathFormat;
    }
    public long getScrawlMaxSize() {
        return scrawlMaxSize;
    }
    public void setScrawlMaxSize(long scrawlMaxSize) {
        this.scrawlMaxSize = scrawlMaxSize;
    }
    public String getScrawlUrlPrefix() {
        return scrawlUrlPrefix;
    }
    public void setScrawlUrlPrefix(String scrawlUrlPrefix) {
        this.scrawlUrlPrefix = scrawlUrlPrefix;
    }
    public String getScrawlInsertAlign() {
        return scrawlInsertAlign;
    }
    public void setScrawlInsertAlign(String scrawlInsertAlign) {
        this.scrawlInsertAlign = scrawlInsertAlign;
    }
    public String getSnapscreenActionName() {
        return snapscreenActionName;
    }
    public void setSnapscreenActionName(String snapscreenActionName) {
        this.snapscreenActionName = snapscreenActionName;
    }
    public String getSnapscreenPathFormat() {
        return snapscreenPathFormat;
    }
    public void setSnapscreenPathFormat(String snapscreenPathFormat) {
        this.snapscreenPathFormat = snapscreenPathFormat;
    }
    public String getSnapscreenUrlPrefix() {
        return snapscreenUrlPrefix;
    }
    public void setSnapscreenUrlPrefix(String snapscreenUrlPrefix) {
        this.snapscreenUrlPrefix = snapscreenUrlPrefix;
    }
    public String getSnapscreenInsertAlign() {
        return snapscreenInsertAlign;
    }
    public void setSnapscreenInsertAlign(String snapscreenInsertAlign) {
        this.snapscreenInsertAlign = snapscreenInsertAlign;
    }
    public String getCatcherLocalDomain() {
        return catcherLocalDomain;
    }
    public void setCatcherLocalDomain(String catcherLocalDomain) {
        this.catcherLocalDomain = catcherLocalDomain;
    }
    public String getCatcherActionName() {
        return catcherActionName;
    }
    public void setCatcherActionName(String catcherActionName) {
        this.catcherActionName = catcherActionName;
    }
    public String getCatcherFieldName() {
        return catcherFieldName;
    }
    public void setCatcherFieldName(String catcherFieldName) {
        this.catcherFieldName = catcherFieldName;
    }
    public String getCatcherPathFormat() {
        return catcherPathFormat;
    }
    public void setCatcherPathFormat(String catcherPathFormat) {
        this.catcherPathFormat = catcherPathFormat;
    }
    public String getCatcherUrlPrefix() {
        return catcherUrlPrefix;
    }
    public void setCatcherUrlPrefix(String catcherUrlPrefix) {
        this.catcherUrlPrefix = catcherUrlPrefix;
    }
    public long getCatcherMaxSize() {
        return catcherMaxSize;
    }
    public void setCatcherMaxSize(long catcherMaxSize) {
        this.catcherMaxSize = catcherMaxSize;
    }
    public String getCatcherAllowFiles() {
        return catcherAllowFiles;
    }
    public void setCatcherAllowFiles(String catcherAllowFiles) {
        this.catcherAllowFiles = catcherAllowFiles;
    }
    public String getVideoActionName() {
        return videoActionName;
    }
    public void setVideoActionName(String videoActionName) {
        this.videoActionName = videoActionName;
    }
    public String getVideoFieldName() {
        return videoFieldName;
    }
    public void setVideoFieldName(String videoFieldName) {
        this.videoFieldName = videoFieldName;
    }
    public String getVideoPathFormat() {
        return videoPathFormat;
    }
    public void setVideoPathFormat(String videoPathFormat) {
        this.videoPathFormat = videoPathFormat;
    }
    public String getVideoUrlPrefix() {
        return videoUrlPrefix;
    }
    public void setVideoUrlPrefix(String videoUrlPrefix) {
        this.videoUrlPrefix = videoUrlPrefix;
    }
    public long getVideoMaxSize() {
        return videoMaxSize;
    }
    public void setVideoMaxSize(long videoMaxSize) {
        this.videoMaxSize = videoMaxSize;
    }
    public String getVideoAllowFiles() {
        return videoAllowFiles;
    }
    public void setVideoAllowFiles(String videoAllowFiles) {
        this.videoAllowFiles = videoAllowFiles;
    }
    public String getFileActionName() {
        return fileActionName;
    }
    public void setFileActionName(String fileActionName) {
        this.fileActionName = fileActionName;
    }
    public String getFileFieldName() {
        return fileFieldName;
    }
    public void setFileFieldName(String fileFieldName) {
        this.fileFieldName = fileFieldName;
    }
    public String getFilePathFormat() {
        return filePathFormat;
    }
    public void setFilePathFormat(String filePathFormat) {
        this.filePathFormat = filePathFormat;
    }
    public String getFileUrlPrefix() {
        return fileUrlPrefix;
    }
    public void setFileUrlPrefix(String fileUrlPrefix) {
        this.fileUrlPrefix = fileUrlPrefix;
    }
    public long getFileMaxSize() {
        return fileMaxSize;
    }
    public void setFileMaxSize(long fileMaxSize) {
        this.fileMaxSize = fileMaxSize;
    }
    public String getFileAllowFiles() {
        return fileAllowFiles;
    }
    public void setFileAllowFiles(String fileAllowFiles) {
        this.fileAllowFiles = fileAllowFiles;
    }
    public String getImageManagerActionName() {
        return imageManagerActionName;
    }
    public void setImageManagerActionName(String imageManagerActionName) {
        this.imageManagerActionName = imageManagerActionName;
    }
    public String getImageManagerListPath() {
        return imageManagerListPath;
    }
    public void setImageManagerListPath(String imageManagerListPath) {
        this.imageManagerListPath = imageManagerListPath;
    }
    public long getImageManagerListSize() {
        return imageManagerListSize;
    }
    public void setImageManagerListSize(long imageManagerListSize) {
        this.imageManagerListSize = imageManagerListSize;
    }
    public String getImageManagerUrlPrefix() {
        return imageManagerUrlPrefix;
    }
    public void setImageManagerUrlPrefix(String imageManagerUrlPrefix) {
        this.imageManagerUrlPrefix = imageManagerUrlPrefix;
    }
    public String getImageManagerInsertAlign() {
        return imageManagerInsertAlign;
    }
    public void setImageManagerInsertAlign(String imageManagerInsertAlign) {
        this.imageManagerInsertAlign = imageManagerInsertAlign;
    }
    public String getImageManagerAllowFiles() {
        return imageManagerAllowFiles;
    }
    public void setImageManagerAllowFiles(String imageManagerAllowFiles) {
        this.imageManagerAllowFiles = imageManagerAllowFiles;
    }
    public String getFileManagerActionName() {
        return fileManagerActionName;
    }
    public void setFileManagerActionName(String fileManagerActionName) {
        this.fileManagerActionName = fileManagerActionName;
    }
    public String getFileManagerListPath() {
        return fileManagerListPath;
    }
    public void setFileManagerListPath(String fileManagerListPath) {
        this.fileManagerListPath = fileManagerListPath;
    }
    public String getFileManagerUrlPrefix() {
        return fileManagerUrlPrefix;
    }
    public void setFileManagerUrlPrefix(String fileManagerUrlPrefix) {
        this.fileManagerUrlPrefix = fileManagerUrlPrefix;
    }
    public long getFileManagerListSize() {
        return fileManagerListSize;
    }
    public void setFileManagerListSize(long fileManagerListSize) {
        this.fileManagerListSize = fileManagerListSize;
    }
    public String getFileManagerAllowFiles() {
        return fileManagerAllowFiles;
    }
    public void setFileManagerAllowFiles(String fileManagerAllowFiles) {
        this.fileManagerAllowFiles = fileManagerAllowFiles;
    }
    public File getRootPath() {
        return rootPath;
    }
    public void setRootPath(File rootPath) {
        this.rootPath = rootPath;
    }
    public List<String> from(String src) {
        if (src == null)
            return null;
        return ListUtil.splitTrimExcludeEmpty(src, ',');
    }
    public List<String> addDot(List<String> list) {
        if (null == list)
            return null;
        List<String> ret = new LinkedList<String>();
        for (String s : list) {
            if (s.length() > 0)
                ret.add("." + s);
        }
        return ret;
    }
    public Map<String, Object> getAllConfig() {
        Map<String, Object> ret = new HashMap<String, Object>();
        ret.put("imageActionName", this.imageActionName);
        ret.put("imageFieldName", this.imageFieldName);
        ret.put("imageMaxSize", this.imageMaxSize);
        ret.put("imageAllowFiles", this.addDot(this.from(this.imageAllowFiles)));
        ret.put("imageCompressEnable", this.imageCompressEnable);
        ret.put("imageCompressBorder", this.imageCompressBorder);
        ;
        ret.put("imageInsertAlign", this.imageInsertAlign);
        ret.put("imageUrlPrefix", this.imageUrlPrefix);
        ret.put("imagePathFormat", this.imagePathFormat);
        ret.put("scrawlActionName", this.scrawlActionName);
        ret.put("scrawlFieldName", this.scrawlFieldName);
        ret.put("scrawlPathFormat", this.scrawlPathFormat);
        ret.put("scrawlMaxSize", this.scrawlMaxSize);
        ret.put("scrawlUrlPrefix", this.scrawlUrlPrefix);
        ret.put("scrawlInsertAlign", this.scrawlInsertAlign);
        ret.put("snapscreenActionName", this.snapscreenActionName);
        /* 上传保存路径,可以自定义保存路径和文件名格式 */
        ret.put("snapscreenPathFormat", this.snapscreenPathFormat);
        /* 图片访问路径前缀 */
        ret.put("snapscreenUrlPrefix", this.snapscreenUrlPrefix);
        /* 插入的图片浮动方式 */
        ret.put("snapscreenInsertAlign", this.snapscreenInsertAlign);
        /* 抓取远程图片配置 */
        ret.put("catcherLocalDomain", this.from(this.catcherLocalDomain));
        /* 执行抓取远程图片的action名称 */
        ret.put("catcherActionName", this.catcherActionName);
        /* 提交的图片列表表单名称 */
        ret.put("catcherFieldName", this.catcherFieldName);
        /* 上传保存路径,可以自定义保存路径和文件名格式 */
        ret.put("catcherPathFormat", this.catcherPathFormat);
        /* 图片访问路径前缀 */
        ret.put("catcherUrlPrefix", this.catcherUrlPrefix);
        /* 上传大小限制，单位B */
        ret.put("catcherMaxSize", this.catcherMaxSize);
        ret.put("catcherAllowFiles", this.addDot(this.from(this.catcherAllowFiles)));
        /* 上传视频配置 */
        /* 执行上传视频的action名称 */
        ret.put("videoActionName", this.videoActionName);
        /* 提交的视频表单名称 */
        ret.put("videoFieldName", this.videoFieldName);
        /* 上传保存路径,可以自定义保存路径和文件名格式 */
        ret.put("videoPathFormat", this.videoPathFormat);
        /* 视频访问路径前缀 */
        ret.put("videoUrlPrefix", this.videoUrlPrefix);
        ret.put("videoMaxSize", this.videoMaxSize);
        /* 上传视频格式显示 */
        ret.put("videoAllowFiles", this.addDot(this.from(this.videoAllowFiles)));
        /* 上传文件配置 */
        /* controller里,执行上传视频的action名称 */
        ret.put("fileActionName", this.fileActionName);
        /* 提交的文件表单名称 */
        ret.put("fileFieldName", this.fileFieldName);
        /* 上传保存路径,可以自定义保存路径和文件名格式 */
        ret.put("filePathFormat", this.filePathFormat);
        /* 文件访问路径前缀 */
        ret.put("fileUrlPrefix", this.fileUrlPrefix);
        /* 上传大小限制，单位B，默认50MB */
        ret.put("fileMaxSize", this.fileMaxSize);
        /* 上传文件格式显示 */
        ret.put("fileAllowFiles", this.addDot(this.from(this.fileAllowFiles)));
        /* 列出指定目录下的图片 */
        /* 执行图片管理的action名称 */
        ret.put("imageManagerActionName", this.imageManagerActionName);
        /* 指定要列出图片的目录 */
        ret.put("imageManagerListPath", this.imageManagerListPath);
        /* 每次列出文件数量 */
        ret.put("imageManagerListSize", this.imageManagerListSize);
        /* 图片访问路径前缀 */
        ret.put("imageManagerUrlPrefix", this.imageManagerUrlPrefix);
        /* 插入的图片浮动方式 */
        ret.put("imageManagerInsertAlign", this.imageManagerInsertAlign);
        /* 列出的文件类型 */
        ret.put("imageManagerAllowFiles", this.addDot(this.from(this.imageManagerAllowFiles)));
        /* 列出指定目录下的文件 */
        /* 执行文件管理的action名称 */
        ret.put("fileManagerActionName", this.fileManagerActionName);
        /* 指定要列出文件的目录 */
        ret.put("fileManagerListPath", this.fileManagerListPath);
        /* 文件访问路径前缀 */
        ret.put("fileManagerUrlPrefix", this.fileManagerUrlPrefix);
        /* 每次列出文件数量 */
        ret.put("fileManagerListSize", this.fileManagerListSize);
        /* 列出的文件类型 */
        ret.put("fileManagerAllowFiles", this.addDot(this.from(this.fileManagerAllowFiles)));
        return ret;
    }
}

src/main/java/com/ekexiu/portal/editor/PathFormat.java

@@ -0,0 +1,128 @@
package com.ekexiu.portal.editor;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PathFormat {
    private static Date currentDate = null;
    public static String parse(String input) {
        Pattern pattern = Pattern.compile("\\{([^\\}]+)\\}", 2);
        Matcher matcher = pattern.matcher(input);
        currentDate = new Date();
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, getString(matcher.group(1)));
        }
        matcher.appendTail(sb);
        return sb.toString();
    }
    public static String format(String input) {
        return input.replace("\\", "/");
    }
    public static String parse(String input, String filename) {
        Pattern pattern = Pattern.compile("\\{([^\\}]+)\\}", 2);
        Matcher matcher = pattern.matcher(input);
        String matchStr = null;
        currentDate = new Date();
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matchStr = matcher.group(1);
            if (matchStr.indexOf("filename") != -1) {
                filename = filename.replace("$", "\\$").replaceAll("[\\/:*?\"<>|]", "");
                matcher.appendReplacement(sb, filename);
            } else {
                matcher.appendReplacement(sb, getString(matchStr));
            }
        }
        matcher.appendTail(sb);
        return sb.toString();
    }
    private static String getString(String pattern) {
        pattern = pattern.toLowerCase();
        if (pattern.indexOf("time") != -1) {
            return "" + getTimestamp();
        }
        if (pattern.indexOf("yyyy") != -1) {
            return getFullYear();
        }
        if (pattern.indexOf("yy") != -1) {
            return getYear();
        }
        if (pattern.indexOf("mm") != -1) {
            return getMonth();
        }
        if (pattern.indexOf("dd") != -1) {
            return getDay();
        }
        if (pattern.indexOf("hh") != -1) {
            return getHour();
        }
        if (pattern.indexOf("ii") != -1) {
            return getMinute();
        }
        if (pattern.indexOf("ss") != -1) {
            return getSecond();
        }
        if (pattern.indexOf("rand") != -1) {
            return getRandom(pattern);
        }
        return pattern;
    }
    private static long getTimestamp() {
        return System.currentTimeMillis();
    }
    private static String getFullYear() {
        return new SimpleDateFormat("yyyy").format(currentDate);
    }
    private static String getYear() {
        return new SimpleDateFormat("yy").format(currentDate);
    }
    private static String getMonth() {
        return new SimpleDateFormat("MM").format(currentDate);
    }
    private static String getDay() {
        return new SimpleDateFormat("dd").format(currentDate);
    }
    private static String getHour() {
        return new SimpleDateFormat("HH").format(currentDate);
    }
    private static String getMinute() {
        return new SimpleDateFormat("mm").format(currentDate);
    }
    private static String getSecond() {
        return new SimpleDateFormat("ss").format(currentDate);
    }
    private static String getRandom(String pattern) {
        int length = 0;
        pattern = pattern.split(":")[1].trim();
        length = Integer.parseInt(pattern);
        return ("" + Math.random()).replace(".", "").substring(0, length);
    }
    public static void main(String[] args) {
    }
}

src/main/java/com/ekexiu/portal/editor/define/AppInfo.java

@@ -0,0 +1,65 @@
package com.ekexiu.portal.editor.define;
import java.util.HashMap;
import java.util.Map;
public class AppInfo {
    public static final int SUCCESS = 0;
    public static final int MAX_SIZE = 1;
    public static final int PERMISSION_DENIED = 2;
    public static final int FAILED_CREATE_FILE = 3;
    public static final int IO_ERROR = 4;
    public static final int NOT_MULTIPART_CONTENT = 5;
    public static final int PARSE_REQUEST_ERROR = 6;
    public static final int NOTFOUND_UPLOAD_DATA = 7;
    public static final int NOT_ALLOW_FILE_TYPE = 8;
    public static final int INVALID_ACTION = 101;
    public static final int CONFIG_ERROR = 102;
    public static final int PREVENT_HOST = 201;
    public static final int CONNECTION_ERROR = 202;
    public static final int REMOTE_FAIL = 203;
    public static final int NOT_DIRECTORY = 301;
    public static final int NOT_EXIST = 302;
    public static final int ILLEGAL = 401;
    public static Map<Integer, String> info = new HashMap<Integer, String>();
    public static String getStateInfo(int key) {
        return info.get(Integer.valueOf(key));
    }
    static {
        info.put(SUCCESS, "SUCCESS");
        info.put(INVALID_ACTION, "无效的Action");
        info.put(CONFIG_ERROR, "配置文件初始化失败");
        info.put(REMOTE_FAIL, "抓取远程图片失败");
        info.put(PREVENT_HOST, "被阻止的远程主机");
        info.put(CONNECTION_ERROR, "远程连接出错");
        info.put(MAX_SIZE, "文件大小超出限制");
        info.put(PERMISSION_DENIED, "权限不足");
        info.put(FAILED_CREATE_FILE, "创建文件失败");
        info.put(IO_ERROR, "IO错误");
        info.put(NOT_MULTIPART_CONTENT, "上传表单不是multipart/form-data类型");
        info.put(PARSE_REQUEST_ERROR, "解析上传表单错误");
        info.put(NOTFOUND_UPLOAD_DATA, "未找到上传数据");
        info.put(NOT_ALLOW_FILE_TYPE, "不允许的文件类型");
        info.put(NOT_DIRECTORY, "指定路径不是目录");
        info.put(NOT_EXIST, "指定路径并不存在");
        info.put(ILLEGAL, "Callback参数名不合法");
    }
}

src/main/java/com/ekexiu/portal/editor/define/BaseState.java

@@ -0,0 +1,89 @@
package com.ekexiu.portal.editor.define;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class BaseState implements State {
    private boolean state = false;
    private String info = null;
    private Map<String, String> infoMap = new HashMap<String, String>();
    public BaseState() {
        this.state = true;
    }
    public BaseState(boolean state) {
        setState(state);
    }
    public BaseState(boolean state, String info) {
        setState(state);
        this.info = info;
    }
    public BaseState(boolean state, int infoCode) {
        setState(state);
        this.info = AppInfo.getStateInfo(infoCode);
    }
    public boolean isSuccess() {
        return this.state;
    }
    public void setState(boolean state) {
        this.state = state;
    }
    public void setInfo(String info) {
        this.info = info;
    }
    public void setInfo(int infoCode) {
        this.info = AppInfo.getStateInfo(infoCode);
    }
    public String toJSONString() {
        return toString();
    }
    public String toString() {
        String key = null;
        String stateVal = isSuccess() ? AppInfo.getStateInfo(0) : this.info;
        StringBuilder builder = new StringBuilder();
        builder.append("{\"state\": \"" + stateVal + "\"");
        Iterator<String> iterator = this.infoMap.keySet().iterator();
        while (iterator.hasNext()) {
            key = (String) iterator.next();
            builder.append(",\"" + key + "\": \"" + (String) this.infoMap.get(key) + "\"");
        }
        builder.append("}");
        return toUnicode(builder.toString());
    }
    public void putInfo(String name, String val) {
        this.infoMap.put(name, val);
    }
    public void putInfo(String name, long val) {
        putInfo(name,""+val);
    }
    public static String toUnicode(String input) {
        StringBuilder builder = new StringBuilder();
        char[] chars = input.toCharArray();
        for (char ch : chars) {
            if (ch < '\u0100') {
                builder.append(ch);
            } else {
                builder.append("\\u" + Integer.toHexString(ch & 0xFFFF));
            }
        }
        return builder.toString();
    }
}

src/main/java/com/ekexiu/portal/editor/define/State.java

@@ -0,0 +1,11 @@
package com.ekexiu.portal.editor.define;
public interface State {
   boolean isSuccess();
   void putInfo(String name, String val);
   void putInfo(String name, long val);
    String toJSONString();
}