cmsimportexportconfiguration.java

来自「找了很久才找到到源代码」· Java 代码 · 共 999 行 · 第 1/3 页

        staticexportElement.addElement(N_LINKSUBSTITUTION_HANDLER).addText(
            m_staticExportManager.getLinkSubstitutionHandler().getClass().getName());

        // <exportpath> node
        String exportPathUnmodified = m_staticExportManager.getExportPathForConfiguration();
        // cut path seperator        
        if (exportPathUnmodified.endsWith(File.separator)) {
            exportPathUnmodified = exportPathUnmodified.substring(0, exportPathUnmodified.length() - 1);
        }
        staticexportElement.addElement(N_STATICEXPORT_EXPORTPATH).addText(exportPathUnmodified);

        // <exportworkpath> node
        String exportWorkPathUnmodified = m_staticExportManager.getExportWorkPathForConfiguration();
        if (exportWorkPathUnmodified != null) {
            // cut path seperator        
            if (exportWorkPathUnmodified.endsWith(File.separator)) {
                exportWorkPathUnmodified = exportWorkPathUnmodified.substring(0, exportWorkPathUnmodified.length() - 1);
            }
            staticexportElement.addElement(N_STATICEXPORT_EXPORTWORKPATH).addText(exportWorkPathUnmodified);
        }

        // <exportbackups> node
        if (m_staticExportManager.getExportBackups() != null) {
            String exportBackupsUnmodified = String.valueOf(m_staticExportManager.getExportBackups());
            staticexportElement.addElement(N_STATICEXPORT_EXPORTBACKUPS).addText(exportBackupsUnmodified);
        }

        // <defaultpropertyvalue> node
        staticexportElement.addElement(N_STATICEXPORT_DEFAULT).addText(m_staticExportManager.getDefault());

        // <defaultsuffixes> node and its <suffix> sub nodes
        Element defaultsuffixesElement = staticexportElement.addElement(N_STATICEXPORT_DEFAULTSUFFIXES);

        i = m_staticExportManager.getExportSuffixes().iterator();
        while (i.hasNext()) {
            String suffix = (String)i.next();
            Element suffixElement = defaultsuffixesElement.addElement(N_STATICEXPORT_SUFFIX);
            suffixElement.addAttribute(A_KEY, suffix);
        }

        // <exportheaders> node and its <header> sub nodes
        i = m_staticExportManager.getExportHeaders().iterator();
        if (i.hasNext()) {
            Element exportheadersElement = staticexportElement.addElement(N_STATICEXPORT_EXPORTHEADERS);
            while (i.hasNext()) {
                String header = (String)i.next();
                exportheadersElement.addElement(N_STATICEXPORT_HEADER).addText(header);
            }
        }
        // <requestheaders> node and the <acceptlanguage> and <acceptcharset> node
        String acceptlanguage = m_staticExportManager.getAcceptLanguageHeader();
        String acceptcharset = m_staticExportManager.getAcceptCharsetHeader();
        String remoteaddr = m_staticExportManager.getRemoteAddr();
        if ((acceptlanguage != null) || (acceptcharset != null) || (remoteaddr != null)) {
            Element requestheadersElement = staticexportElement.addElement(N_STATICEXPORT_REQUESTHEADERS);
            if (acceptlanguage != null) {
                requestheadersElement.addElement(N_STATICEXPORT_ACCEPTLANGUAGE).addText(acceptlanguage);
            }
            if (acceptcharset != null) {
                requestheadersElement.addElement(N_STATICEXPORT_ACCEPTCHARSET).addText(acceptcharset);
            }
            if (remoteaddr != null) {
                requestheadersElement.addElement(N_STATICEXPORT_REMOTEADDR).addText(remoteaddr);
            }
        }

        // <rendersettings> node
        Element rendersettingsElement = staticexportElement.addElement(N_STATICEXPORT_RENDERSETTINGS);

        // <rfsPrefix> node
        rendersettingsElement.addElement(N_STATICEXPORT_RFS_PREFIX).addText(
            m_staticExportManager.getRfsPrefixForConfiguration());

        // <vfsPrefix> node
        rendersettingsElement.addElement(N_STATICEXPORT_VFS_PREFIX).addText(
            m_staticExportManager.getVfsPrefixForConfiguration());

        // <userelativelinks> node
        rendersettingsElement.addElement(N_STATICEXPORT_RELATIVELINKS).addText(m_staticExportManager.getRelativeLinks());

        // <exporturl> node
        rendersettingsElement.addElement(N_STATICEXPORT_EXPORTURL).addText(
            m_staticExportManager.getExportUrlForConfiguration());

        // <plainoptimization> node
        rendersettingsElement.addElement(N_STATICEXPORT_PLAINOPTIMIZATION).addText(
            m_staticExportManager.getPlainExportOptimization());

        // <testresource> node
        Element testresourceElement = rendersettingsElement.addElement(N_STATICEXPORT_TESTRESOURCE);
        testresourceElement.addAttribute(A_URI, m_staticExportManager.getTestResource());

        // <resourcestorender> node and <regx> subnodes
        Element resourcetorenderElement = rendersettingsElement.addElement(N_STATICEXPORT_RESOURCESTORENDER);

        i = m_staticExportManager.getExportFolderPatterns().iterator();
        while (i.hasNext()) {
            String pattern = (String)i.next();
            resourcetorenderElement.addElement(N_STATICEXPORT_REGEX).addText(pattern);
        }

        if (!m_staticExportManager.getExportRules().isEmpty()) {
            // <export-rules> node
            Element exportRulesElement = resourcetorenderElement.addElement(N_STATICEXPORT_EXPORTRULES);

            i = m_staticExportManager.getExportRules().iterator();
            while (i.hasNext()) {
                CmsStaticExportExportRule rule = (CmsStaticExportExportRule)i.next();
                // <export-rule> node
                Element exportRuleElement = exportRulesElement.addElement(N_STATICEXPORT_EXPORTRULE);
                exportRuleElement.addElement(N_STATICEXPORT_NAME).addText(rule.getName());
                exportRuleElement.addElement(N_STATICEXPORT_DESCRIPTION).addText(rule.getDescription());
                // <modified-resources> node and <regex> subnodes
                Element modifiedElement = exportRuleElement.addElement(N_STATICEXPORT_MODIFIED);
                Iterator itMods = rule.getModifiedResources().iterator();
                while (itMods.hasNext()) {
                    Pattern regex = (Pattern)itMods.next();
                    modifiedElement.addElement(N_STATICEXPORT_REGEX).addText(regex.pattern());
                }
                // <export-resources> node and <uri> subnodes
                Element exportElement = exportRuleElement.addElement(N_STATICEXPORT_EXPORT);
                Iterator itExps = rule.getExportResourcePatterns().iterator();
                while (itExps.hasNext()) {
                    String uri = (String)itExps.next();
                    exportElement.addElement(N_STATICEXPORT_URI).addText(uri);
                }
            }
        }

        if (!m_staticExportManager.getRfsRules().isEmpty()) {
            // <rfs-rules> node
            Element rfsRulesElement = rendersettingsElement.addElement(N_STATICEXPORT_RFS_RULES);

            i = m_staticExportManager.getRfsRules().iterator();
            while (i.hasNext()) {
                CmsStaticExportRfsRule rule = (CmsStaticExportRfsRule)i.next();
                // <rfs-rule> node and subnodes
                Element rfsRuleElement = rfsRulesElement.addElement(N_STATICEXPORT_RFS_RULE);
                rfsRuleElement.addElement(N_STATICEXPORT_NAME).addText(rule.getName());
                rfsRuleElement.addElement(N_STATICEXPORT_DESCRIPTION).addText(rule.getDescription());
                rfsRuleElement.addElement(N_STATICEXPORT_SOURCE).addText(rule.getSource().pattern());
                rfsRuleElement.addElement(N_STATICEXPORT_RFS_PREFIX).addText(rule.getRfsPrefixConfigured());
                rfsRuleElement.addElement(N_STATICEXPORT_EXPORTPATH).addText(rule.getExportPathConfigured());
                if (rule.getExportWorkPathConfigured() != null) {
                    rfsRuleElement.addElement(N_STATICEXPORT_EXPORTWORKPATH).addText(rule.getExportWorkPathConfigured());
                }
                if (rule.getExportBackups() != null) {
                    rfsRuleElement.addElement(N_STATICEXPORT_EXPORTBACKUPS).addText(
                        String.valueOf(rule.getExportBackups()));
                }
                if (rule.getUseRelativeLinks() != null) {
                    rfsRuleElement.addElement(N_STATICEXPORT_RELATIVELINKS).addText(
                        rule.getUseRelativeLinks().toString());
                }
                Element relatedSystemRes = rfsRuleElement.addElement(N_STATICEXPORT_RELATED_SYSTEM_RES);
                Iterator itSystemRes = rule.getRelatedSystemResources().iterator();
                while (itSystemRes.hasNext()) {
                    Pattern sysRes = (Pattern)itSystemRes.next();
                    relatedSystemRes.addElement(N_STATICEXPORT_REGEX).addText(sysRes.pattern());
                }
            }

        }

        if (m_importExportManager.getUserExportSettings() != null) {
            // <usercsvexport>
            Element userExportElement = parent.addElement(N_USERCSVEXPORT);

            userExportElement.addElement(N_SEPARATOR).setText(
                m_importExportManager.getUserExportSettings().getSeparator());
            Element exportColumns = userExportElement.addElement(N_COLUMNS);
            List exportColumnList = m_importExportManager.getUserExportSettings().getColumns();
            Iterator itExportColumnList = exportColumnList.iterator();
            while (itExportColumnList.hasNext()) {
                exportColumns.addElement(N_COLUMN).setText((String)itExportColumnList.next());
            }
            // </usercsvexport>
        }

        if (m_repositoryManager.isConfigured()) {
            List repositories = m_repositoryManager.getRepositories();
            if (repositories != null) {

                // <repositories> node
                Element repositoriesElement = parent.addElement(N_REPOSITORIES);

                i = repositories.iterator();
                while (i.hasNext()) {

                    // <repository> node
                    A_CmsRepository repository = (A_CmsRepository)i.next();
                    Element repositoryElement = repositoriesElement.addElement(N_REPOSITORY);
                    repositoryElement.addAttribute(A_NAME, repository.getName());
                    repositoryElement.addAttribute(A_CLASS, repository.getClass().getName());

                    // <params> node
                    Map config = repository.getConfiguration();
                    if ((config != null) && (config.size() > 0)) {
                        Element paramsElement = repositoryElement.addElement(N_PARAMS);

                        Iterator it = config.entrySet().iterator();
                        while (it.hasNext()) {
                            Map.Entry e = (Map.Entry)it.next();
                            String key = (String)e.getKey();
                            String[] value = (String[])e.getValue();

                            // <param> nodes
                            for (int j = 0; j < value.length; j++) {
                                Element paramNode = paramsElement.addElement(N_PARAM);
                                paramNode.addAttribute(A_NAME, key);
                                paramNode.addText(value[j]);
                            }
                        }
                    }

                    // <filter> node
                    CmsRepositoryFilter filter = repository.getFilter();
                    if (filter != null) {
                        List rules = filter.getFilterRules();
                        if (rules.size() > 0) {
                            Element filterElement = repositoryElement.addElement(N_FILTER);
                            filterElement.addAttribute(A_TYPE, filter.getType());

                            // <regex> nodes
                            Iterator it = rules.iterator();
                            while (it.hasNext()) {
                                Pattern rule = (Pattern)it.next();
                                filterElement.addElement(N_REGEX).addText(rule.pattern());
                            }
                        }
                    }
                }
            }
        }

        // return the configured node
        return importexportElement;
    }

    /**
     * @see org.opencms.configuration.I_CmsXmlConfiguration#getDtdFilename()
     */
    public String getDtdFilename() {

        return CONFIGURATION_DTD_NAME;
    }

    /**
     * Returns the initialized import/export manager.<p>
     * 
     * @return the initialized import/export manager
     */
    public CmsImportExportManager getImportExportManager() {

        return m_importExportManager;
    }

    /**
     * Returns the initialized repository manager.<p>
     * 
     * @return the initialized repository manager
     */
    public CmsRepositoryManager getRepositoryManager() {

        return m_repositoryManager;
    }

    /**
     * Returns the initialized static export manager.<p>
     * 
     * @return the initialized static export manager
     */
    public CmsStaticExportManager getStaticExportManager() {

        return m_staticExportManager;
    }

    /**
     * Will be called when configuration of this object is finished.<p> 
     */
    public void initializeFinished() {

        if (CmsLog.INIT.isInfoEnabled()) {
            CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_IMPORT_CONFIG_FINISHED_0));
        }
    }

    /**
     * Sets the generated import/export manager.<p>
     * 
     * @param manager the import/export manager to set
     */
    public void setImportExportManager(CmsImportExportManager manager) {

        m_importExportManager = manager;
        if (CmsLog.INIT.isInfoEnabled()) {
            CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_IMPORT_MANAGER_0));
        }
    }

    /**
     * Sets the generated repository manager.<p>
     * 
     * @param manager the repository manager to set
     */
    public void setRepositoryManager(CmsRepositoryManager manager) {

        m_repositoryManager = manager;
    }

    /**
     * Sets the generated static export manager.<p>
     * 
     * @param manager the static export manager to set
     */
    public void setStaticExportManager(CmsStaticExportManager manager) {

        m_staticExportManager = manager;
        if (CmsLog.INIT.isInfoEnabled()) {
            CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_STATEXP_MANAGER_0));
        }
    }

    /**
     * Sets the user settings for export and import.<p>
     * 
     * @param userExportSettings the user settings for export and import
     */
    public void setUserExportSettings(CmsUserExportSettings userExportSettings) {

        m_importExportManager.setUserExportSettings(userExportSettings);
    }
}