@Transactional(readOnly = true)
public int build(String templatePath, String staticPath, Map<String, Object> model) {
Assert.hasText(templatePath);
Assert.hasText(staticPath);
FileOutputStream fileOutputStream = null;
OutputStreamWriter outputStreamWriter = null;
Writer writer = null;
try {
freemarker.template.Template template =
freeMarkerConfigurer.getConfiguration().getTemplate(templatePath);
File staticFile = new File(servletContext.getRealPath(staticPath));
File staticDirectory = staticFile.getParentFile();
if (!staticDirectory.exists()) {
staticDirectory.mkdirs();
}
fileOutputStream = new FileOutputStream(staticFile);
outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
writer = new BufferedWriter(outputStreamWriter);
template.process(model, writer);
writer.flush();
return 1;
} catch (Exception e) {
e.printStackTrace();
} finally {
IOUtils.closeQuietly(writer);
IOUtils.closeQuietly(outputStreamWriter);
IOUtils.closeQuietly(fileOutputStream);
}
return 0;
}
private void generateCode(Writer modelCodeWriter) throws IOException, TemplateException {
Map<String, Object> modelProperties = Maps.newHashMap();
List<Map<String, Object>> eventList = Lists.newLinkedList();
modelProperties.put("modelName", modelName);
modelProperties.put("events", eventList);
modelProperties.put("variables", variableList);
for (Event event : events) {
EventBuilder eventBuilder = new EventBuilder();
Event.EventState eventState = event.getEventState();
Event.Function eventFunctionMatcher = new Event.Function(eventState.getFunctionBody());
eventFunctionMatcher.process();
eventBuilder.setName(eventState.getName());
eventBuilder.setParameters(eventFunctionMatcher.getParameters());
eventBuilder.setBody(eventFunctionMatcher.getBody());
for (Map.Entry<Event, List<Edge>> targetEntry : adjacencyList.row(event).entrySet()) {
List<Edge> edges = targetEntry.getValue();
for (Edge edge : edges) {
eventBuilder.addEdge(edge);
}
}
eventList.add(eventBuilder.asMap());
}
Templates templatesInstance = Templates.getTemplatesInstance();
Configuration templateConfiguration = templatesInstance.getConfiguration();
Template modelTemplate = templateConfiguration.getTemplate("Simulation.java.ftl");
modelTemplate.process(modelProperties, modelCodeWriter);
}
@Override
public String generateContent(AlertEntity alert) {
Map<Object, Object> dataMap = generateExceptionMap(alert);
StringWriter sw = new StringWriter(5000);
try {
Template t = m_configuration.getTemplate("exceptionAlert.ftl");
t.process(dataMap, sw);
} catch (Exception e) {
Cat.logError("build exception content error:" + alert.toString(), e);
}
String alertContent = sw.toString();
String summaryContext = "";
try {
summaryContext = m_executor.execute(alert.getDomain(), alert.getDate());
} catch (Exception e) {
Cat.logError(alert.toString(), e);
}
if (summaryContext != null) {
return alertContent + "<br/>" + summaryContext;
} else {
return alertContent;
}
}
/**
* @param templateName 模板文件名称
* @param templateEncoding 模板文件的编码方式
* @param root 数据模型根对象
*/
public static void analysisTemplate(
String templateName, String templateEncoding, Map<?, ?> root) {
try {
/** 创建Configuration对象 */
Configuration config = new Configuration();
/** 指定模板路径 */
File file = new File("templates");
/** 设置要解析的模板所在的目录，并加载模板文件 */
config.setDirectoryForTemplateLoading(file);
/** 设置包装器，并将对象包装为数据模型 */
config.setObjectWrapper(new DefaultObjectWrapper());
/** 获取模板,并设置编码方式，这个编码必须要与页面中的编码格式一致 */
Template template = config.getTemplate(templateName, templateEncoding);
/** 合并数据模型与模板 */
Writer out = new OutputStreamWriter(System.out);
template.process(root, out);
out.flush();
out.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TemplateException e) {
e.printStackTrace();
}
}
private String buildEmailAlarmContent(ThresholdAlarmMeta meta) {
Map<Object, Object> root = new HashMap<Object, Object>();
StringWriter sw = new StringWriter(5000);
root.put("rule", buildRuleMeta(meta.getDuration()));
root.put("count", meta.getRealCount());
root.put("domain", meta.getDomain());
root.put("date", meta.getDate());
root.put("url", buildProblemUrl(meta.getBaseShowUrl(), meta.getDomain(), meta.getDate()));
try {
String type = meta.getType();
if (type.equalsIgnoreCase(AlertInfo.EXCEPTION)) {
Template t = m_configuration.getTemplate("exceptionAlarm.ftl");
t.process(root, sw);
} else if (type.equalsIgnoreCase(AlertInfo.SERVICE)) {
Template t = m_configuration.getTemplate("serviceAlarm.ftl");
t.process(root, sw);
}
} catch (Exception e) {
Cat.logError(e);
}
return sw.toString();
}
@Override
public void generate(Model model, MolgenisOptions options) throws Exception {
if (options.generate_tests) {
} else {
Template template =
this.createTemplate(this.getClass().getSimpleName() + getExtension() + ".ftl");
Map<String, Object> templateArgs = createTemplateArguments(options);
// apply generator to each entity
for (Entity entity : model.getEntities()) {
// calculate package from its own package
String packageName =
entity.getNamespace().toLowerCase()
+ this.getClass()
.getPackage()
.toString()
.substring(Generator.class.getPackage().toString().length());
File targetDir =
new File(
(this.getSourcePath(options).endsWith("/")
? this.getSourcePath(options)
: this.getSourcePath(options) + "/")
+ packageName.replace(".", "/").replace("/cpp", ""));
try {
File targetFile =
new File(
targetDir + "/" + GeneratorHelper.getJavaName(entity.getName()) + getExtension());
boolean created = targetDir.mkdirs();
if (!created && !targetDir.exists()) {
throw new IOException("could not create " + targetDir);
}
// logger.debug("trying to generated "+targetFile);
templateArgs.put("entity", entity);
templateArgs.put("model", model);
templateArgs.put("db_driver", options.db_driver);
templateArgs.put("template", template.getName());
templateArgs.put(
"file",
targetDir.getCanonicalPath().replace("\\", "/")
+ "/"
+ GeneratorHelper.firstToUpper(entity.getName())
+ getType()
+ getExtension());
templateArgs.put("package", packageName);
OutputStream targetOut = new FileOutputStream(targetFile);
template.process(
templateArgs, new OutputStreamWriter(targetOut, Charset.forName("UTF-8")));
targetOut.close();
logger.info("generated " + targetFile);
} catch (Exception e) {
logger.error("problem generating for " + entity.getName());
throw e;
}
}
}
}
private void readArrayField(Field field, ArrayType array) {
String elTypeJavaName = TypeNameEmitter.getTypeName(array);
if (elTypeJavaName.startsWith("ObjectArray")) {
try {
ArrayEmitter ae = new ArrayEmitter(field, array, this);
Template tpl = global.getTemplateConfig().getTemplate("java/ArrayRead.ftl");
tpl.process(ae, writer);
} catch (TemplateException exc) {
throw new DataScriptException(exc);
} catch (IOException exc) {
throw new DataScriptException(exc);
}
} else {
Expression length = array.getLengthExpression();
TypeInterface elType = array.getElementType();
if (elType instanceof EnumType) {
EnumType enumType = (EnumType) elType;
readEnumField(field, enumType);
} else {
buffer.append(AccessorNameEmitter.getSetterName(field));
buffer.append("(new ");
buffer.append(elTypeJavaName);
buffer.append("(__in, (int)(");
buffer.append(getLengthExpression(length));
buffer.append(")");
if (elType instanceof BitFieldType) {
BitFieldType bitField = (BitFieldType) elType;
Expression numBits = bitField.getLengthExpression();
buffer.append(", ");
buffer.append(getLengthExpression(numBits));
}
}
buffer.append("));");
}
}
/**
* 读取邮件内容
*
* @param model
* @param templateFile
* @return
*/
public String getTemplate(Map<String, Object> model, String templateFile, String templatePath) {
Template temp = null;
Writer out = null;
try {
temp = cfg(templatePath).getTemplate(templateFile);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
out = new OutputStreamWriter(bos);
temp.process(model, out);
String content = bos.toString();
out.close();
return content;
} catch (IOException e) {
logger.error("IO错误", e);
} catch (TemplateException e) {
logger.error("模板错误", e);
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
logger.error("IO错误", e);
}
}
}
return "";
}
/**
* 根据模板内容生成Html内容
*
* @param templateContent freemarker模板内容
* @param paramMap freemarker模板参数600876 600850
* @return
* @throws IOException
* @throws TemplateException
*/
@SuppressWarnings("unchecked")
public static String parseTemplate(String templateContent, Map paramMap)
throws IOException, TemplateException {
Template template =
new Template(null, new StringReader(templateContent), TemplateParser.cfg("/"));
ByteArrayOutputStream bos = new ByteArrayOutputStream();
OutputStreamWriter out = new OutputStreamWriter(bos);
try {
template.process(paramMap, out);
return bos.toString();
} catch (TemplateException e) {
throw e;
} catch (IOException e) {
throw e;
} finally {
try {
out.close();
} catch (IOException e) {
} finally {
out = null;
}
try {
bos.close();
} catch (IOException e) {
} finally {
bos = null;
}
}
}
// templatePath模板文件存放路径
// templateName 模板文件名称
// filename 生成的文件名称
public static void analysisTemplate(
String templatePath, String templateName, String fileName, Map<?, ?> root) {
try {
Configuration config = new Configuration();
// 设置要解析的模板所在的目录，并加载模板文件
config.setDirectoryForTemplateLoading(new File(templatePath));
// 设置包装器，并将对象包装为数据模型
config.setObjectWrapper(new DefaultObjectWrapper());
// 获取模板,并设置编码方式，这个编码必须要与页面中的编码格式一致
// 否则会出现乱码
Template template = config.getTemplate(templateName, "UTF-8");
// 合并数据模型与模板
FileOutputStream fos = new FileOutputStream(fileName);
Writer out = new OutputStreamWriter(fos, "UTF-8");
template.process(root, out);
out.flush();
out.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TemplateException e) {
e.printStackTrace();
}
}
private void displayStartupStatus(ServletRequest req, ServletResponse resp)
throws IOException, ServletException {
HttpServletResponse hresp = (HttpServletResponse) resp;
HttpServletRequest hreq = (HttpServletRequest) req;
try {
Map<String, Object> bodyMap = new HashMap<String, Object>();
bodyMap.put("status", ss);
bodyMap.put("showLink", !isFatal());
bodyMap.put("contextPath", getContextPath());
bodyMap.put("applicationName", getApplicationName());
String url = "";
String path = hreq.getRequestURI();
if (path != null) {
url = path;
}
String query = hreq.getQueryString();
if (!StringUtils.isEmpty(query)) {
url = url + "?" + query;
}
bodyMap.put("url", url);
hresp.setContentType("text/html;charset=UTF-8");
hresp.setStatus(SC_INTERNAL_SERVER_ERROR);
Template tpl = loadFreemarkerTemplate();
tpl.process(bodyMap, hresp.getWriter());
} catch (TemplateException e) {
throw new ServletException("Problem with Freemarker Template", e);
}
}
public static void makeEntity() throws Exception {
Configuration cfg = getCfg();
Template template = cfg.getTemplate("entity.html");
// 生成文件设置
String path =
getJavaFileRoot() + File.separator + PropertyUtil.getValue("code.src.entity.root");
mkdirs(path);
path += File.separator + upperKey + "Entity.java";
FileWriter sw = new FileWriter(new File(path));
WeakHashMap<String, Object> data = new WeakHashMap<String, Object>();
data.put("packageName", entityPackagePath);
data.put("key", key);
data.put("UpperKey", upperKey);
data.put("ZhKey", zhKey);
data.put("author", author);
data.put("createDate", createDate);
List<Field> list = MysqlUtil.getInstance().getTableField();
noCommonFieldList = removeCommonFields(list);
data.put("fieldList", list);
data.put("noCommonFieldList", noCommonFieldList);
primaryKey = MysqlUtil.getInstance().getPrimaryKey(list);
fieldList = list;
String level = PropertyUtil.getValue("created.code.level");
if (!levels.contains(level)) {
level = "all";
}
if ("all".equals(level) || "entity".equals(level)) {
template.process(data, sw);
}
}
/** Description: */
public static void makeController() throws Exception {
Configuration cfg = getCfg();
Template template = cfg.getTemplate("controller.html");
// 生成文件设置
String path =
getJavaFileRoot()
+ File.separator
+ PropertyUtil.getValue("code.src.controller.root")
+ File.separator
+ key;
mkdirs(path);
path += File.separator + upperKey + "Controller.java";
FileWriter sw = new FileWriter(new File(path));
WeakHashMap<String, Object> data = new WeakHashMap<String, Object>();
data.put("packageName", controllerPackagePath); // 包名
data.put("pagePrefix", urlPrefix.substring(1));
data.put("urlPrefix", urlPrefix);
data.put("key", key);
data.put("UpperKey", upperKey);
data.put("ZhKey", zhKey);
data.put("author", author);
data.put("createDate", createDate);
data.put("EntityClass", entityPackagePath + "." + upperKey + "Entity");
data.put("serviceInterFace", servicePackagePath + ".I" + upperKey + "Service");
data.put("primaryKey", primaryKey.getName());
data.put("UpperPrimaryKey", StringUtil.upperFirst(primaryKey.getName()));
template.process(data, sw);
}
/**
* Description: 生成service相关类
*
* @throws Exception
*/
public static void makeService() throws Exception {
Configuration cfg = getCfg();
// interface
Template template = cfg.getTemplate("serviceInterface.html");
// 生成文件设置
String path =
getJavaFileRoot()
+ File.separator
+ PropertyUtil.getValue("code.src.service.root")
+ File.separator
+ key;
mkdirs(path);
path += File.separator + "I" + upperKey + "Service.java";
FileWriter sw = new FileWriter(new File(path));
WeakHashMap<String, Object> data = new WeakHashMap<String, Object>();
data.put("packageName", servicePackagePath); // 包名
data.put("EntityClass", entityPackagePath + "." + upperKey + "Entity");
data.put("key", key);
data.put("UpperKey", upperKey);
data.put("ZhKey", zhKey);
data.put("primaryKey", primaryKey.getName());
data.put("UpperPrimaryKey", StringUtil.upperFirst(primaryKey.getName()));
data.put("PrimaryKeyType", StringUtil.upperFirst(primaryKey.getType()));
data.put("author", author);
data.put("createDate", createDate);
template.process(data, sw);
// impl
Template implTemplate = cfg.getTemplate("service.html");
String serviceImplPackagePath = servicePackagePath + ".impl";
// 生成文件设置
String implPath =
getJavaFileRoot()
+ File.separator
+ PropertyUtil.getValue("code.src.service.root")
+ File.separator
+ key
+ File.separator
+ "impl";
mkdirs(implPath);
implPath += File.separator + upperKey + "ServiceImpl.java";
FileWriter implWriter = new FileWriter(new File(implPath));
WeakHashMap<String, Object> implData = new WeakHashMap<String, Object>();
implData.put("packageName", serviceImplPackagePath); // 包名
implData.put("key", key);
implData.put("UpperKey", upperKey);
implData.put("ZhKey", zhKey);
implData.put("EntityClass", entityPackagePath + "." + upperKey + "Entity");
implData.put("daoInterFace", daoPackagePath + ".I" + upperKey + "Dao");
implData.put("serviceInterFace", servicePackagePath + ".I" + upperKey + "Service");
implData.put("primaryKey", primaryKey.getName());
implData.put("UpperPrimaryKey", StringUtil.upperFirst(primaryKey.getName()));
implData.put("PrimaryKeyType", StringUtil.upperFirst(primaryKey.getType()));
implData.put("author", author);
implData.put("createDate", createDate);
implTemplate.process(implData, implWriter);
}
/**
* @see org.opencms.frontend.layoutpage.I_CmsMacroWrapper#getResult(java.lang.String,
* java.lang.String[])
*/
public String getResult(String macroName, String[] args) {
Writer out = new StringWriter();
boolean error = false;
try {
// get the macro object to process
Macro macro = (Macro) m_template.getMacros().get(macroName);
if (macro != null) {
// found macro, put it context
putContextVariable(MACRO_NAME, macro);
// process the template
m_template.process(getContext(), out);
} else {
// did not find macro
error = true;
}
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error(e.getLocalizedMessage(), e);
}
error = true;
} finally {
try {
out.close();
} catch (Exception e) {
// ignore exception when closing writer
}
}
if (error) {
return "";
}
return out.toString();
}
/**
* método que permite generar fichero index.html
*
* @throws Exception
*/
private void generarIndex() throws Exception {
FileOutputStream fo = null;
Writer out = null;
File index = null;
Template temp;
try {
temp = cfg.getTemplate("index.ftl");
index = new File(dirDestino + "/index.html");
boolean creado = index.createNewFile();
if (creado) {
fo = new FileOutputStream(index);
out = new OutputStreamWriter(fo);
temp.process(root, out);
out.flush();
}
} catch (Exception e) {
if (logger.isDebugEnabled()) {
logger.debug("Error en GeneradorHTML:generarIndex .. " + e.getMessage());
}
throw e;
} finally {
index = null;
if (fo != null) {
try {
fo.close();
out.close();
} catch (IOException e) {
}
}
}
}
protected boolean preTemplateProcess(Template template, TemplateModel model) throws IOException {
Object attrContentType = template.getCustomAttribute("content_type");
if (attrContentType != null) {
ServletActionContext.getResponse().setContentType(attrContentType.toString());
} else {
String contentType = getContentType();
if (contentType == null) {
contentType = "text/html";
}
// webwork:
// String encoding = template.getEncoding();
String encoding = template.getOutputEncoding();
if (encoding != null) {
contentType = contentType + "; charset=" + encoding;
}
ServletActionContext.getResponse().setContentType(contentType);
}
return true;
}
@Override
public void generate(Model model, MolgenisOptions options) throws Exception {
Template template = createTemplate("/" + this.getClass().getSimpleName() + ".java.ftl");
Map<String, Object> templateArgs = createTemplateArguments(options);
List<Entity> entityList = model.getEntities();
entityList = MolgenisModel.sortEntitiesByDependency(entityList, model); // side
// effect?
File target = new File(this.getSourcePath(options) + "/test/TestDataSet.java");
boolean created = target.getParentFile().mkdirs();
if (!created && !target.getParentFile().exists()) {
throw new IOException("could not create " + target.getParentFile());
}
String packageName = "test";
templateArgs.put(
"databaseImp",
options.mapper_implementation.equals(MolgenisOptions.MapperImplementation.JPA)
? "jpa"
: "jdbc");
templateArgs.put("model", model);
templateArgs.put("entities", entityList);
templateArgs.put("package", packageName);
OutputStream targetOut = new FileOutputStream(target);
template.process(templateArgs, new OutputStreamWriter(targetOut, Charset.forName("UTF-8")));
targetOut.close();
logger.info("generated " + target);
}
@Override
public void render(
RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler) {
try {
Template template = cache.get(templateFileName);
if (template == null) {
// real compile
synchronized (this) {
loader.setVertx(context.vertx());
// Compile
template = config.getTemplate(adjustLocation(templateFileName));
}
cache.put(templateFileName, template);
}
Map<String, RoutingContext> variables = new HashMap<>(1);
variables.put("context", context);
try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
template.process(variables, new OutputStreamWriter(baos));
handler.handle(Future.succeededFuture(Buffer.buffer(baos.toByteArray())));
}
} catch (Exception ex) {
handler.handle(Future.failedFuture(ex));
}
}
private String substituteParams(final Event e) {
final Configuration cfg = new Configuration();
final StringWriter writer = new StringWriter();
String processedTemplate = null;
// StringTemplateLoader Freemarker used to read the ResponseTemplate of
// Event object
final StringTemplateLoader stringLoader = new StringTemplateLoader();
stringLoader.putTemplate("template", e.getResponseTemplate());
cfg.setTemplateLoader(stringLoader);
Template tpl;
// Substitutes the ResponseTemplate variables with the values defined in
// the map(params)
try {
tpl = cfg.getTemplate("template");
tpl.process(e.getParams(), writer);
processedTemplate = writer.toString();
} catch (final IOException ex) {
throw new EGOVRuntimeException(
"Exception Occurred in EventProcessor while substituting Parameters" + ex);
} catch (final TemplateException ex) {
throw new EGOVRuntimeException(
"Exception Occurred in EventProcessor while processing Template" + ex);
}
return processedTemplate;
}
public String proessPageContent() {
try {
String name = this.clazz.getSimpleName();
pageExt = pageExt == null ? ".html" : pageExt;
name = this.pageName == null ? name : pageName;
cfg = this.getCfg();
cfg.setNumberFormat("0.##");
Template temp = cfg.getTemplate(name + pageExt);
ByteOutputStream stream = new ByteOutputStream();
Writer out = new OutputStreamWriter(stream);
temp.process(data, out);
out.flush();
String content = stream.toString();
if (wrapPath) {
// System.out.println("before:---------------------------");
// System.out.println(content);
content = EopUtil.wrapjavascript(content, this.getResPath());
content = EopUtil.wrapcss(content, getResPath());
// System.out.println("after:---------------------------");
// System.out.println(content);
}
// content= StringUtil.compressHtml(content);
return content;
} catch (IOException e) {
e.printStackTrace();
} catch (TemplateException e) {
e.printStackTrace();
}
return "widget processor error";
}
/* (non-Javadoc)
* @see org.alfresco.web.scripts.TemplateProcessor#processString(java.lang.String, java.lang.Object, java.io.Writer)
*/
public void processString(String template, Object model, Writer out) {
if (template == null || template.length() == 0) {
throw new IllegalArgumentException("Template is mandatory.");
}
if (model == null) {
throw new IllegalArgumentException("Model is mandatory.");
}
if (out == null) {
throw new IllegalArgumentException("Output Writer is mandatory.");
}
long startTime = 0;
if (logger.isDebugEnabled()) {
logger.debug("Executing template: " + template);
startTime = System.nanoTime();
}
addProcessorModelExtensions(model);
try {
Template t = new Template("name", new StringReader(template), stringConfig);
t.process(model, out);
if (logger.isDebugEnabled()) {
long endTime = System.nanoTime();
logger.debug("Time to execute template: " + (endTime - startTime) / 1000000f + "ms");
}
} catch (Throwable err) {
throw new WebScriptException("Failed to process template " + template, err);
}
}
@Override
public void run() {
try {
Template template = cfg.getTemplate("/reports/templates/classloader.ftl");
ApplicationContext appCtx = new ApplicationContext(namingUtility.getApplicationName());
ClassloaderReport report =
new ClassloaderReport("Class Not Found", "Class Not Found", "Referenced By");
// for each class leveraging a blacklist...
for (JavaClass clz : javaClassDao.getAllClassNotFound()) {
Name name =
namingUtility.getReportJavaResource(runDirectory, reportReference.getParentFile(), clz);
// get reference...
ClassLoaderReportRow row = new ClassLoaderReportRow(name);
addAll(row.getReferences(), clz.providesForJavaClass());
report.getClasses().add(row);
}
Map<String, Object> objects = new HashMap<String, Object>();
objects.put("application", appCtx);
objects.put("classloader", report);
template.process(objects, new FileWriter(reportReference));
} catch (Exception e) {
throw new RuntimeException("Exception processing report.", e);
}
}
public String processarModelo(
CpOrgaoUsuario ou, Map<String, Object> attrs, Map<String, Object> params) throws Exception {
// Create the root hash
Map root = new HashMap();
root.put("root", root);
root.putAll(attrs);
root.put("param", params);
String sTemplate = "[#compress]\n[#include \"GERAL\"]\n";
if (ou != null) {
sTemplate += "[#include \"" + ou.getAcronimoOrgaoUsu() + "\"]";
}
sTemplate += "\n" + (String) attrs.get("template") + "\n[/#compress]";
Template temp = new Template((String) attrs.get("nmMod"), new StringReader(sTemplate), cfg);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Writer out = new OutputStreamWriter(baos);
try {
temp.process(root, out);
} catch (TemplateException e) {
return (e.getMessage() + "\n" + e.getFTLInstructionStack())
.replace("\n", "<br/>")
.replace("\r", "");
} catch (IOException e) {
return e.getMessage();
}
out.flush();
return baos.toString();
}
public static void main(String[] args) {
Writer out = null;
String gAME_VERSION = "1";
String tAG_VERSION = "195";
String channelName = "ZHANGYUE";
String cHANNEL_ID = "3058";
String mEIDA_CHANNEL = "2011552002";
Configuration cfg = new Configuration(Configuration.VERSION_2_3_22);
try {
cfg.setDirectoryForTemplateLoading(new File("./templates"));
cfg.setDefaultEncoding("UTF-8");
cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);
Map<String, Object> root = new HashMap<String, Object>();
XMTLBBConfig xConfig =
XTestMain.getConfigBean(
channelName, cHANNEL_ID, gAME_VERSION, tAG_VERSION, mEIDA_CHANNEL);
root.put("XMTLBB", xConfig);
File target = new File("./target/" + cHANNEL_ID + "/config.properties");
target.getParentFile().mkdirs();
Template temp = cfg.getTemplate("config.ftl");
out = new OutputStreamWriter(new FileOutputStream(target), "utf-8");
temp.process(root, out);
out.flush();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static LayoutContent displayHome(spark.Request request, Configuration cfg) {
String html = "";
Map<String, String> root = Tools.listLayoutMap();
root.replace("msg", DBH.getMsg(request.session().id()));
Template temp;
try {
temp = cfg.getTemplate("user-home.htm");
Writer out = new StringWriter();
temp.process(root, out);
html = out.toString();
} catch (IOException | TemplateException e) {
// TODO Auto-generated catch block
e.printStackTrace();
html = e.getMessage();
}
HashMap<String, String> options = new HashMap<String, String>();
options.put("addBtn", Tools.getAddBtn("/tramites/agregar", "Iniciar Trámite"));
options.put(
"toolBar",
Tools.getToolbarItem("/tramites/agregar", "Iniciar Trámite", "", "btn red darken-3")
+ Tools.getToolbarItem("/tramites", "Trámites", "", "btn green darken-3"));
LayoutContent lc = new LayoutContent(html, options);
return lc;
}
public void generatePropertiesClass(PropertiesClass propertiesClass, Writer out)
throws IOException, TemplateException {
Template template = cfg.getTemplate("properties_class.ftl");
Environment env = template.createProcessingEnvironment(propertiesClass, out);
env.setOutputEncoding(outputCharset);
env.process();
}
public static void process(HttpSession session, PrintWriter out, String template)
throws TemplateException, IOException {
// handle all button stuff, if user has loging, create logout button
// if not, create login button
if (!root.containsKey("button")) {
if (session.getAttribute("user") == null) {
root.put(
"button",
"<li><a href='login.html'><span class='glyphicon glyphicon-log-in'></span> Login</a></li>");
} else {
root.put(
"button",
"<li><a><span class='glyphicon'></span>Welcome, "
+ session.getAttribute("user")
+ "</a></li>"
+ "<li><a href='logout.html'><span class='glyphicon glyphicon-log-out'></span> Logout</a></li>");
}
}
// set default value
if (!root.containsKey("list")) root.put("list", "");
if (!root.containsKey("menu")) root.put("menu", "");
Template temp = cfg.getTemplate(template);
temp.process(root, out);
root = new HashMap();
}
@Override
@SuppressWarnings({"unchecked", "rawtypes"})
public void render() {
response.setContentType(CONTENT_TYPE);
Enumeration<String> attrs = request.getAttributeNames();
Map root = new HashMap();
while (attrs.hasMoreElements()) {
String attrName = attrs.nextElement();
root.put(attrName, request.getAttribute(attrName));
}
Writer writer = null;
try {
writer = response.getWriter();
Template template = getConfiguration().getTemplate(view);
template.process(root, writer); // Merge the data-model and the template
} catch (Exception e) {
throw new RenderException(e);
} finally {
try {
if (writer != null) {
writer.close();
}
} catch (IOException e) {
Throwables.propagate(e);
}
}
}
public static void main(String[] args) throws Exception {
/* You should do this ONLY ONCE in the whole application life-cycle: */
/* Create and adjust the configuration singleton */
Configuration cfg = new Configuration(Configuration.VERSION_2_3_22);
cfg.setDirectoryForTemplateLoading(new File("/Users/ian.goldsmith/projects/freemarker"));
cfg.setDefaultEncoding("UTF-8");
cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);
/*
* You usually do these for MULTIPLE TIMES in the application
* life-cycle:
*/
/* Create a data-model */
Map message = new HashMap();
message.put(
"contentAsXml",
freemarker.ext.dom.NodeModel.parse(
new File("/Users/ian.goldsmith/projects/freemarker/test.xml")));
Map root = new HashMap();
root.put("message", message);
/* Get the template (uses cache internally) */
Template temp = cfg.getTemplate("testxml.ftl");
/* Merge data-model with template */
Writer out = new OutputStreamWriter(System.out);
temp.process(root, out);
// Note: Depending on what `out` is, you may need to call `out.close()`.
// This is usually the case for file output, but not for servlet output.
}
