xwikidocument.java

xwiki 源码

                return null;
            else
                return url.toString();
        }
        else
            return context.getURLFactory().getURL(url, context);
    }

    public String getURL(String action, XWikiContext context) {
        return getURL(action, false, context);
    }

    public String getURL(String action, String querystring, XWikiContext context) {
        URL url = context.getURLFactory().createURL(getWeb(), getName(), action,
                querystring, null, context);
        return context.getURLFactory().getURL(url, context);
    }

    public String getExternalURL(String action, XWikiContext context) {
        URL url = context.getURLFactory().createExternalURL(getWeb(), getName(), action,
                null , null, context);
        return url.toString();
    }

    public String getExternalURL(String action, String querystring, XWikiContext context) {
        URL url = context.getURLFactory().createExternalURL(getWeb(), getName(), action,
                querystring, null, context);
        return url.toString();
    }


    public String getParentURL(XWikiContext context) throws XWikiException {
        XWikiDocument doc = new XWikiDocument();
        doc.setFullName(getParent(), context);
        URL url = context.getURLFactory().createURL(doc.getWeb(), doc.getName(), context);
        return context.getURLFactory().getURL(url, context);
    }

    public Version[] getRevisions(XWikiContext context) throws XWikiException {
        return getStore().getXWikiDocVersions(this, context);
    }

    public String[] getRecentRevisions(int nb, XWikiContext context) throws XWikiException {
        try {
            Version[] revisions = getStore().getXWikiDocVersions(this, context);
            int length = nb;

            // 0 means all revisions
            if (nb==0)
                length = revisions.length;

            if (revisions.length<length)
                length = revisions.length;

            String[] recentrevs = new String[length];
            for (int i = 1; i <= length; i++)
                recentrevs[i-1
                        ] = revisions[revisions.length-i].toString();
            return recentrevs;
        } catch (Exception e) {
            return new String[0];
        }
    }

    public Archive getRCSArchive() {
        return archive;
    }

    public void setRCSArchive(Archive archive) {
        this.archive = archive;
    }

    public String getArchive() throws XWikiException {
        return getArchive(null);
    }

    public String getArchive(XWikiContext context) throws XWikiException {
        if ((content==null)||(content.equals("")))
            setContent("\n");
        if (archive==null)
            updateArchive(toXML(context));
        if (archive==null)
            return "";
        else {
            StringBuffer buffer = new StringBuffer();
            archive.toString(buffer);
            return buffer.toString();
        }
    }

    public void setArchive(String text) throws XWikiException {
        try {
            StringInputStream is = new StringInputStream(text);
            archive = new Archive(getFullName(), is);
        }
        catch (Exception e) {
            Object[] args = { getFullName() };
            throw new XWikiException( XWikiException.MODULE_XWIKI_STORE, XWikiException.ERROR_XWIKI_STORE_ARCHIVEFORMAT,
                    "Exception while manipulating the archive for doc {0}", e, args);
        }
    }

    public void updateArchive(String text) throws XWikiException {
        try {
            Lines lines = new Lines(text);
            if (archive!=null)
                archive.addRevision(lines.toArray(),"");
            else
                archive = new Archive(lines.toArray(),getFullName(),getVersion());
        }
        catch (Exception e) {
            Object[] args = { getFullName() };
            throw new XWikiException( XWikiException.MODULE_XWIKI_STORE, XWikiException.ERROR_XWIKI_STORE_ARCHIVEFORMAT,
                    "Exception while manipulating the archive for doc {0}", e, args);
        }
    }

    public boolean isMostRecent() {
        return mostRecent;
    }

    public void setMostRecent(boolean mostRecent) {
        this.mostRecent = mostRecent;
    }

    public BaseClass getxWikiClass() {
        if (xWikiClass==null) {
            xWikiClass = new BaseClass();
            xWikiClass.setName(getFullName());
        }
        return xWikiClass;
    }

    public void setxWikiClass(BaseClass xWikiClass) {
        this.xWikiClass = xWikiClass;
    }

    public Map getxWikiObjects() {
        return xWikiObjects;
    }

    public void setxWikiObjects(Map xWikiObjects) {
        this.xWikiObjects = xWikiObjects;
    }

    public BaseObject getxWikiObject() {
        return getObject(getFullName());
    }

    public List getxWikiClasses(XWikiContext context) {
        List list = new ArrayList();
        for (Iterator it=getxWikiObjects().keySet().iterator();it.hasNext();) {
            String classname = (String) it.next();
            BaseClass bclass = null;
            Vector objects = getObjects(classname);
            for (int i=0;i<objects.size();i++) {
                BaseObject obj = (BaseObject) objects.get(i);
                if (obj!=null) {
                    bclass = obj.getxWikiClass(context);
                    if (bclass!=null)
                        break;
                }
            }
            if (bclass!=null)
                list.add(bclass);
        }
        return list;
    }

    public int createNewObject(String classname, XWikiContext context) throws XWikiException {
        BaseObject object = new BaseObject();
        object.setName(getFullName());
        object.setClassName(classname);
        Vector objects = getObjects(classname);
        if (objects==null) {
            objects = new Vector();
            setObjects(classname, objects);
        }
        objects.add(object);
        int nb = objects.size()-1;
        object.setNumber(nb);
        return nb;
    }

    public int getObjectNumbers(String classname) {
        try {
            return ((Vector)getxWikiObjects().get(classname)).size();
        } catch (Exception e) {
            return 0;
        }
    }

    public Vector getObjects(String classname) {
        return (Vector) getxWikiObjects().get(classname);
    }

    public void setObjects(String classname, Vector objects) {
        getxWikiObjects().put(classname, objects);
    }

    public BaseObject getObject(String classname) {
        Vector objects = (Vector)getxWikiObjects().get(classname);
        if (objects==null)
            return null;
        for (int i=0;i<objects.size();i++) {
            BaseObject obj = (BaseObject) objects.get(i);
            if (obj!=null)
                return obj;
        }
        return null;
    }

    public BaseObject getObject(String classname, int nb) {
        try {
            return (BaseObject) ((Vector)getxWikiObjects().get(classname)).get(nb);
        } catch (Exception e) {
            return null;
        }
    }

    public BaseObject getObject(String classname, String key, String value) {
        return getObject(classname, key, value, false);
    }

    public BaseObject getObject(String classname, String key, String value, boolean failover) {
        try {
            if (value==null) {
                if (failover)
                    return getObject(classname);
                else
                    return null;
            }

            Vector objects = (Vector)getxWikiObjects().get(classname);
            if ((objects==null)||(objects.size()==0))
                return null;
            for (int i=0;i<objects.size();i++) {
                BaseObject obj = (BaseObject) objects.get(i);
                if (obj!=null) {
                    if (value.equals(obj.getStringValue(key)))
                        return obj;
                }
            }

            if (failover)
                return getObject(classname);
            else
                return null;
        } catch (Exception e) {
            if (failover)
                return getObject(classname);

            e.printStackTrace();
            return null;
        }
    }


    public void addObject(String classname, BaseObject object) {
        Vector vobj = getObjects(classname);
        if (vobj==null)
            setObject(classname, 0, object);
        else
            setObject(classname, vobj.size(), object);
    }

    public void setObject(String classname, int nb, BaseObject object) {
        Vector objects = null;
        objects = getObjects(classname);
        if (objects==null) {
            objects = new Vector();
            setObjects(classname, objects);
        }
        if (nb >= objects.size()) {
            objects.setSize(nb+1);
        }
        objects.set(nb, object);
        object.setNumber(nb);
    }

    public boolean isNew() {
        return isNew;
    }

    public void setNew(boolean aNew) {
        isNew = aNew;
    }

    public void mergexWikiClass(XWikiDocument templatedoc) {
        BaseClass bclass = getxWikiClass();
        BaseClass tbclass = templatedoc.getxWikiClass();
        if (tbclass!=null) {
            if (bclass==null) {
                setxWikiClass((BaseClass)tbclass.clone());
            } else {
                getxWikiClass().merge((BaseClass)tbclass.clone());
            }
        }
    }

    public void mergexWikiObjects(XWikiDocument templatedoc) {
        // TODO: look for each object if it already exist and add it if it doesn't
        Iterator itobjects = templatedoc.getxWikiObjects().keySet().iterator();
        while (itobjects.hasNext()) {
            String name = (String) itobjects.next();
            Vector objects = (Vector) getxWikiObjects().get(name);

            if (objects!=null) {
                Vector tobjects = (Vector) templatedoc.getxWikiObjects().get(name);
                for (int i=0;i<tobjects.size();i++) {
                    {
                        BaseObject bobj = (BaseObject) ((BaseObject) tobjects.get(i)).clone();
                        objects.add(bobj);
                        bobj.setNumber(objects.size()-1);
                    }
                }
            } else {
                Vector tobjects = (Vector) templatedoc.getObjects(name);
                objects = new Vector();
                for (int i=0;i<tobjects.size();i++)
                {
                    BaseObject bobj1 = (BaseObject) tobjects.get(i);
                    if (bobj1!=null) {
                        BaseObject bobj = (BaseObject)bobj1.clone();
                        objects.add(bobj);
                        bobj.setNumber(objects.size()-1);
                    }
                }
                getxWikiObjects().put(name, objects);
            }
        }
    }

    public String getTemplate() {
        return template;
    }

    public void setTemplate(String template) {
        this.template = template;
    }

    public String display(String fieldname, String type, BaseObject obj, XWikiContext context) {
        try {
            type = type.toLowerCase();
            StringBuffer result = new StringBuffer();
            PropertyClass pclass = (PropertyClass) obj.getxWikiClass(context).get(fieldname);
            String prefix = obj.getxWikiClass(context).getName() + "_" + obj.getNumber() + "_";

            if (type.equals("view")) {
                pclass.displayView(result, fieldname, prefix, obj, context);
            }
            else if (type.equals("rendered")) {
                String fcontent = pclass.displayView(fieldname, prefix, obj, context);
                result.append(getRenderedContent(fcontent, context));
            }
            else if (type.equals("edit")) {
                result.append("{pre}");
                pclass.displayEdit(result, fieldname, prefix, obj, context);
                result.append("{/pre}");
            }
            else if (type.equals("hidden")) {
                result.append("{pre}");
                pclass.displayHidden(result, fieldname, prefix, obj, context);
                result.append("{/pre}");
            }
            else if (type.equals("search")) {
                result.append("{pre}");
                pclass.displaySearch(result, fieldname, prefix, obj, context);
                result.append("{/pre}");
            }
            else {
                pclass.displayView(result, fieldname, prefix, obj, context);
            }
            return result.toString();
        }
        catch (Exception e) {
            return "";
            // return "||Exception showing field " + fieldname + ": " + e.getMessage() + "||";
        }
    }