You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@struts.apache.org by "Greg Huber (JIRA)" <ji...@apache.org> on 2012/11/14 18:22:12 UTC
[jira] [Created] (WW-3922) Make javatemplates work with other
plugins
Greg Huber created WW-3922:
------------------------------
Summary: Make javatemplates work with other plugins
Key: WW-3922
URL: https://issues.apache.org/jira/browse/WW-3922
Project: Struts 2
Issue Type: Improvement
Components: Plugin - Java Templates
Affects Versions: 2.3.4.1
Reporter: Greg Huber
Hello,
Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
Here are the changes needed to the JavaTemplateEngine.java get it to work.
Cheers Greg
{code:java}
package org.apache.struts2.views.java;
import org.apache.struts2.StrutsException;
import org.apache.struts2.components.template.BaseTemplateEngine;
import org.apache.struts2.components.template.Template;
import org.apache.struts2.components.template.TemplateEngine;
import org.apache.struts2.components.template.TemplateEngineManager;
import org.apache.struts2.components.template.TemplateRenderingContext;
import org.apache.struts2.views.java.simple.SimpleTheme;
import java.util.HashMap;
import java.util.StringTokenizer;
import com.opensymphony.xwork2.util.logging.LoggerFactory;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.ClassLoaderUtil;
import com.opensymphony.xwork2.config.ConfigurationException;
import com.opensymphony.xwork2.inject.Inject;
/**
* Template engine that renders tags using java implementations
*/
public class JavaTemplateEngine extends BaseTemplateEngine {
private static final Logger LOG = LoggerFactory
.getLogger(JavaTemplateEngine.class);
// The struts template engine manager
protected TemplateEngineManager templateEngineManager;
// The struts default template type. If struts ever changes this will need
// updating.
private String defaultTemplateType = "ftl";
@Inject
public void setTemplateEngineManager(TemplateEngineManager mgr) {
this.templateEngineManager = mgr;
}
private Themes themes = new Themes() {
{
add(new SimpleTheme());
}
};
@Override
protected String getSuffix() {
return "java";
}
public void renderTemplate(TemplateRenderingContext templateContext)
throws Exception {
Template t = templateContext.getTemplate();
Theme theme = themes.get(t.getTheme());
if (theme == null) {
// Theme not supported, so do what struts would have done if we were
// not here.
if (LOG.isDebugEnabled()) {
LOG.debug("Theme not found " + t.getTheme()
+ "trying default templete engine using template type "
+ defaultTemplateType);
}
final TemplateEngine engine = templateEngineManager
.getTemplateEngine(templateContext.getTemplate(),
defaultTemplateType);
if (engine == null) {
// May be the default template has changed?
throw new ConfigurationException(
"Unable to find a TemplateEngine for template type '"
+ defaultTemplateType
+ "' whilst trying to render template "
+ templateContext.getTemplate());
} else {
try {
// Retry render
engine.renderTemplate(templateContext);
} catch (Exception e) {
// Give up and throw a new StrutsException(e);
throw new StrutsException("Cannot render tag ["
+ t.getName() + "] because theme [" + t.getTheme()
+ "] was not found.");
}
}
} else {
// Render our template
theme.renderTag(t.getName(), templateContext);
}
}
private class Themes {
private HashMap<String, Theme> themes = new HashMap<String, Theme>();
public void add(Theme theme) {
themes.put(theme.getName(), theme);
}
public Theme get(String name) {
return themes.get(name);
}
}
/**
* Allows for providing custom theme classes (implementations of the
* org.apache.struts2.views.java.Theme) interface for custom rendering of
* tags using the javatemplates engine
*
* @param themeClasses
* a comma delimited list of custom theme class names
*/
@Inject(value = "struts.javatemplates.customThemes", required = false)
public void setThemeClasses(String themeClasses) {
StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
while (customThemes.hasMoreTokens()) {
String themeClass = customThemes.nextToken().trim();
try {
if (LOG.isInfoEnabled()) {
LOG.info("Registering custom theme '" + themeClass
+ "' to javatemplates engine");
}
// FIXME: This means Themes must have no-arg constructor -
// should use object factory here
// ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
// getClass()), null);
themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
getClass()).newInstance());
} catch (ClassCastException cce) {
LOG.error("Invalid java them class '"
+ themeClass
+ "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
} catch (ClassNotFoundException cnf) {
LOG.error("Invalid java theme class '" + themeClass
+ "'. Class not found");
} catch (Exception e) {
LOG.error("Could not find messages file " + themeClass
+ ".properties. Skipping");
}
}
}
/**
* Allows for providing an alternative default struts theme. Will default to
* "ftl" otherwise.
*
* @param defaultTemplateTheme
* the struts default theme
*/
@Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
public void setDefaultTemplateType(String type) {
// Make sure we don't set ourself as default for race condition
if (type != null && !type.equalsIgnoreCase(getSuffix())) {
this.defaultTemplateType = type.toLowerCase();
} else {
LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
+ getSuffix());
}
}
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (WW-3922) Make javatemplates work with other
plugins
Posted by "Greg Huber (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WW-3922?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Greg Huber updated WW-3922:
---------------------------
Description:
Hello,
Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
Here are the changes needed to the JavaTemplateEngine.java to get it to work.
Cheers Greg
{code:java}
package org.apache.struts2.views.java;
import org.apache.struts2.StrutsException;
import org.apache.struts2.components.template.BaseTemplateEngine;
import org.apache.struts2.components.template.Template;
import org.apache.struts2.components.template.TemplateEngine;
import org.apache.struts2.components.template.TemplateEngineManager;
import org.apache.struts2.components.template.TemplateRenderingContext;
import org.apache.struts2.views.java.simple.SimpleTheme;
import java.util.HashMap;
import java.util.StringTokenizer;
import com.opensymphony.xwork2.util.logging.LoggerFactory;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.ClassLoaderUtil;
import com.opensymphony.xwork2.config.ConfigurationException;
import com.opensymphony.xwork2.inject.Inject;
/**
* Template engine that renders tags using java implementations
*/
public class JavaTemplateEngine extends BaseTemplateEngine {
private static final Logger LOG = LoggerFactory
.getLogger(JavaTemplateEngine.class);
// The struts template engine manager
protected TemplateEngineManager templateEngineManager;
// The struts default template type. If struts ever changes this will need
// updating.
private String defaultTemplateType = "ftl";
@Inject
public void setTemplateEngineManager(TemplateEngineManager mgr) {
this.templateEngineManager = mgr;
}
private Themes themes = new Themes() {
{
add(new SimpleTheme());
}
};
@Override
protected String getSuffix() {
return "java";
}
public void renderTemplate(TemplateRenderingContext templateContext)
throws Exception {
Template t = templateContext.getTemplate();
Theme theme = themes.get(t.getTheme());
if (theme == null) {
// Theme not supported, so do what struts would have done if we were
// not here.
if (LOG.isDebugEnabled()) {
LOG.debug("Theme not found " + t.getTheme()
+ "trying default templete engine using template type "
+ defaultTemplateType);
}
final TemplateEngine engine = templateEngineManager
.getTemplateEngine(templateContext.getTemplate(),
defaultTemplateType);
if (engine == null) {
// May be the default template has changed?
throw new ConfigurationException(
"Unable to find a TemplateEngine for template type '"
+ defaultTemplateType
+ "' whilst trying to render template "
+ templateContext.getTemplate());
} else {
try {
// Retry render
engine.renderTemplate(templateContext);
} catch (Exception e) {
// Give up and throw a new StrutsException(e);
throw new StrutsException("Cannot render tag ["
+ t.getName() + "] because theme [" + t.getTheme()
+ "] was not found.");
}
}
} else {
// Render our template
theme.renderTag(t.getName(), templateContext);
}
}
private class Themes {
private HashMap<String, Theme> themes = new HashMap<String, Theme>();
public void add(Theme theme) {
themes.put(theme.getName(), theme);
}
public Theme get(String name) {
return themes.get(name);
}
}
/**
* Allows for providing custom theme classes (implementations of the
* org.apache.struts2.views.java.Theme) interface for custom rendering of
* tags using the javatemplates engine
*
* @param themeClasses
* a comma delimited list of custom theme class names
*/
@Inject(value = "struts.javatemplates.customThemes", required = false)
public void setThemeClasses(String themeClasses) {
StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
while (customThemes.hasMoreTokens()) {
String themeClass = customThemes.nextToken().trim();
try {
if (LOG.isInfoEnabled()) {
LOG.info("Registering custom theme '" + themeClass
+ "' to javatemplates engine");
}
// FIXME: This means Themes must have no-arg constructor -
// should use object factory here
// ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
// getClass()), null);
themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
getClass()).newInstance());
} catch (ClassCastException cce) {
LOG.error("Invalid java them class '"
+ themeClass
+ "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
} catch (ClassNotFoundException cnf) {
LOG.error("Invalid java theme class '" + themeClass
+ "'. Class not found");
} catch (Exception e) {
LOG.error("Could not find messages file " + themeClass
+ ".properties. Skipping");
}
}
}
/**
* Allows for providing an alternative default struts theme. Will default to
* "ftl" otherwise.
*
* @param defaultTemplateTheme
* the struts default theme
*/
@Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
public void setDefaultTemplateType(String type) {
// Make sure we don't set ourself as default for race condition
if (type != null && !type.equalsIgnoreCase(getSuffix())) {
this.defaultTemplateType = type.toLowerCase();
} else {
LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
+ getSuffix());
}
}
}
{code}
was:
Hello,
Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
Here are the changes needed to the JavaTemplateEngine.java get it to work.
Cheers Greg
{code:java}
package org.apache.struts2.views.java;
import org.apache.struts2.StrutsException;
import org.apache.struts2.components.template.BaseTemplateEngine;
import org.apache.struts2.components.template.Template;
import org.apache.struts2.components.template.TemplateEngine;
import org.apache.struts2.components.template.TemplateEngineManager;
import org.apache.struts2.components.template.TemplateRenderingContext;
import org.apache.struts2.views.java.simple.SimpleTheme;
import java.util.HashMap;
import java.util.StringTokenizer;
import com.opensymphony.xwork2.util.logging.LoggerFactory;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.ClassLoaderUtil;
import com.opensymphony.xwork2.config.ConfigurationException;
import com.opensymphony.xwork2.inject.Inject;
/**
* Template engine that renders tags using java implementations
*/
public class JavaTemplateEngine extends BaseTemplateEngine {
private static final Logger LOG = LoggerFactory
.getLogger(JavaTemplateEngine.class);
// The struts template engine manager
protected TemplateEngineManager templateEngineManager;
// The struts default template type. If struts ever changes this will need
// updating.
private String defaultTemplateType = "ftl";
@Inject
public void setTemplateEngineManager(TemplateEngineManager mgr) {
this.templateEngineManager = mgr;
}
private Themes themes = new Themes() {
{
add(new SimpleTheme());
}
};
@Override
protected String getSuffix() {
return "java";
}
public void renderTemplate(TemplateRenderingContext templateContext)
throws Exception {
Template t = templateContext.getTemplate();
Theme theme = themes.get(t.getTheme());
if (theme == null) {
// Theme not supported, so do what struts would have done if we were
// not here.
if (LOG.isDebugEnabled()) {
LOG.debug("Theme not found " + t.getTheme()
+ "trying default templete engine using template type "
+ defaultTemplateType);
}
final TemplateEngine engine = templateEngineManager
.getTemplateEngine(templateContext.getTemplate(),
defaultTemplateType);
if (engine == null) {
// May be the default template has changed?
throw new ConfigurationException(
"Unable to find a TemplateEngine for template type '"
+ defaultTemplateType
+ "' whilst trying to render template "
+ templateContext.getTemplate());
} else {
try {
// Retry render
engine.renderTemplate(templateContext);
} catch (Exception e) {
// Give up and throw a new StrutsException(e);
throw new StrutsException("Cannot render tag ["
+ t.getName() + "] because theme [" + t.getTheme()
+ "] was not found.");
}
}
} else {
// Render our template
theme.renderTag(t.getName(), templateContext);
}
}
private class Themes {
private HashMap<String, Theme> themes = new HashMap<String, Theme>();
public void add(Theme theme) {
themes.put(theme.getName(), theme);
}
public Theme get(String name) {
return themes.get(name);
}
}
/**
* Allows for providing custom theme classes (implementations of the
* org.apache.struts2.views.java.Theme) interface for custom rendering of
* tags using the javatemplates engine
*
* @param themeClasses
* a comma delimited list of custom theme class names
*/
@Inject(value = "struts.javatemplates.customThemes", required = false)
public void setThemeClasses(String themeClasses) {
StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
while (customThemes.hasMoreTokens()) {
String themeClass = customThemes.nextToken().trim();
try {
if (LOG.isInfoEnabled()) {
LOG.info("Registering custom theme '" + themeClass
+ "' to javatemplates engine");
}
// FIXME: This means Themes must have no-arg constructor -
// should use object factory here
// ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
// getClass()), null);
themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
getClass()).newInstance());
} catch (ClassCastException cce) {
LOG.error("Invalid java them class '"
+ themeClass
+ "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
} catch (ClassNotFoundException cnf) {
LOG.error("Invalid java theme class '" + themeClass
+ "'. Class not found");
} catch (Exception e) {
LOG.error("Could not find messages file " + themeClass
+ ".properties. Skipping");
}
}
}
/**
* Allows for providing an alternative default struts theme. Will default to
* "ftl" otherwise.
*
* @param defaultTemplateTheme
* the struts default theme
*/
@Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
public void setDefaultTemplateType(String type) {
// Make sure we don't set ourself as default for race condition
if (type != null && !type.equalsIgnoreCase(getSuffix())) {
this.defaultTemplateType = type.toLowerCase();
} else {
LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
+ getSuffix());
}
}
}
{code}
> Make javatemplates work with other plugins
> ------------------------------------------
>
> Key: WW-3922
> URL: https://issues.apache.org/jira/browse/WW-3922
> Project: Struts 2
> Issue Type: Improvement
> Components: Plugin - Java Templates
> Affects Versions: 2.3.4.1
> Reporter: Greg Huber
>
> Hello,
> Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
> Here are the changes needed to the JavaTemplateEngine.java to get it to work.
> Cheers Greg
> {code:java}
> package org.apache.struts2.views.java;
> import org.apache.struts2.StrutsException;
> import org.apache.struts2.components.template.BaseTemplateEngine;
> import org.apache.struts2.components.template.Template;
> import org.apache.struts2.components.template.TemplateEngine;
> import org.apache.struts2.components.template.TemplateEngineManager;
> import org.apache.struts2.components.template.TemplateRenderingContext;
> import org.apache.struts2.views.java.simple.SimpleTheme;
> import java.util.HashMap;
> import java.util.StringTokenizer;
> import com.opensymphony.xwork2.util.logging.LoggerFactory;
> import com.opensymphony.xwork2.util.logging.Logger;
> import com.opensymphony.xwork2.util.ClassLoaderUtil;
> import com.opensymphony.xwork2.config.ConfigurationException;
> import com.opensymphony.xwork2.inject.Inject;
> /**
> * Template engine that renders tags using java implementations
> */
> public class JavaTemplateEngine extends BaseTemplateEngine {
> private static final Logger LOG = LoggerFactory
> .getLogger(JavaTemplateEngine.class);
> // The struts template engine manager
> protected TemplateEngineManager templateEngineManager;
> // The struts default template type. If struts ever changes this will need
> // updating.
> private String defaultTemplateType = "ftl";
> @Inject
> public void setTemplateEngineManager(TemplateEngineManager mgr) {
> this.templateEngineManager = mgr;
> }
> private Themes themes = new Themes() {
> {
> add(new SimpleTheme());
> }
> };
> @Override
> protected String getSuffix() {
> return "java";
> }
> public void renderTemplate(TemplateRenderingContext templateContext)
> throws Exception {
> Template t = templateContext.getTemplate();
> Theme theme = themes.get(t.getTheme());
> if (theme == null) {
> // Theme not supported, so do what struts would have done if we were
> // not here.
> if (LOG.isDebugEnabled()) {
> LOG.debug("Theme not found " + t.getTheme()
> + "trying default templete engine using template type "
> + defaultTemplateType);
> }
> final TemplateEngine engine = templateEngineManager
> .getTemplateEngine(templateContext.getTemplate(),
> defaultTemplateType);
> if (engine == null) {
> // May be the default template has changed?
> throw new ConfigurationException(
> "Unable to find a TemplateEngine for template type '"
> + defaultTemplateType
> + "' whilst trying to render template "
> + templateContext.getTemplate());
> } else {
> try {
> // Retry render
> engine.renderTemplate(templateContext);
> } catch (Exception e) {
> // Give up and throw a new StrutsException(e);
> throw new StrutsException("Cannot render tag ["
> + t.getName() + "] because theme [" + t.getTheme()
> + "] was not found.");
> }
> }
> } else {
> // Render our template
> theme.renderTag(t.getName(), templateContext);
> }
> }
> private class Themes {
> private HashMap<String, Theme> themes = new HashMap<String, Theme>();
> public void add(Theme theme) {
> themes.put(theme.getName(), theme);
> }
> public Theme get(String name) {
> return themes.get(name);
> }
> }
> /**
> * Allows for providing custom theme classes (implementations of the
> * org.apache.struts2.views.java.Theme) interface for custom rendering of
> * tags using the javatemplates engine
> *
> * @param themeClasses
> * a comma delimited list of custom theme class names
> */
> @Inject(value = "struts.javatemplates.customThemes", required = false)
> public void setThemeClasses(String themeClasses) {
> StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
> while (customThemes.hasMoreTokens()) {
> String themeClass = customThemes.nextToken().trim();
> try {
> if (LOG.isInfoEnabled()) {
> LOG.info("Registering custom theme '" + themeClass
> + "' to javatemplates engine");
> }
> // FIXME: This means Themes must have no-arg constructor -
> // should use object factory here
> // ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
> // getClass()), null);
> themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
> getClass()).newInstance());
> } catch (ClassCastException cce) {
> LOG.error("Invalid java them class '"
> + themeClass
> + "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
> } catch (ClassNotFoundException cnf) {
> LOG.error("Invalid java theme class '" + themeClass
> + "'. Class not found");
> } catch (Exception e) {
> LOG.error("Could not find messages file " + themeClass
> + ".properties. Skipping");
> }
> }
> }
> /**
> * Allows for providing an alternative default struts theme. Will default to
> * "ftl" otherwise.
> *
> * @param defaultTemplateTheme
> * the struts default theme
> */
> @Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
> public void setDefaultTemplateType(String type) {
> // Make sure we don't set ourself as default for race condition
> if (type != null && !type.equalsIgnoreCase(getSuffix())) {
> this.defaultTemplateType = type.toLowerCase();
> } else {
> LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
> + getSuffix());
> }
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Commented] (WW-3922) Make javatemplates work with other
plugins
Posted by "Johannes Geppert (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WW-3922?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13499500#comment-13499500 ]
Johannes Geppert commented on WW-3922:
--------------------------------------
Can you please attach the Changes as an SVN Patch?
> Make javatemplates work with other plugins
> ------------------------------------------
>
> Key: WW-3922
> URL: https://issues.apache.org/jira/browse/WW-3922
> Project: Struts 2
> Issue Type: Improvement
> Components: Plugin - Java Templates
> Affects Versions: 2.3.4.1
> Reporter: Greg Huber
>
> Hello,
> Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
> Here are the changes needed to the JavaTemplateEngine.java to get it to work.
> Cheers Greg
> {code:java}
> package org.apache.struts2.views.java;
> import org.apache.struts2.StrutsException;
> import org.apache.struts2.components.template.BaseTemplateEngine;
> import org.apache.struts2.components.template.Template;
> import org.apache.struts2.components.template.TemplateEngine;
> import org.apache.struts2.components.template.TemplateEngineManager;
> import org.apache.struts2.components.template.TemplateRenderingContext;
> import org.apache.struts2.views.java.simple.SimpleTheme;
> import java.util.HashMap;
> import java.util.StringTokenizer;
> import com.opensymphony.xwork2.util.logging.LoggerFactory;
> import com.opensymphony.xwork2.util.logging.Logger;
> import com.opensymphony.xwork2.util.ClassLoaderUtil;
> import com.opensymphony.xwork2.config.ConfigurationException;
> import com.opensymphony.xwork2.inject.Inject;
> /**
> * Template engine that renders tags using java implementations
> */
> public class JavaTemplateEngine extends BaseTemplateEngine {
> private static final Logger LOG = LoggerFactory
> .getLogger(JavaTemplateEngine.class);
> // The struts template engine manager
> protected TemplateEngineManager templateEngineManager;
> // The struts default template type. If struts ever changes this will need
> // updating.
> private String defaultTemplateType = "ftl";
> @Inject
> public void setTemplateEngineManager(TemplateEngineManager mgr) {
> this.templateEngineManager = mgr;
> }
> private Themes themes = new Themes() {
> {
> add(new SimpleTheme());
> }
> };
> @Override
> protected String getSuffix() {
> return "java";
> }
> public void renderTemplate(TemplateRenderingContext templateContext)
> throws Exception {
> Template t = templateContext.getTemplate();
> Theme theme = themes.get(t.getTheme());
> if (theme == null) {
> // Theme not supported, so do what struts would have done if we were
> // not here.
> if (LOG.isDebugEnabled()) {
> LOG.debug("Theme not found " + t.getTheme()
> + "trying default templete engine using template type "
> + defaultTemplateType);
> }
> final TemplateEngine engine = templateEngineManager
> .getTemplateEngine(templateContext.getTemplate(),
> defaultTemplateType);
> if (engine == null) {
> // May be the default template has changed?
> throw new ConfigurationException(
> "Unable to find a TemplateEngine for template type '"
> + defaultTemplateType
> + "' whilst trying to render template "
> + templateContext.getTemplate());
> } else {
> try {
> // Retry render
> engine.renderTemplate(templateContext);
> } catch (Exception e) {
> // Give up and throw a new StrutsException(e);
> throw new StrutsException("Cannot render tag ["
> + t.getName() + "] because theme [" + t.getTheme()
> + "] was not found.");
> }
> }
> } else {
> // Render our template
> theme.renderTag(t.getName(), templateContext);
> }
> }
> private class Themes {
> private HashMap<String, Theme> themes = new HashMap<String, Theme>();
> public void add(Theme theme) {
> themes.put(theme.getName(), theme);
> }
> public Theme get(String name) {
> return themes.get(name);
> }
> }
> /**
> * Allows for providing custom theme classes (implementations of the
> * org.apache.struts2.views.java.Theme) interface for custom rendering of
> * tags using the javatemplates engine
> *
> * @param themeClasses
> * a comma delimited list of custom theme class names
> */
> @Inject(value = "struts.javatemplates.customThemes", required = false)
> public void setThemeClasses(String themeClasses) {
> StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
> while (customThemes.hasMoreTokens()) {
> String themeClass = customThemes.nextToken().trim();
> try {
> if (LOG.isInfoEnabled()) {
> LOG.info("Registering custom theme '" + themeClass
> + "' to javatemplates engine");
> }
> // FIXME: This means Themes must have no-arg constructor -
> // should use object factory here
> // ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
> // getClass()), null);
> themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
> getClass()).newInstance());
> } catch (ClassCastException cce) {
> LOG.error("Invalid java them class '"
> + themeClass
> + "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
> } catch (ClassNotFoundException cnf) {
> LOG.error("Invalid java theme class '" + themeClass
> + "'. Class not found");
> } catch (Exception e) {
> LOG.error("Could not find messages file " + themeClass
> + ".properties. Skipping");
> }
> }
> }
> /**
> * Allows for providing an alternative default struts theme. Will default to
> * "ftl" otherwise.
> *
> * @param defaultTemplateTheme
> * the struts default theme
> */
> @Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
> public void setDefaultTemplateType(String type) {
> // Make sure we don't set ourself as default for race condition
> if (type != null && !type.equalsIgnoreCase(getSuffix())) {
> this.defaultTemplateType = type.toLowerCase();
> } else {
> LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
> + getSuffix());
> }
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (WW-3922) Make javatemplates work with other
plugins
Posted by "Greg Huber (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WW-3922?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Greg Huber updated WW-3922:
---------------------------
Attachment: patch.txt
Make javatemplates work with other plugins
> Make javatemplates work with other plugins
> ------------------------------------------
>
> Key: WW-3922
> URL: https://issues.apache.org/jira/browse/WW-3922
> Project: Struts 2
> Issue Type: Improvement
> Components: Plugin - Java Templates
> Affects Versions: 2.3.4.1
> Reporter: Greg Huber
> Attachments: patch.txt
>
>
> Hello,
> Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
> Here are the changes needed to the JavaTemplateEngine.java to get it to work.
> Cheers Greg
> {code:java}
> package org.apache.struts2.views.java;
> import org.apache.struts2.StrutsException;
> import org.apache.struts2.components.template.BaseTemplateEngine;
> import org.apache.struts2.components.template.Template;
> import org.apache.struts2.components.template.TemplateEngine;
> import org.apache.struts2.components.template.TemplateEngineManager;
> import org.apache.struts2.components.template.TemplateRenderingContext;
> import org.apache.struts2.views.java.simple.SimpleTheme;
> import java.util.HashMap;
> import java.util.StringTokenizer;
> import com.opensymphony.xwork2.util.logging.LoggerFactory;
> import com.opensymphony.xwork2.util.logging.Logger;
> import com.opensymphony.xwork2.util.ClassLoaderUtil;
> import com.opensymphony.xwork2.config.ConfigurationException;
> import com.opensymphony.xwork2.inject.Inject;
> /**
> * Template engine that renders tags using java implementations
> */
> public class JavaTemplateEngine extends BaseTemplateEngine {
> private static final Logger LOG = LoggerFactory
> .getLogger(JavaTemplateEngine.class);
> // The struts template engine manager
> protected TemplateEngineManager templateEngineManager;
> // The struts default template type. If struts ever changes this will need
> // updating.
> private String defaultTemplateType = "ftl";
> @Inject
> public void setTemplateEngineManager(TemplateEngineManager mgr) {
> this.templateEngineManager = mgr;
> }
> private Themes themes = new Themes() {
> {
> add(new SimpleTheme());
> }
> };
> @Override
> protected String getSuffix() {
> return "java";
> }
> public void renderTemplate(TemplateRenderingContext templateContext)
> throws Exception {
> Template t = templateContext.getTemplate();
> Theme theme = themes.get(t.getTheme());
> if (theme == null) {
> // Theme not supported, so do what struts would have done if we were
> // not here.
> if (LOG.isDebugEnabled()) {
> LOG.debug("Theme not found " + t.getTheme()
> + "trying default templete engine using template type "
> + defaultTemplateType);
> }
> final TemplateEngine engine = templateEngineManager
> .getTemplateEngine(templateContext.getTemplate(),
> defaultTemplateType);
> if (engine == null) {
> // May be the default template has changed?
> throw new ConfigurationException(
> "Unable to find a TemplateEngine for template type '"
> + defaultTemplateType
> + "' whilst trying to render template "
> + templateContext.getTemplate());
> } else {
> try {
> // Retry render
> engine.renderTemplate(templateContext);
> } catch (Exception e) {
> // Give up and throw a new StrutsException(e);
> throw new StrutsException("Cannot render tag ["
> + t.getName() + "] because theme [" + t.getTheme()
> + "] was not found.");
> }
> }
> } else {
> // Render our template
> theme.renderTag(t.getName(), templateContext);
> }
> }
> private class Themes {
> private HashMap<String, Theme> themes = new HashMap<String, Theme>();
> public void add(Theme theme) {
> themes.put(theme.getName(), theme);
> }
> public Theme get(String name) {
> return themes.get(name);
> }
> }
> /**
> * Allows for providing custom theme classes (implementations of the
> * org.apache.struts2.views.java.Theme) interface for custom rendering of
> * tags using the javatemplates engine
> *
> * @param themeClasses
> * a comma delimited list of custom theme class names
> */
> @Inject(value = "struts.javatemplates.customThemes", required = false)
> public void setThemeClasses(String themeClasses) {
> StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
> while (customThemes.hasMoreTokens()) {
> String themeClass = customThemes.nextToken().trim();
> try {
> if (LOG.isInfoEnabled()) {
> LOG.info("Registering custom theme '" + themeClass
> + "' to javatemplates engine");
> }
> // FIXME: This means Themes must have no-arg constructor -
> // should use object factory here
> // ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
> // getClass()), null);
> themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
> getClass()).newInstance());
> } catch (ClassCastException cce) {
> LOG.error("Invalid java them class '"
> + themeClass
> + "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
> } catch (ClassNotFoundException cnf) {
> LOG.error("Invalid java theme class '" + themeClass
> + "'. Class not found");
> } catch (Exception e) {
> LOG.error("Could not find messages file " + themeClass
> + ".properties. Skipping");
> }
> }
> }
> /**
> * Allows for providing an alternative default struts theme. Will default to
> * "ftl" otherwise.
> *
> * @param defaultTemplateTheme
> * the struts default theme
> */
> @Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
> public void setDefaultTemplateType(String type) {
> // Make sure we don't set ourself as default for race condition
> if (type != null && !type.equalsIgnoreCase(getSuffix())) {
> this.defaultTemplateType = type.toLowerCase();
> } else {
> LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
> + getSuffix());
> }
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (WW-3922) Make javatemplates work with other
plugins
Posted by "Lukasz Lenart (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WW-3922?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Lukasz Lenart updated WW-3922:
------------------------------
Fix Version/s: 2.3.8
> Make javatemplates work with other plugins
> ------------------------------------------
>
> Key: WW-3922
> URL: https://issues.apache.org/jira/browse/WW-3922
> Project: Struts 2
> Issue Type: Improvement
> Components: Plugin - Java Templates
> Affects Versions: 2.3.4.1
> Reporter: Greg Huber
> Fix For: 2.3.8
>
> Attachments: patch.txt, patch.txt
>
>
> Hello,
> Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
> Here are the changes needed to the JavaTemplateEngine.java to get it to work.
> Cheers Greg
> {code:java}
> package org.apache.struts2.views.java;
> import org.apache.struts2.StrutsException;
> import org.apache.struts2.components.template.BaseTemplateEngine;
> import org.apache.struts2.components.template.Template;
> import org.apache.struts2.components.template.TemplateEngine;
> import org.apache.struts2.components.template.TemplateEngineManager;
> import org.apache.struts2.components.template.TemplateRenderingContext;
> import org.apache.struts2.views.java.simple.SimpleTheme;
> import java.util.HashMap;
> import java.util.StringTokenizer;
> import com.opensymphony.xwork2.util.logging.LoggerFactory;
> import com.opensymphony.xwork2.util.logging.Logger;
> import com.opensymphony.xwork2.util.ClassLoaderUtil;
> import com.opensymphony.xwork2.config.ConfigurationException;
> import com.opensymphony.xwork2.inject.Inject;
> /**
> * Template engine that renders tags using java implementations
> */
> public class JavaTemplateEngine extends BaseTemplateEngine {
> private static final Logger LOG = LoggerFactory
> .getLogger(JavaTemplateEngine.class);
> // The struts template engine manager
> protected TemplateEngineManager templateEngineManager;
> // The struts default template type. If struts ever changes this will need
> // updating.
> private String defaultTemplateType = "ftl";
> @Inject
> public void setTemplateEngineManager(TemplateEngineManager mgr) {
> this.templateEngineManager = mgr;
> }
> private Themes themes = new Themes() {
> {
> add(new SimpleTheme());
> }
> };
> @Override
> protected String getSuffix() {
> return "java";
> }
> public void renderTemplate(TemplateRenderingContext templateContext)
> throws Exception {
> Template t = templateContext.getTemplate();
> Theme theme = themes.get(t.getTheme());
> if (theme == null) {
> // Theme not supported, so do what struts would have done if we were
> // not here.
> if (LOG.isDebugEnabled()) {
> LOG.debug("Theme not found " + t.getTheme()
> + "trying default templete engine using template type "
> + defaultTemplateType);
> }
> final TemplateEngine engine = templateEngineManager
> .getTemplateEngine(templateContext.getTemplate(),
> defaultTemplateType);
> if (engine == null) {
> // May be the default template has changed?
> throw new ConfigurationException(
> "Unable to find a TemplateEngine for template type '"
> + defaultTemplateType
> + "' whilst trying to render template "
> + templateContext.getTemplate());
> } else {
> try {
> // Retry render
> engine.renderTemplate(templateContext);
> } catch (Exception e) {
> // Give up and throw a new StrutsException(e);
> throw new StrutsException("Cannot render tag ["
> + t.getName() + "] because theme [" + t.getTheme()
> + "] was not found.");
> }
> }
> } else {
> // Render our template
> theme.renderTag(t.getName(), templateContext);
> }
> }
> private class Themes {
> private HashMap<String, Theme> themes = new HashMap<String, Theme>();
> public void add(Theme theme) {
> themes.put(theme.getName(), theme);
> }
> public Theme get(String name) {
> return themes.get(name);
> }
> }
> /**
> * Allows for providing custom theme classes (implementations of the
> * org.apache.struts2.views.java.Theme) interface for custom rendering of
> * tags using the javatemplates engine
> *
> * @param themeClasses
> * a comma delimited list of custom theme class names
> */
> @Inject(value = "struts.javatemplates.customThemes", required = false)
> public void setThemeClasses(String themeClasses) {
> StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
> while (customThemes.hasMoreTokens()) {
> String themeClass = customThemes.nextToken().trim();
> try {
> if (LOG.isInfoEnabled()) {
> LOG.info("Registering custom theme '" + themeClass
> + "' to javatemplates engine");
> }
> // FIXME: This means Themes must have no-arg constructor -
> // should use object factory here
> // ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
> // getClass()), null);
> themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
> getClass()).newInstance());
> } catch (ClassCastException cce) {
> LOG.error("Invalid java them class '"
> + themeClass
> + "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
> } catch (ClassNotFoundException cnf) {
> LOG.error("Invalid java theme class '" + themeClass
> + "'. Class not found");
> } catch (Exception e) {
> LOG.error("Could not find messages file " + themeClass
> + ".properties. Skipping");
> }
> }
> }
> /**
> * Allows for providing an alternative default struts theme. Will default to
> * "ftl" otherwise.
> *
> * @param defaultTemplateTheme
> * the struts default theme
> */
> @Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
> public void setDefaultTemplateType(String type) {
> // Make sure we don't set ourself as default for race condition
> if (type != null && !type.equalsIgnoreCase(getSuffix())) {
> this.defaultTemplateType = type.toLowerCase();
> } else {
> LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
> + getSuffix());
> }
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Commented] (WW-3922) Make javatemplates work with other
plugins
Posted by "Greg Huber (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WW-3922?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13499928#comment-13499928 ]
Greg Huber commented on WW-3922:
--------------------------------
The second one. Null pointer check.
> Make javatemplates work with other plugins
> ------------------------------------------
>
> Key: WW-3922
> URL: https://issues.apache.org/jira/browse/WW-3922
> Project: Struts 2
> Issue Type: Improvement
> Components: Plugin - Java Templates
> Affects Versions: 2.3.4.1
> Reporter: Greg Huber
> Fix For: 2.3.8
>
> Attachments: patch.txt, patch.txt
>
>
> Hello,
> Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
> Here are the changes needed to the JavaTemplateEngine.java to get it to work.
> Cheers Greg
> {code:java}
> package org.apache.struts2.views.java;
> import org.apache.struts2.StrutsException;
> import org.apache.struts2.components.template.BaseTemplateEngine;
> import org.apache.struts2.components.template.Template;
> import org.apache.struts2.components.template.TemplateEngine;
> import org.apache.struts2.components.template.TemplateEngineManager;
> import org.apache.struts2.components.template.TemplateRenderingContext;
> import org.apache.struts2.views.java.simple.SimpleTheme;
> import java.util.HashMap;
> import java.util.StringTokenizer;
> import com.opensymphony.xwork2.util.logging.LoggerFactory;
> import com.opensymphony.xwork2.util.logging.Logger;
> import com.opensymphony.xwork2.util.ClassLoaderUtil;
> import com.opensymphony.xwork2.config.ConfigurationException;
> import com.opensymphony.xwork2.inject.Inject;
> /**
> * Template engine that renders tags using java implementations
> */
> public class JavaTemplateEngine extends BaseTemplateEngine {
> private static final Logger LOG = LoggerFactory
> .getLogger(JavaTemplateEngine.class);
> // The struts template engine manager
> protected TemplateEngineManager templateEngineManager;
> // The struts default template type. If struts ever changes this will need
> // updating.
> private String defaultTemplateType = "ftl";
> @Inject
> public void setTemplateEngineManager(TemplateEngineManager mgr) {
> this.templateEngineManager = mgr;
> }
> private Themes themes = new Themes() {
> {
> add(new SimpleTheme());
> }
> };
> @Override
> protected String getSuffix() {
> return "java";
> }
> public void renderTemplate(TemplateRenderingContext templateContext)
> throws Exception {
> Template t = templateContext.getTemplate();
> Theme theme = themes.get(t.getTheme());
> if (theme == null) {
> // Theme not supported, so do what struts would have done if we were
> // not here.
> if (LOG.isDebugEnabled()) {
> LOG.debug("Theme not found " + t.getTheme()
> + "trying default templete engine using template type "
> + defaultTemplateType);
> }
> final TemplateEngine engine = templateEngineManager
> .getTemplateEngine(templateContext.getTemplate(),
> defaultTemplateType);
> if (engine == null) {
> // May be the default template has changed?
> throw new ConfigurationException(
> "Unable to find a TemplateEngine for template type '"
> + defaultTemplateType
> + "' whilst trying to render template "
> + templateContext.getTemplate());
> } else {
> try {
> // Retry render
> engine.renderTemplate(templateContext);
> } catch (Exception e) {
> // Give up and throw a new StrutsException(e);
> throw new StrutsException("Cannot render tag ["
> + t.getName() + "] because theme [" + t.getTheme()
> + "] was not found.");
> }
> }
> } else {
> // Render our template
> theme.renderTag(t.getName(), templateContext);
> }
> }
> private class Themes {
> private HashMap<String, Theme> themes = new HashMap<String, Theme>();
> public void add(Theme theme) {
> themes.put(theme.getName(), theme);
> }
> public Theme get(String name) {
> return themes.get(name);
> }
> }
> /**
> * Allows for providing custom theme classes (implementations of the
> * org.apache.struts2.views.java.Theme) interface for custom rendering of
> * tags using the javatemplates engine
> *
> * @param themeClasses
> * a comma delimited list of custom theme class names
> */
> @Inject(value = "struts.javatemplates.customThemes", required = false)
> public void setThemeClasses(String themeClasses) {
> StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
> while (customThemes.hasMoreTokens()) {
> String themeClass = customThemes.nextToken().trim();
> try {
> if (LOG.isInfoEnabled()) {
> LOG.info("Registering custom theme '" + themeClass
> + "' to javatemplates engine");
> }
> // FIXME: This means Themes must have no-arg constructor -
> // should use object factory here
> // ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
> // getClass()), null);
> themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
> getClass()).newInstance());
> } catch (ClassCastException cce) {
> LOG.error("Invalid java them class '"
> + themeClass
> + "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
> } catch (ClassNotFoundException cnf) {
> LOG.error("Invalid java theme class '" + themeClass
> + "'. Class not found");
> } catch (Exception e) {
> LOG.error("Could not find messages file " + themeClass
> + ".properties. Skipping");
> }
> }
> }
> /**
> * Allows for providing an alternative default struts theme. Will default to
> * "ftl" otherwise.
> *
> * @param defaultTemplateTheme
> * the struts default theme
> */
> @Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
> public void setDefaultTemplateType(String type) {
> // Make sure we don't set ourself as default for race condition
> if (type != null && !type.equalsIgnoreCase(getSuffix())) {
> this.defaultTemplateType = type.toLowerCase();
> } else {
> LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
> + getSuffix());
> }
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (WW-3922) Make javatemplates work with other
plugins
Posted by "Greg Huber (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WW-3922?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Greg Huber updated WW-3922:
---------------------------
Comment: was deleted
(was: Make javatemplates work with other plugins)
> Make javatemplates work with other plugins
> ------------------------------------------
>
> Key: WW-3922
> URL: https://issues.apache.org/jira/browse/WW-3922
> Project: Struts 2
> Issue Type: Improvement
> Components: Plugin - Java Templates
> Affects Versions: 2.3.4.1
> Reporter: Greg Huber
> Attachments: patch.txt, patch.txt
>
>
> Hello,
> Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
> Here are the changes needed to the JavaTemplateEngine.java to get it to work.
> Cheers Greg
> {code:java}
> package org.apache.struts2.views.java;
> import org.apache.struts2.StrutsException;
> import org.apache.struts2.components.template.BaseTemplateEngine;
> import org.apache.struts2.components.template.Template;
> import org.apache.struts2.components.template.TemplateEngine;
> import org.apache.struts2.components.template.TemplateEngineManager;
> import org.apache.struts2.components.template.TemplateRenderingContext;
> import org.apache.struts2.views.java.simple.SimpleTheme;
> import java.util.HashMap;
> import java.util.StringTokenizer;
> import com.opensymphony.xwork2.util.logging.LoggerFactory;
> import com.opensymphony.xwork2.util.logging.Logger;
> import com.opensymphony.xwork2.util.ClassLoaderUtil;
> import com.opensymphony.xwork2.config.ConfigurationException;
> import com.opensymphony.xwork2.inject.Inject;
> /**
> * Template engine that renders tags using java implementations
> */
> public class JavaTemplateEngine extends BaseTemplateEngine {
> private static final Logger LOG = LoggerFactory
> .getLogger(JavaTemplateEngine.class);
> // The struts template engine manager
> protected TemplateEngineManager templateEngineManager;
> // The struts default template type. If struts ever changes this will need
> // updating.
> private String defaultTemplateType = "ftl";
> @Inject
> public void setTemplateEngineManager(TemplateEngineManager mgr) {
> this.templateEngineManager = mgr;
> }
> private Themes themes = new Themes() {
> {
> add(new SimpleTheme());
> }
> };
> @Override
> protected String getSuffix() {
> return "java";
> }
> public void renderTemplate(TemplateRenderingContext templateContext)
> throws Exception {
> Template t = templateContext.getTemplate();
> Theme theme = themes.get(t.getTheme());
> if (theme == null) {
> // Theme not supported, so do what struts would have done if we were
> // not here.
> if (LOG.isDebugEnabled()) {
> LOG.debug("Theme not found " + t.getTheme()
> + "trying default templete engine using template type "
> + defaultTemplateType);
> }
> final TemplateEngine engine = templateEngineManager
> .getTemplateEngine(templateContext.getTemplate(),
> defaultTemplateType);
> if (engine == null) {
> // May be the default template has changed?
> throw new ConfigurationException(
> "Unable to find a TemplateEngine for template type '"
> + defaultTemplateType
> + "' whilst trying to render template "
> + templateContext.getTemplate());
> } else {
> try {
> // Retry render
> engine.renderTemplate(templateContext);
> } catch (Exception e) {
> // Give up and throw a new StrutsException(e);
> throw new StrutsException("Cannot render tag ["
> + t.getName() + "] because theme [" + t.getTheme()
> + "] was not found.");
> }
> }
> } else {
> // Render our template
> theme.renderTag(t.getName(), templateContext);
> }
> }
> private class Themes {
> private HashMap<String, Theme> themes = new HashMap<String, Theme>();
> public void add(Theme theme) {
> themes.put(theme.getName(), theme);
> }
> public Theme get(String name) {
> return themes.get(name);
> }
> }
> /**
> * Allows for providing custom theme classes (implementations of the
> * org.apache.struts2.views.java.Theme) interface for custom rendering of
> * tags using the javatemplates engine
> *
> * @param themeClasses
> * a comma delimited list of custom theme class names
> */
> @Inject(value = "struts.javatemplates.customThemes", required = false)
> public void setThemeClasses(String themeClasses) {
> StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
> while (customThemes.hasMoreTokens()) {
> String themeClass = customThemes.nextToken().trim();
> try {
> if (LOG.isInfoEnabled()) {
> LOG.info("Registering custom theme '" + themeClass
> + "' to javatemplates engine");
> }
> // FIXME: This means Themes must have no-arg constructor -
> // should use object factory here
> // ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
> // getClass()), null);
> themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
> getClass()).newInstance());
> } catch (ClassCastException cce) {
> LOG.error("Invalid java them class '"
> + themeClass
> + "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
> } catch (ClassNotFoundException cnf) {
> LOG.error("Invalid java theme class '" + themeClass
> + "'. Class not found");
> } catch (Exception e) {
> LOG.error("Could not find messages file " + themeClass
> + ".properties. Skipping");
> }
> }
> }
> /**
> * Allows for providing an alternative default struts theme. Will default to
> * "ftl" otherwise.
> *
> * @param defaultTemplateTheme
> * the struts default theme
> */
> @Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
> public void setDefaultTemplateType(String type) {
> // Make sure we don't set ourself as default for race condition
> if (type != null && !type.equalsIgnoreCase(getSuffix())) {
> this.defaultTemplateType = type.toLowerCase();
> } else {
> LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
> + getSuffix());
> }
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (WW-3922) Make javatemplates work with other
plugins
Posted by "Greg Huber (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WW-3922?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Greg Huber updated WW-3922:
---------------------------
Attachment: patch.txt
Updated, checks for null templateEngineManager for plugin testing.
> Make javatemplates work with other plugins
> ------------------------------------------
>
> Key: WW-3922
> URL: https://issues.apache.org/jira/browse/WW-3922
> Project: Struts 2
> Issue Type: Improvement
> Components: Plugin - Java Templates
> Affects Versions: 2.3.4.1
> Reporter: Greg Huber
> Attachments: patch.txt, patch.txt
>
>
> Hello,
> Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
> Here are the changes needed to the JavaTemplateEngine.java to get it to work.
> Cheers Greg
> {code:java}
> package org.apache.struts2.views.java;
> import org.apache.struts2.StrutsException;
> import org.apache.struts2.components.template.BaseTemplateEngine;
> import org.apache.struts2.components.template.Template;
> import org.apache.struts2.components.template.TemplateEngine;
> import org.apache.struts2.components.template.TemplateEngineManager;
> import org.apache.struts2.components.template.TemplateRenderingContext;
> import org.apache.struts2.views.java.simple.SimpleTheme;
> import java.util.HashMap;
> import java.util.StringTokenizer;
> import com.opensymphony.xwork2.util.logging.LoggerFactory;
> import com.opensymphony.xwork2.util.logging.Logger;
> import com.opensymphony.xwork2.util.ClassLoaderUtil;
> import com.opensymphony.xwork2.config.ConfigurationException;
> import com.opensymphony.xwork2.inject.Inject;
> /**
> * Template engine that renders tags using java implementations
> */
> public class JavaTemplateEngine extends BaseTemplateEngine {
> private static final Logger LOG = LoggerFactory
> .getLogger(JavaTemplateEngine.class);
> // The struts template engine manager
> protected TemplateEngineManager templateEngineManager;
> // The struts default template type. If struts ever changes this will need
> // updating.
> private String defaultTemplateType = "ftl";
> @Inject
> public void setTemplateEngineManager(TemplateEngineManager mgr) {
> this.templateEngineManager = mgr;
> }
> private Themes themes = new Themes() {
> {
> add(new SimpleTheme());
> }
> };
> @Override
> protected String getSuffix() {
> return "java";
> }
> public void renderTemplate(TemplateRenderingContext templateContext)
> throws Exception {
> Template t = templateContext.getTemplate();
> Theme theme = themes.get(t.getTheme());
> if (theme == null) {
> // Theme not supported, so do what struts would have done if we were
> // not here.
> if (LOG.isDebugEnabled()) {
> LOG.debug("Theme not found " + t.getTheme()
> + "trying default templete engine using template type "
> + defaultTemplateType);
> }
> final TemplateEngine engine = templateEngineManager
> .getTemplateEngine(templateContext.getTemplate(),
> defaultTemplateType);
> if (engine == null) {
> // May be the default template has changed?
> throw new ConfigurationException(
> "Unable to find a TemplateEngine for template type '"
> + defaultTemplateType
> + "' whilst trying to render template "
> + templateContext.getTemplate());
> } else {
> try {
> // Retry render
> engine.renderTemplate(templateContext);
> } catch (Exception e) {
> // Give up and throw a new StrutsException(e);
> throw new StrutsException("Cannot render tag ["
> + t.getName() + "] because theme [" + t.getTheme()
> + "] was not found.");
> }
> }
> } else {
> // Render our template
> theme.renderTag(t.getName(), templateContext);
> }
> }
> private class Themes {
> private HashMap<String, Theme> themes = new HashMap<String, Theme>();
> public void add(Theme theme) {
> themes.put(theme.getName(), theme);
> }
> public Theme get(String name) {
> return themes.get(name);
> }
> }
> /**
> * Allows for providing custom theme classes (implementations of the
> * org.apache.struts2.views.java.Theme) interface for custom rendering of
> * tags using the javatemplates engine
> *
> * @param themeClasses
> * a comma delimited list of custom theme class names
> */
> @Inject(value = "struts.javatemplates.customThemes", required = false)
> public void setThemeClasses(String themeClasses) {
> StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
> while (customThemes.hasMoreTokens()) {
> String themeClass = customThemes.nextToken().trim();
> try {
> if (LOG.isInfoEnabled()) {
> LOG.info("Registering custom theme '" + themeClass
> + "' to javatemplates engine");
> }
> // FIXME: This means Themes must have no-arg constructor -
> // should use object factory here
> // ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
> // getClass()), null);
> themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
> getClass()).newInstance());
> } catch (ClassCastException cce) {
> LOG.error("Invalid java them class '"
> + themeClass
> + "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
> } catch (ClassNotFoundException cnf) {
> LOG.error("Invalid java theme class '" + themeClass
> + "'. Class not found");
> } catch (Exception e) {
> LOG.error("Could not find messages file " + themeClass
> + ".properties. Skipping");
> }
> }
> }
> /**
> * Allows for providing an alternative default struts theme. Will default to
> * "ftl" otherwise.
> *
> * @param defaultTemplateTheme
> * the struts default theme
> */
> @Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
> public void setDefaultTemplateType(String type) {
> // Make sure we don't set ourself as default for race condition
> if (type != null && !type.equalsIgnoreCase(getSuffix())) {
> this.defaultTemplateType = type.toLowerCase();
> } else {
> LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
> + getSuffix());
> }
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Commented] (WW-3922) Make javatemplates work with other
plugins
Posted by "Lukasz Lenart (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/WW-3922?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13499892#comment-13499892 ]
Lukasz Lenart commented on WW-3922:
-----------------------------------
Which patch is the correct one?
> Make javatemplates work with other plugins
> ------------------------------------------
>
> Key: WW-3922
> URL: https://issues.apache.org/jira/browse/WW-3922
> Project: Struts 2
> Issue Type: Improvement
> Components: Plugin - Java Templates
> Affects Versions: 2.3.4.1
> Reporter: Greg Huber
> Fix For: 2.3.8
>
> Attachments: patch.txt, patch.txt
>
>
> Hello,
> Using the plugin stops the struts2-jquery plugin working. Can the JavaTemplateEngine be modified to call the default template engine (ftl) if it cannot find a plugin java template.
> Here are the changes needed to the JavaTemplateEngine.java to get it to work.
> Cheers Greg
> {code:java}
> package org.apache.struts2.views.java;
> import org.apache.struts2.StrutsException;
> import org.apache.struts2.components.template.BaseTemplateEngine;
> import org.apache.struts2.components.template.Template;
> import org.apache.struts2.components.template.TemplateEngine;
> import org.apache.struts2.components.template.TemplateEngineManager;
> import org.apache.struts2.components.template.TemplateRenderingContext;
> import org.apache.struts2.views.java.simple.SimpleTheme;
> import java.util.HashMap;
> import java.util.StringTokenizer;
> import com.opensymphony.xwork2.util.logging.LoggerFactory;
> import com.opensymphony.xwork2.util.logging.Logger;
> import com.opensymphony.xwork2.util.ClassLoaderUtil;
> import com.opensymphony.xwork2.config.ConfigurationException;
> import com.opensymphony.xwork2.inject.Inject;
> /**
> * Template engine that renders tags using java implementations
> */
> public class JavaTemplateEngine extends BaseTemplateEngine {
> private static final Logger LOG = LoggerFactory
> .getLogger(JavaTemplateEngine.class);
> // The struts template engine manager
> protected TemplateEngineManager templateEngineManager;
> // The struts default template type. If struts ever changes this will need
> // updating.
> private String defaultTemplateType = "ftl";
> @Inject
> public void setTemplateEngineManager(TemplateEngineManager mgr) {
> this.templateEngineManager = mgr;
> }
> private Themes themes = new Themes() {
> {
> add(new SimpleTheme());
> }
> };
> @Override
> protected String getSuffix() {
> return "java";
> }
> public void renderTemplate(TemplateRenderingContext templateContext)
> throws Exception {
> Template t = templateContext.getTemplate();
> Theme theme = themes.get(t.getTheme());
> if (theme == null) {
> // Theme not supported, so do what struts would have done if we were
> // not here.
> if (LOG.isDebugEnabled()) {
> LOG.debug("Theme not found " + t.getTheme()
> + "trying default templete engine using template type "
> + defaultTemplateType);
> }
> final TemplateEngine engine = templateEngineManager
> .getTemplateEngine(templateContext.getTemplate(),
> defaultTemplateType);
> if (engine == null) {
> // May be the default template has changed?
> throw new ConfigurationException(
> "Unable to find a TemplateEngine for template type '"
> + defaultTemplateType
> + "' whilst trying to render template "
> + templateContext.getTemplate());
> } else {
> try {
> // Retry render
> engine.renderTemplate(templateContext);
> } catch (Exception e) {
> // Give up and throw a new StrutsException(e);
> throw new StrutsException("Cannot render tag ["
> + t.getName() + "] because theme [" + t.getTheme()
> + "] was not found.");
> }
> }
> } else {
> // Render our template
> theme.renderTag(t.getName(), templateContext);
> }
> }
> private class Themes {
> private HashMap<String, Theme> themes = new HashMap<String, Theme>();
> public void add(Theme theme) {
> themes.put(theme.getName(), theme);
> }
> public Theme get(String name) {
> return themes.get(name);
> }
> }
> /**
> * Allows for providing custom theme classes (implementations of the
> * org.apache.struts2.views.java.Theme) interface for custom rendering of
> * tags using the javatemplates engine
> *
> * @param themeClasses
> * a comma delimited list of custom theme class names
> */
> @Inject(value = "struts.javatemplates.customThemes", required = false)
> public void setThemeClasses(String themeClasses) {
> StringTokenizer customThemes = new StringTokenizer(themeClasses, ",");
> while (customThemes.hasMoreTokens()) {
> String themeClass = customThemes.nextToken().trim();
> try {
> if (LOG.isInfoEnabled()) {
> LOG.info("Registering custom theme '" + themeClass
> + "' to javatemplates engine");
> }
> // FIXME: This means Themes must have no-arg constructor -
> // should use object factory here
> // ObjectFactory.getObjectFactory().buildBean(ClassLoaderUtil.loadClass(themeClass,
> // getClass()), null);
> themes.add((Theme) ClassLoaderUtil.loadClass(themeClass,
> getClass()).newInstance());
> } catch (ClassCastException cce) {
> LOG.error("Invalid java them class '"
> + themeClass
> + "'. Class does not implement 'org.apache.struts2.views.java.Theme' interface");
> } catch (ClassNotFoundException cnf) {
> LOG.error("Invalid java theme class '" + themeClass
> + "'. Class not found");
> } catch (Exception e) {
> LOG.error("Could not find messages file " + themeClass
> + ".properties. Skipping");
> }
> }
> }
> /**
> * Allows for providing an alternative default struts theme. Will default to
> * "ftl" otherwise.
> *
> * @param defaultTemplateTheme
> * the struts default theme
> */
> @Inject(value = "struts.javatemplates.defaultTemplateType", required = false)
> public void setDefaultTemplateType(String type) {
> // Make sure we don't set ourself as default for race condition
> if (type != null && !type.equalsIgnoreCase(getSuffix())) {
> this.defaultTemplateType = type.toLowerCase();
> } else {
> LOG.error("Invalid struts.javatemplates.defaultTemplateType value. Cannot be "
> + getSuffix());
> }
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira