JSPWiki文件名转换问题

   1:/**
   2: * created on 2005-9-8 by dengber.
   3: */
   4:package net.sf.startemplate;
   5:
   6:import org.apache.log4j.logger;
   7:
   8:import com.ecyrd.jspwiki.providers.versioningfileprovider;
   9:
  10:/**
  11: * a privider for jspwiki.
  12: * this class behaves the same with <code>versioningfileprovider</code> provided
  13: * by jspwiki,excepting it saves wiki pages into harddisk with the name inputted
  14: * by the user. this is different with <code>versioningfileprovider</code>, it
  15: * will save wiki pages with a encoded name, such as %e6%b5%8b%e8%af%95.
  16: * though it is a good solution to save files whos name may contains any 
  17: * charachers in the world, it is not readable.
  18: * <br /><br />
  19: * for many people, they use jspwiki only in a intranet, the character problem 
  20: * above is nothing to them. saving wiki pages with the native charachter names 
  21: * may working well to them. so this class is a choice to that people: the wiki
  22: * pages in harddisk have a readable name.
  23: * <br /><br />
  24: * danger: if the jspwiki user can input a character that can not be proccessed
  25: * by your server, not use this class.
  26: * <br /><br />
  27: * how to use:copy the jar file that contains this class to <b>lib</b> 
  28: * directory of your jspwiki webapp, and set the following value to 
  29: * jspwiki.properties:
  30: * jspwiki.pageprovider=net.sf.startemplate.nativefilenameversioningfileprovider 
  31: * 
  32: * @author dengber [email protected]
  33: * 
  34: */
  35:public class nativefilenameversioningfileprovider extends
  36:        versioningfileprovider {
  37:    private static final logger log = logger
  38:            .getlogger(nativefilenameversioningfileprovider.class);
  39:
  40:    /**
  41:     * convert string to the formatting that can be as file name.
  42:     * 
  43:     * @param pagename
  44:     * @return
  45:     */
  46:    protected string manglename(string pagename) {
  47:        final string[] windows_device_names = { "con", "prn", "nul",
  48:            "aux", "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7",
  49:            "lpt8", "lpt9", "com1", "com2", "com3", "com4", "com5", "com6",
  50:            "com7", "com8", "com9" };
  51:
  52:        log.debug("manglename(" + pagename + ")");
  53:        pagename = textutil.encodefilename(pagename);
  54:
  55:        boolean windowshackneeded = false;
  56:        string os = system.getproperty("os.name").tolowercase();
  57:
  58:        if (os.startswith("windows") || os.equals("nt")) {
  59:            windowshackneeded = true;
  60:        }
  61:
  62:        if (windowshackneeded) {
  63:            string pn = pagename.tolowercase();
  64:            for (int i = 0; i < windows_device_names.length; i++) {
  65:                if (windows_device_names[i].equals(pn)) {
  66:                    pagename = "$$$" + pagename;
  67:                }
  68:            }
  69:        }
  70:
  71:        log.debug("manglename()=" + pagename);
  72:        return pagename;
  73:    }
  74:
  75:    /**
  76:     * convert string converted by <code>manglename()</code> to its orginal 
  77:     * value.
  78:     * 
  79:     * @param pagename
  80:     * @return 
  81:     */
  82:    protected string unmanglename(string pagename) {
  83:        log.debug("unmanglename(" + pagename + ")");
  84:        boolean windowshackneeded = false;
  85:        string os = system.getproperty("os.name").tolowercase();
  86:
  87:        if (os.startswith("windows") || os.equals("nt")) {
  88:            windowshackneeded = true;
  89:        }
  90:
  91:        if (windowshackneeded && pagename.startswith("$$$")
  92:                && pagename.length() > 3) {
  93:            pagename = pagename.substring(3);
  94:        }
  95:
  96:        log.debug("unmanglename()=" + pagename);
  97:        return textutil.decodefilename(pagename);
  98:    }
  99:
 100:}
 101:

   1:/**
   2: * created on 2005-9-11 by dengber.
   3: */
   4:package net.sf.startemplate;
   5:
   6:import org.apache.log4j.logger;
   7:
   8:import com.ecyrd.jspwiki.providers.basicattachmentprovider;
   9:
  10:/**
  11: * a privider for jspwiki.
  12: * this class behaves the same with <code>versioningfileprovider</code> provided
  13: * by jspwiki,excepting it saves wiki pages into harddisk with the name inputted
  14: * by the user. this is different with <code>versioningfileprovider</code>, it
  15: * will save wiki pages with a encoded name, such as %e6%b5%8b%e8%af%95.
  16: * 
  17: * @see net.sf.startemplate.nativefilenameversioningfileprovider
  18: * 
  19: * @author dengber [email protected]
  20: *
  21: */
  22:public class nativefilenameattachmentprovider extends basicattachmentprovider {
  23:    private static final logger log = logger.getlogger(nativefilenameattachmentprovider.class);
  24:    
  25:    /**
  26:     * convert string to the formatting that can be as file name.
  27:     * 
  28:     * @param pagename
  29:     * @return
  30:     */
  31:    protected string manglename(string pagename) {
  32:        log.debug("manglename(" + pagename + "");
  33:        return textutil.encodefilename(pagename);
  34:    }
  35:
  36:    /**
  37:     * convert string converted by <code>manglename()</code> to its orginal 
  38:     * value.
  39:     * 
  40:     * @param pagename
  41:     * @return 
  42:     */
  43:    protected string unmanglename(string pagename) {
  44:        log.debug("unmanglename(" + pagename + "");
  45:        return textutil.decodefilename(pagename);
  46:    }
  47:}
  48:

   1:/**
   2: * created on 2005-9-11 by dengber.
   3: */
   4:package net.sf.startemplate;
   5:
   6:import org.apache.log4j.logger;
   7:
   8:/**
   9: * a utility class for string processing.
  10: * 
  11: * @author dengber [email protected]
  12: * 
  13: */
  14:public class textutil {
  15:
  16:    /**
  17:     * encode //:*?<>|% to %nn%nn formatting.
  18:     * 
  19:     * @param filename
  20:     * @return
  21:     */
  22:    public static string encodefilename(string filename) {
  23:        stringbuffer result = new stringbuffer();
  24:        final string hex_digits = "0123456789abcdef";
  25:
  26:        for (int i = 0; i < filename.length(); i++) {
  27:            char c = filename.charat(i);
  28:            switch (c) {
  29:            case '//':
  30:            case '/':
  31:            case ':':
  32:            case '*':
  33:            case '?':
  34:            case '/"':
  35:            case '<':
  36:            case '>':
  37:            case '|':
  38:            case '%':
  39:                result.append('%');
  40:                //the character above is all one-byte character,
  41:                //so we only need to encode the most right 8 bit.
  42:                result.append(hex_digits.charat((c & 0xf0) >> 4));
  43:                result.append(hex_digits.charat(c & 0x0f));
  44:                break;
  45:            default:
  46:                result.append(c);
  47:            }
  48:        }
  49:
  50:        return result.tostring();
  51:    }
  52:
  53:    /**
  54:     * decode %nn%nn formatting string to its orginal value .
  55:     * 
  56:     * @param filename
  57:     * @return
  58:     */
  59:    public static string decodefilename(string filename) {
  60:        stringbuffer result = new stringbuffer();
  61:
  62:        for (int i = 0; i < filename.length(); i++) {
  63:            char c = filename.charat(i);
  64:            switch (c) {
  65:            case '%':
  66:                char upper = filename.charat(++i);
  67:                char lower = filename.charat(++i);
  68:                char ch = (char) integer.parseint("" + upper + lower, 16);
  69:                result.append(ch);
  70:                break;
  71:
  72:            default:
  73:                result.append(c);
  74:                break;
  75:            }
  76:        }
  77:
  78:        return result.tostring();
  79:    }
  80:
  81:}
  82: