litvinovg/vitro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

NIHVIVO-1394 As a necessary first step to calling a template from a controller which will add to the data model used by page and body templates, provide BaseTemplateModelDirective with its own template processing methods, to separate from TemplateProcessingHelper, which will only be available to FreemarkerHttpServlet.

Browse source
This commit is contained in:
rjy7 2010-11-23 16:10:05 +00:00
parent a0225f1cc9
commit 70fe857329
6 changed files with 66 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

18
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/FreemarkerHttpServlet.java
View file

@ -57,7 +57,8 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
TITLED_ERROR_MESSAGE("error-titled.ftl"),
MESSAGE("message.ftl"),
TITLED_MESSAGE("message-titled.ftl"),
PAGE_DEFAULT("page.ftl");
PAGE_DEFAULT("page.ftl"),
SETUP("setup.ftl");
private final String filename;
@ -162,19 +163,21 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
Configuration config = getConfig(vreq);
Map<String, Object> bodyMap = values.getMap();
TemplateProcessingHelper helper = new TemplateProcessingHelper(config, vreq, getServletContext());
// We can't use shared variables in the Freemarker configuration to store anything
// except theme-specific data, because multiple portals or apps might share the same theme. So instead
// just put the shared variables in both root and body.
Map<String, Object> sharedVariables = getSharedVariables(vreq, bodyMap);
//helper.processSetupTemplate(config, vreq, sharedVariables);
// root is the map used to create the page shell - header, footer, menus, etc.
Map<String, Object> root = new HashMap<String, Object>(sharedVariables);
Map<String, Object> root = new HashMap<String, Object>(sharedVariables);
root.putAll(getPageTemplateValues(vreq));
// Tell the template and any directives it uses that we're processing a page template.
root.put("templateType", PAGE_TEMPLATE_TYPE);
// Add the values that we got, and merge to the template.
String bodyTemplate = values.getTemplateName();
String bodyString;
@ -198,6 +201,11 @@ public class FreemarkerHttpServlet extends VitroHttpServlet {
writePage(root, config, vreq, response);
}
private void processSetupTemplate(Configuration config, HttpServletRequest request, Map<String, Object> map) {
TemplateProcessingHelper helper = new TemplateProcessingHelper(config, request, getServletContext());
helper.processTemplate(Template.SETUP.toString(), map);
}
protected void doRedirect(HttpServletRequest request, HttpServletResponse response, ResponseValues values)
throws ServletException, IOException {
String redirectUrl = values.getRedirectUrl();

18
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/freemarker/TemplateProcessingHelper.java
View file

@ -26,28 +26,30 @@ public class TemplateProcessingHelper {
private Configuration config = null;
private HttpServletRequest request = null;
private ServletContext context = null;
//private Map<String, Object> templateDataModel = null;
public TemplateProcessingHelper(Configuration config, HttpServletRequest request, ServletContext context) {
TemplateProcessingHelper(Configuration config, HttpServletRequest request, ServletContext context) {
this.config = config;
this.request = request;
this.context = context;
//this.templateDataModel = new HashMap<String, Object>();
}
public StringWriter processTemplate(String templateName, Map<String, Object> map) {
protected StringWriter processTemplate(String templateName, Map<String, Object> map) {
Template template = getTemplate(templateName);
StringWriter sw = new StringWriter();
processTemplate(template, map, sw);
return sw;
}
public StringWriter processTemplate(ResponseValues values) {
protected StringWriter processTemplate(ResponseValues values) {
if (values == null) {
return null;
}
return processTemplate(values.getTemplateName(), values.getMap());
}
public void processTemplate(Template template, Map<String, Object> map, Writer writer) {
private void processTemplate(Template template, Map<String, Object> map, Writer writer) {
try {
Environment env = template.createProcessingEnvironment(map, writer);
@ -64,15 +66,15 @@ public class TemplateProcessingHelper {
}
// In fact, we can put StringWriter objects directly into the data model, so perhaps we should eliminate the processTemplateToString() methods.
public String processTemplateToString(String templateName, Map<String, Object> map) {
protected String processTemplateToString(String templateName, Map<String, Object> map) {
return processTemplate(templateName, map).toString();
}
public String processTemplateToString(ResponseValues values) {
protected String processTemplateToString(ResponseValues values) {
return processTemplate(values).toString();
}
public Template getTemplate(String templateName) {
private Template getTemplate(String templateName) {
Template template = null;
try {
template = config.getTemplate(templateName);

40
webapp/src/edu/cornell/mannlib/vitro/webapp/web/directives/BaseTemplateDirectiveModel.java
View file

@ -2,6 +2,8 @@
package edu.cornell.mannlib.vitro.webapp.web.directives;
import java.io.IOException;
import java.io.StringWriter;
import java.util.HashMap;
import java.util.Map;
@ -14,7 +16,9 @@ import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.TemplateProcessingHelper;
import freemarker.core.Environment;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateDirectiveModel;
import freemarker.template.TemplateException;
public abstract class BaseTemplateDirectiveModel implements TemplateDirectiveModel {
@ -38,18 +42,32 @@ public abstract class BaseTemplateDirectiveModel implements TemplateDirectiveMod
return directiveName;
}
protected String mergeToHelpTemplate(Map<String, Object> map, Environment environment) {
TemplateProcessingHelper helper = getFreemarkerHelper(environment);
return helper.processTemplateToString("help-directive.ftl", map);
protected String mergeToHelpTemplate(Map<String, Object> map, Environment env) {
return processTemplateToString("help-directive.ftl", map, env);
}
public static TemplateProcessingHelper getFreemarkerHelper(Environment env) {
Configuration config = env.getConfiguration();
// In a directive, custom attributes for request and context are available in the Environment.
// They are put there when the enclosing template is processed.
HttpServletRequest request = (HttpServletRequest) env.getCustomAttribute("request");
ServletContext context = (ServletContext) env.getCustomAttribute("context");
return new TemplateProcessingHelper(config, request, context);
public static String processTemplateToString(String templateName, Map<String, Object> map, Environment env) {
Template template = getTemplate(templateName, env);
StringWriter sw = new StringWriter();
try {
template.process(map, sw);
} catch (TemplateException e) {
log.error("Template Exception creating processing environment", e);
} catch (IOException e) {
log.error("IOException creating processing environment", e);
}
return sw.toString();
}
private static Template getTemplate(String templateName, Environment env) {
Template template = null;
try {
template = env.getConfiguration().getTemplate(templateName);
} catch (IOException e) {
// RY Should probably throw this error instead.
log.error("Cannot get template " + templateName, e);
}
return template;
}
}

15
webapp/src/edu/cornell/mannlib/vitro/webapp/web/directives/dump/DumpHelper.java
View file

@ -27,20 +27,19 @@ public class DumpHelper {
private static final Log log = LogFactory.getLog(DumpHelper.class);
private Environment environment = null;
private Environment env = null;
public DumpHelper(Environment env) {
environment = env;
this.env = env;
}
public String getVariableDump(String varName) {
Map<String, Object> map = getVariableDumpData(varName);
TemplateProcessingHelper helper = BaseTemplateDirectiveModel.getFreemarkerHelper(environment);
return helper.processTemplateToString("dump-var.ftl", map);
return BaseTemplateDirectiveModel.processTemplateToString("dump-var.ftl", map, env);
}
public Map<String, Object> getVariableDumpData(String varName) {
TemplateHashModel dataModel = environment.getDataModel();
TemplateHashModel dataModel = env.getDataModel();
TemplateModel tm = null;
try {
@ -115,10 +114,8 @@ public class DumpHelper {
}
public void writeDump(String templateName, Map<String, Object> map, String modelName) {
TemplateProcessingHelper helper = BaseTemplateDirectiveModel.getFreemarkerHelper(environment);
String output = helper.processTemplateToString(templateName, map);
Writer out = environment.getOut();
String output = BaseTemplateDirectiveModel.processTemplateToString(templateName, map, env);
Writer out = env.getOut();
try {
out.write(output);
} catch (IOException e) {