xwiki.java

xwiki 源码

            try {
                result = object.getStringValue(prefname);
                // If empty we take it from the default pref object
            } catch (Exception e) {
            }

            if (result.equals(""))
                result = doc.getxWikiObject().getStringValue(prefname);

            if (!result.equals(""))
                return result;
        } catch (Exception e) {
        }
        return getXWikiPreference(prefname, default_value, context);
    }

    public String getUserPreference(String prefname, XWikiContext context) {
        try {
            String user = context.getUser();
            XWikiDocument userdoc = getDocument(user, context);
            if (userdoc != null) {
                String result = userdoc.getStringValue("XWiki.XWikiUsers", prefname);
                if (!result.equals(""))
                    return result;
            }
        } catch (Exception e) {
        }

        return getWebPreference(prefname, context);
    }


    public String getUserPreferenceFromCookie(String prefname, XWikiContext context) {
        Cookie[] cookies = context.getRequest().getCookies();
        if (cookies == null)
            return null;
        for (int i = 0; i < cookies.length; i++) {
            String name = cookies[i].getName();
            if (name.equals(prefname)) {
                String value = cookies[i].getValue();
                if (!value.trim().equals(""))
                    return value;
                else
                    break;
            }
        }
        return null;
    }

    public String getUserPreference(String prefname, boolean useCookie, XWikiContext context) {
        // First we look in the cookies
        if (useCookie) {
            String result = getUserPreferenceFromCookie(prefname, context);
            if (result != null)
                return result;
        }
        return getUserPreference(prefname, context);
    }

    public String getLanguagePreference(XWikiContext context) {
        // First we get the language from the request
        String language;

        language = context.getLanguage();
        if (language != null)
            return language;

        if (!context.getWiki().isMultiLingual(context)) {
            language = context.getWiki().getXWikiPreference("language", "", context);
            context.setLanguage(language);
            return language;
        }

        try {
            language = context.getRequest().getParameter("language");
            if ((language != null) && (!language.equals(""))) {
                if (language.equals("default")) {
                    // forgetting language cookie
                    Cookie cookie = new Cookie("language", "");
                    cookie.setMaxAge(0);
                    cookie.setPath("/");
                    context.getResponse().addCookie(cookie);
                    language = "";
                } else {
                    // setting language cookie
                    Cookie cookie = new Cookie("language", language);
                    cookie.setMaxAge(60 * 60 * 24 * 365 * 10);
                    cookie.setPath("/");
                    context.getResponse().addCookie(cookie);
                }
                context.setLanguage(language);
                return language;
            }
        } catch (Exception e) {
        }

        try {
            // First we get the language from the cookie
            language = getUserPreferenceFromCookie("language", context);
            if ((language != null) && (!language.equals(""))) {
                context.setLanguage(language);
                return language;
            }
        } catch (Exception e) {
        }

        // Next from the default user preference
        try {
            String user = context.getUser();
            XWikiDocument userdoc = null;
            userdoc = getDocument(user, context);
            if (userdoc != null) {
                language = userdoc.getStringValue("XWiki.XWikiUsers", "default_language");
                if (!language.equals("")) {
                    context.setLanguage(language);
                    return language;
                }
            }
        } catch (XWikiException e) {
        }

        // Then from the navigator language setting
        if (context.getRequest() != null) {
            String accept = context.getRequest().getHeader("Accept-Language");
            if ((accept == null) || (accept.equals(""))) {
                context.setLanguage("");
                return "";
            }

            String[] alist = StringUtils.split(accept, ",;-");
            if ((alist == null) || (alist.length == 0)) {
                context.setLanguage("");
                return "";
            } else {
                context.setLanguage(alist[0]);
                return alist[0];
            }
        }

        context.setLanguage("");
        return "";
    }

    public long getXWikiPreferenceAsLong(String prefname, XWikiContext context) {
        return Long.parseLong(getXWikiPreference(prefname, context));
    }

    public long getWebPreferenceAsLong(String prefname, XWikiContext context) {
        return Long.parseLong(getWebPreference(prefname, context));
    }

    public long getXWikiPreferenceAsLong(String prefname, long default_value, XWikiContext context) {
        try {
            return Long.parseLong(getXWikiPreference(prefname, context));
        } catch (NumberFormatException e) {
            return default_value;
        }
    }

    public long getWebPreferenceAsLong(String prefname, long default_value, XWikiContext context) {
        try {
            return Long.parseLong(getWebPreference(prefname, context));
        } catch (NumberFormatException e) {
            return default_value;
        }
    }

    public long getUserPreferenceAsLong(String prefname, XWikiContext context) {
        return Long.parseLong(getUserPreference(prefname, context));
    }

    public int getXWikiPreferenceAsInt(String prefname, XWikiContext context) {
        return Integer.parseInt(getXWikiPreference(prefname, context));
    }

    public int getWebPreferenceAsInt(String prefname, XWikiContext context) {
        return Integer.parseInt(getWebPreference(prefname, context));
    }

    public int getXWikiPreferenceAsInt(String prefname, int default_value, XWikiContext context) {
        try {
            return Integer.parseInt(getXWikiPreference(prefname, context));
        } catch (NumberFormatException e) {
            return default_value;
        }
    }

    public int getWebPreferenceAsInt(String prefname, int default_value, XWikiContext context) {
        try {
            return Integer.parseInt(getWebPreference(prefname, context));
        } catch (NumberFormatException e) {
            return default_value;
        }
    }

    public int getUserPreferenceAsInt(String prefname, XWikiContext context) {
        return Integer.parseInt(getUserPreference(prefname, context));
    }

    public void flushCache() {
        // We need to flush the virtual wiki list
        virtualWikiList = new ArrayList();
        // We need to flush the server Cache
        virtualWikiMap = new HashMap();

        // We need to flush the group service cache
        if (groupService != null)
            groupService.flushCache();

        // If we use the Cache Store layer.. we need to flush it
        XWikiStoreInterface store = getStore();
        if ((store != null) && (store instanceof XWikiCacheStoreInterface)) {
            ((XWikiCacheStoreInterface) getStore()).flushCache();
        }
        // Flush renderers.. Groovy renderer has a cache
        XWikiRenderingEngine rengine = getRenderingEngine();
        if (rengine != null)
            rengine.flushCache();

        XWikiPluginManager pmanager = getPluginManager();
        if (pmanager != null)
            pmanager.flushCache();

    }

    public XWikiPluginManager getPluginManager() {
        return pluginManager;
    }

    public void setPluginManager(XWikiPluginManager pluginManager) {
        this.pluginManager = pluginManager;
    }

    public void setConfig(XWikiConfig config) {
        this.config = config;
    }

    public void setStore(XWikiStoreInterface store) {
        this.store = store;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public XWikiNotificationManager getNotificationManager() {
        return notificationManager;
    }

    public void setNotificationManager(XWikiNotificationManager notificationManager) {
        this.notificationManager = notificationManager;
    }

    public void notify(XWikiNotificationRule rule, XWikiDocument newdoc, XWikiDocument olddoc, int event, XWikiContext context) {
        if (!isVirtual()) {
            if (newdoc.getFullName().equals("XWiki.XWikiPreferences")) {
                preparePlugins(context);
            }
        }
    }

    public BaseClass getUserClass(XWikiContext context) throws XWikiException {
        XWikiDocument doc;
        boolean needsUpdate = false;

        try {
            doc = getDocument("XWiki.XWikiUsers", context);
        } catch (Exception e) {
            doc = new XWikiDocument();
            doc.setWeb("XWiki");
            doc.setName("XWikiUsers");
            needsUpdate = true;
        }

        BaseClass bclass = doc.getxWikiClass();
        if (context.get("initdone") != null)
            return bclass;

        bclass.setName("XWiki.XWikiUsers");

        needsUpdate |= bclass.addTextField("first_name", "First Name", 30);
        needsUpdate |= bclass.addTextField("last_name", "Last Name", 30);
        needsUpdate |= bclass.addTextField("email", "e-Mail", 30);
        needsUpdate |= bclass.addPasswordField("password", "Password", 10);
        needsUpdate |= bclass.addPasswordField("validkey", "Validation Key", 10);
        needsUpdate |= bclass.addBooleanField("active", "Active", "active");
        needsUpdate |= bclass.addTextField("default_language", "Default Language", 30);
        needsUpdate |= bclass.addTextField("company", "Company", 30);
        needsUpdate |= bclass.addTextField("blog", "Blog", 60);
        needsUpdate |= bclass.addTextField("blogfeed", "Blog Feed", 60);
        needsUpdate |= bclass.addTextAreaField("comment", "Comment", 40, 5);
        needsUpdate |= bclass.addStaticListField("imtype", "IM Type", "---|AIM|Yahoo|Jabber|MSN|Skype|ICQ");
        needsUpdate |= bclass.addTextField("imaccount", "imaccount", 30);

        String content = doc.getContent();
        if ((content == null) || (content.equals(""))) {
            needsUpdate = true;
            doc.setContent("1 XWiki Users");
        }

        if (needsUpdate)
            saveDocument(doc, context);
        return bclass;
    }

    public BaseClass getPrefsClass(XWikiContext context) throws XWikiException {
        XWikiDocument doc;
        boolean needsUpdate = false;

        try {
            doc = getDocument("XWiki.XWikiPreferences", context);
        } catch (Exception e) {
            doc = new XWikiDocument();
            doc.setWeb("XWiki");
            doc.setName("XWikiPreferences");
            needsUpdate = true;
        }

        BaseClass bclass = doc.getxWikiClass();
        if (context.get("initdone") != null)
            return bclass;

        bclass.setName("XWiki.XWikiPreferences");

        needsUpdate |= bclass.addBooleanField("multilingual", "Multi-Lingual", "yesno");
        needsUpdate |= bclass.addTextField("language", "Language", 5);
        needsUpdate |= bclass.addTextField("default_language", "Default Language", 5);
        needsUpdate |= bclass.addBooleanField("authenticate_edit", "Authenticated Edit", "yesno");
        needsUpdate |= bclass.addBooleanField("authenticate_view", "Authenticated View", "yesno");

        needsUpdate |= bclass.addTextField("skin", "Skin", 30);
        // This one should not be in the prefs
        PropertyInterface baseskinProp = bclass.get("baseskin");
        if (baseskinProp != null) {
            bclass.removeField("baseskin");
            needsUpdate = true;
        }
        needsUpdate |= bclass.addTextField("stylesheet", "Default Stylesheet", 30);
        needsUpdate |= bclass.addTextField("stylesheets", "Alternative Stylesheet", 60);

        needsUpdate |= bclass.addStaticListField("editor", "Default Editor", "Text|Wysiwyg");
        needsUpdate |= bclass.addTextField("editbox_width", "Editbox Width", 5);
        needsUpdate |= bclass.addTextField("editbox_height", "Editbox Height", 5);

        needsUpdate |= bclass.addTextField("webcopyright", "Copyright", 30);
        needsUpdate |= bclass.addTextField("title", "Title", 30);
        needsUpdate |= bclass.addTextField("version", "Version", 30);
        needsUpdate |= bclass.addTextAreaField("menu", "Menu", 60, 8);
        needsUpdate |= bclass.addTextAreaField("meta", "HTTP Meta Info", 60, 8);