protected String getBody(Context ctx) { return templateEngine.process(this.template, ctx); }
@Override public void configure(final Env env, final Config conf, final Binder binder) throws Throwable { ClassLoaderTemplateResolver resolver = new ClassLoaderTemplateResolver(); boolean cacheable = !env.name().equals("dev"); /** Defaults: */ resolver.setCacheable(cacheable); resolver.setPrefix(prefix); resolver.setSuffix(suffix); resolver.setTemplateMode(TemplateMode.HTML); TemplateEngine engine = new TemplateEngine(); engine.setTemplateResolver(resolver); if (callback != null) { callback.accept(engine, conf); } binder.bind(TemplateEngine.class).toInstance(engine); binder.bind(ITemplateEngine.class).toInstance(engine); Multibinder.newSetBinder(binder, Renderer.class) .addBinding() .toInstance(new ThlEngine(engine, env)); } }
/** * <p> * Sets an additional set of dialects for this template engine, all of them using * their default prefixes. * </p> * <p> * This operation can only be executed before processing templates for the first * time. Once a template is processed, the template engine is considered to be * <i>initialized</i>, and from then on any attempt to change its configuration * will result in an exception. * </p> * * @param additionalDialects the new set of {@link IDialect} objects to be used. * * @since 2.0.9 * */ public void setAdditionalDialects(final Set<IDialect> additionalDialects) { Validate.notNull(additionalDialects, "Dialect set cannot be null"); checkNotInitialized(); for (final IDialect dialect : additionalDialects) { addDialect(dialect); } }
public final IThrottledTemplateProcessor processThrottled(final TemplateSpec templateSpec, final IContext context) { initialize(); try { new Object[]{TemplateEngine.threadIndex(), templateSpec, context.getLocale()}); new Object[]{TemplateEngine.threadIndex(), templateSpec, context.getLocale()}); final BigDecimal elapsed = BigDecimal.valueOf(endNanos - startNanos); final BigDecimal elapsedMs = elapsed.divide(BigDecimal.valueOf(NANOS_IN_SECOND), RoundingMode.HALF_UP); timerLogger.trace( "[THYMELEAF][{}][{}][{}][{}][{}] TEMPLATE \"{}\" WITH LOCALE {} PREPARED FOR THROTTLED PROCESSING IN {} nanoseconds (approx. {}ms)", new Object[]{ TemplateEngine.threadIndex(), LoggingUtils.loggifyTemplateName(templateSpec.getTemplate()), context.getLocale(), elapsed, elapsedMs, templateSpec, context.getLocale(), elapsed, elapsedMs}); logger.error(String.format("[THYMELEAF][%s] Exception preparing throttled template \"%s\": %s", new Object[] {TemplateEngine.threadIndex(), templateSpec, e.getMessage()}), e); throw e; logger.error(String.format("[THYMELEAF][%s] Exception preparing throttled template \"%s\": %s", new Object[] {TemplateEngine.threadIndex(), templateSpec, e.getMessage()}), e); throw e; logger.error(String.format("[THYMELEAF][%s] Exception preparing throttled template \"%s\": %s", new Object[] {TemplateEngine.threadIndex(), templateSpec, e.getMessage()}), e); throw new TemplateProcessingException("Exception preparing throttled template", templateSpec.toString(), e);
static Object executeMinus( final IExpressionContext context, final MinusExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating minus expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } Object operandValue = expression.getOperand().execute(context, expContext); if (operandValue == null) { operandValue = "null"; } final BigDecimal operandNumberValue = EvaluationUtils.evaluateAsNumber(operandValue); if (operandNumberValue != null) { // Addition will act as a mathematical 'plus' return operandNumberValue.multiply(BigDecimal.valueOf(-1)); } throw new TemplateProcessingException( "Cannot execute minus: operand is \"" + LiteralValue.unwrap(operandValue) + "\""); }
new Object[]{TemplateEngine.threadIndex(), Integer.valueOf(maxOutput), outputType, this.templateSpec, this.context.getLocale()}); new Object[]{TemplateEngine.threadIndex(), Integer.valueOf(maxOutput), outputType, Integer.valueOf(writtenCount), outputType, this.templateSpec, this.context.getLocale()}); final BigDecimal elapsed = BigDecimal.valueOf(endNanos - startNanos); final BigDecimal elapsedMs = elapsed.divide(BigDecimal.valueOf(NANOS_IN_SECOND), RoundingMode.HALF_UP); timerLogger.trace( "[THYMELEAF][{}][{}][{}][{}][{}] TEMPLATE \"{}\" WITH LOCALE {} PROCESSED (THROTTLED, LIMIT:{} {}, OUTPUT: {} {}) IN {} nanoseconds (approx. {}ms)", new Object[]{ TemplateEngine.threadIndex(), LoggingUtils.loggifyTemplateName(this.templateSpec.getTemplate()), this.context.getLocale(), elapsed, elapsedMs, this.templateSpec, this.context.getLocale(), Integer.valueOf(maxOutput), outputType, Integer.valueOf(writtenCount), outputType, elapsed, elapsedMs}); this.allProcessingFinished = true; logger.error(String.format("[THYMELEAF][%s] Exception processing throttled template \"%s\": %s", new Object[] {TemplateEngine.threadIndex(), this.templateSpec, e.getMessage()}), e); throw e; this.allProcessingFinished = true; logger.error(String.format("[THYMELEAF][%s] Exception processing throttled template \"%s\": %s", new Object[] {TemplateEngine.threadIndex(), this.templateSpec, e.getMessage()}), e); throw e; this.allProcessingFinished = true; logger.error(String.format("[THYMELEAF][%s] Exception processing throttled template \"%s\": %s", new Object[] {TemplateEngine.threadIndex(), this.templateSpec, e.getMessage()}), e); throw new TemplateProcessingException("Exception processing throttled template", this.templateSpec.toString(), e);
final GreaterOrEqualToExpression expression, final StandardExpressionExecutionContext expContext) { Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); result = Boolean.valueOf(leftNumberValue.compareTo(rightNumberValue) != -1); } else { if (leftValue != null && rightValue != null && result = Boolean.valueOf(((Comparable<Object>)leftValue).compareTo(rightValue) >= 0); } else { throw new TemplateProcessingException( "Cannot execute GREATER OR EQUAL TO from Expression \"" + expression.getStringRepresentation() + "\". Left is \"" + new Object[] {TemplateEngine.threadIndex(), expression.getStringRepresentation(), leftValue, rightValue, result});
logger.trace("[THYMELEAF][{}] Evaluating division expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); if (leftNumberValue != null && rightNumberValue != null) { try { return leftNumberValue.divide(rightNumberValue); } catch (final ArithmeticException ignored) { return leftNumberValue.divide( rightNumberValue, Math.max(Math.max(leftNumberValue.scale(),rightNumberValue.scale()), 10), RoundingMode.HALF_UP); throw new TemplateProcessingException( "Cannot execute division: operands are \"" + LiteralValue.unwrap(leftValue) + "\" and \"" + LiteralValue.unwrap(rightValue) + "\"");
final NotEqualsExpression expression, final StandardExpressionExecutionContext expContext) { Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); result = Boolean.valueOf(leftNumberValue.compareTo(rightNumberValue) != 0); } else { if (leftValue instanceof Character) { new Object[] {TemplateEngine.threadIndex(), expression.getStringRepresentation(), leftValue, rightValue, result});
static Object executeMultiplication( final IExpressionContext context, final MultiplicationExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating multiplication expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); if (leftValue == null) { leftValue = "null"; } if (rightValue == null) { rightValue = "null"; } final BigDecimal leftNumberValue = EvaluationUtils.evaluateAsNumber(leftValue); final BigDecimal rightNumberValue = EvaluationUtils.evaluateAsNumber(rightValue); if (leftNumberValue != null && rightNumberValue != null) { // Addition will act as a mathematical 'plus' return leftNumberValue.multiply(rightNumberValue); } throw new TemplateProcessingException( "Cannot execute multiplication: operands are \"" + LiteralValue.unwrap(leftValue) + "\" and \"" + LiteralValue.unwrap(rightValue) + "\""); }
logger.trace("[THYMELEAF][{}] Evaluating addition expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); leftValue = leftExpr.execute(context, expContext); rightValue = rightExpr.execute(context, expContext); if (rightNumberValue != null) { return leftNumberValue.add(rightNumberValue);
static Object executeSubtraction( final IExpressionContext context, final SubtractionExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating subtraction expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); if (leftValue == null) { leftValue = "null"; } if (rightValue == null) { rightValue = "null"; } final BigDecimal leftNumberValue = EvaluationUtils.evaluateAsNumber(leftValue); final BigDecimal rightNumberValue = EvaluationUtils.evaluateAsNumber(rightValue); if (leftNumberValue != null && rightNumberValue != null) { // Addition will act as a mathematical 'plus' return leftNumberValue.subtract(rightNumberValue); } throw new TemplateProcessingException( "Cannot execute subtraction: operands are \"" + LiteralValue.unwrap(leftValue) + "\" and \"" + LiteralValue.unwrap(rightValue) + "\""); }
static Object executeRemainder( final IExpressionContext context, final RemainderExpression expression, final StandardExpressionExecutionContext expContext) { if (logger.isTraceEnabled()) { logger.trace("[THYMELEAF][{}] Evaluating remainder expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation()); } Object leftValue = expression.getLeft().execute(context, expContext); Object rightValue = expression.getRight().execute(context, expContext); if (leftValue == null) { leftValue = "null"; } if (rightValue == null) { rightValue = "null"; } final BigDecimal leftNumberValue = EvaluationUtils.evaluateAsNumber(leftValue); final BigDecimal rightNumberValue = EvaluationUtils.evaluateAsNumber(rightValue); if (leftNumberValue != null && rightNumberValue != null) { // Addition will act as a mathematical 'plus' return leftNumberValue.remainder(rightNumberValue); } throw new TemplateProcessingException( "Cannot execute division: operands are \"" + LiteralValue.unwrap(leftValue) + "\" and \"" + LiteralValue.unwrap(rightValue) + "\""); }
/** * Initializes and sets the template resolver */ private void initialize(ITemplateResolver templateResolver) { templateEngine = new org.thymeleaf.TemplateEngine(); templateEngine.setTemplateResolver(templateResolver); templateEngine.addDialect(new Java8TimeDialect()); }
ClassLoaderTemplateResolver resolver = new ClassLoaderTemplateResolver(); resolver.setTemplateMode("HTML5"); resolver.setSuffix(".html"); TemplateEngine templateEngine = new TemplateEngine(); templateEngine.setTemplateResolver(resolver); final Context context = new Context(Locale.CANADA); String name = "John Doe"; context.setVariable("name", name); // add more objects from your ResultSet final String html = templateEngine.process("myhtml", context);
private void execute(final ITestable testable, final TestExecutionContext context) { Validate.notNull(testable, "Testable cannot be null"); Validate.notNull(context, "Test execution context cannot be null"); final TestEngineTemplateResolver templateResolver = new TestEngineTemplateResolver(); final TestEngineMessageResolver messageResolver = new TestEngineMessageResolver(); final TestCacheManager cacheManager = new TestCacheManager(); final TemplateEngine templateEngine = new TemplateEngine(); templateEngine.setTemplateResolver(templateResolver); templateEngine.setMessageResolver(messageResolver); templateEngine.setDialects(new HashSet<IDialect>(this.dialects)); templateEngine.setCacheManager(cacheManager); context.setTemplateEngine(templateEngine); this.reporter.executionStart(context.getExecutionId()); final TestExecutionResult result = executeTestable(testable, context); this.reporter.executionEnd( context.getExecutionId(), result.getTotalTestsOk(), result.getTotalTestsExecuted(), result.getTotalTimeNanos()); }
templateResolver.setCacheTTLMs(3600000L); templateEngine = new TemplateEngine(); templateEngine.setTemplateResolver(templateResolver); templateEngine.setMessageResolver(new SegradaMessageResolver(servletContext)); templateEngine.addDialect(new SegradaDialect()); templateEngine.process(templateName, templateSelectors, context, responseInvoker.get().getWriter());
@SuppressWarnings("unchecked") @Override protected void doProcess(ITemplateContext theContext, IProcessableElementTag theTag, AttributeName theAttributeName, String theAttributeValue, IElementTagStructureHandler theStructureHandler) { IEngineConfiguration configuration = theContext.getConfiguration(); IStandardExpressionParser expressionParser = StandardExpressions.getExpressionParser(configuration); final Object value = expression.execute(theContext); String result = myProfileTemplateEngine.process(name, context); String trim = result.trim();
/** * {@inheritDoc} */ @Override public final void execute() throws Exception { checkCatalog(); final Context context = new Context(); context.setVariable("catalog", catalog); context.setVariable("identifiers", identifiers); final TemplateEngine templateEngine = new TemplateEngine(); final Charset inputCharset = outputOptions.getInputCharset(); final FileTemplateResolver fileResolver = new FileTemplateResolver(); fileResolver.setCheckExistence(true); templateEngine.addTemplateResolver(configure(fileResolver, inputCharset)); final ClassLoaderTemplateResolver classpathResolver = new ClassLoaderTemplateResolver(); classpathResolver.setCheckExistence(true); templateEngine .addTemplateResolver(configure(classpathResolver, inputCharset)); final UrlTemplateResolver urlResolver = new UrlTemplateResolver(); urlResolver.setCheckExistence(true); templateEngine.addTemplateResolver(configure(urlResolver, inputCharset)); final String templateLocation = outputOptions.getOutputFormatValue(); try (final Writer writer = outputOptions.openNewOutputWriter();) { templateEngine.process(templateLocation, context, writer); } }
myProfileTemplateEngine = new TemplateEngine(); ProfileResourceResolver resolver = new ProfileResourceResolver(); myProfileTemplateEngine.setTemplateResolver(resolver); StandardDialect dialect = new StandardDialect() { @Override myProfileTemplateEngine.setDialect(dialect); if (this.resolver != null) { myProfileTemplateEngine.setMessageResolver(this.resolver);