/// <summary>
/// Render takes a hash with local variables.
///
/// if you use the same filters over and over again consider registering them globally
/// with <tt>Template.register_filter</tt>
///
/// Following options can be passed:
///
/// * <tt>filters</tt> : array with local filters
/// * <tt>registers</tt> : hash with register variables. Those can be accessed from
/// filters and tags and might be useful to integrate liquid more with its host application
/// </summary>
private void RenderInternal(TextWriter result, RenderParameters parameters)
{
if (Root == null)
{
return;
}
Context context;
Hash registers;
IEnumerable <Type> filters;
parameters.Evaluate(this, out context, out registers, out filters);
if (registers != null)
{
Registers.Merge(registers);
}
if (filters != null)
{
context.AddFilters(filters);
}
try
{
// Render the nodelist.
Root.Render(context, result);
}
finally
{
_errors = context.Errors;
}
}
public static string RenderWithTracing(this Template template, RenderParameters parameters)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
string content = null;
try
{
content = template.Render(parameters);
}
catch(Exception ex)
{
Trace.TraceError(FlattenException(ex));
}
finally
{
if (template.Errors.Any())
{
template.Errors.ForEach(e => Trace.TraceError(FlattenException(e)));
}
}
return content;
}
/// <summary>
/// Renders the template using the specified parameters and returns a string containing the result.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public async Task <string> RenderAsync(RenderParameters parameters)
{
using (var writer = new StringWriter(parameters.FormatProvider))
{
return(await RenderAsync(writer, parameters).ConfigureAwait(false));
}
}
/// <summary>
/// Renders the template using the specified parameters and returns a string containing the result.
/// </summary>
/// <param name="parameters">Render parameters.</param>
/// <returns>The rendering result as string.</returns>
public string Render(RenderParameters parameters)
{
using (var writer = new StringWriter(parameters.FormatProvider))
{
return(this.Render(writer, parameters));
}
}
/// <summary>
/// Renders the template using the specified parameters and returns a string containing the result.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public string Render(RenderParameters parameters)
{
using (var writer = IndentationTextWriter.Create())
{
Render(writer, parameters);
return(writer.ToString());
}
}
public static void RenderWithTracing(this Template template, TextWriter result, RenderParameters parameters)
{
template.Render(result, parameters);
if (template.Errors.Any())
{
template.Errors.ForEach(e => Trace.TraceError(FlattenException(e)));
}
}
/// <summary>
/// Renders the template using the specified parameters and returns a string containing the result.
/// </summary>
/// <param name="parameters"></param>
/// <param name="restrictTypes"></param>
/// <returns></returns>
public string Render(RenderParameters parameters, bool restrictTypes = true)
{
using (TextWriter writer = new StringWriter())
{
Render(writer, parameters, restrictTypes);
return(writer.ToString());
}
}
/// <summary>
/// Renders the template using the specified parameters and returns a string containing the result.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public string Render(RenderParameters parameters)
{
using (TextWriter writer = new StringWriter())
{
Render(writer, parameters);
return(writer.ToString());
}
}
/// <summary>
/// Renders the template using the specified parameters and returns a string containing the result.
/// </summary>
/// <param name="parameters"></param>
/// <param name="errors"></param>
/// <returns></returns>
public string Render(RenderParameters parameters, out List <Exception> errors)
{
using (TextWriter writer = new StringWriter())
{
errors = Render(writer, parameters);
return(writer.ToString());
}
}
/// <summary>
/// Renders the template into the specified Stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="parameters"></param>
public void Render(Stream stream, RenderParameters parameters)
{
// Can't dispose this new StreamWriter, because it would close the
// passed-in stream, which isn't up to us.
StreamWriter streamWriter = new StreamWriter(stream);
RenderInternal(streamWriter, parameters);
streamWriter.Flush();
}
public static string RenderWithTracing(this Template template, RenderParameters parameters)
{
var content = template.Render(parameters);
if (template.Errors.Any())
{
template.Errors.ForEach(e => Trace.TraceError(FlattenException(e)));
}
return content;
}
/// <summary>
/// Renders the template into the specified Stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="parameters"></param>
public List <Exception> Render(Stream stream, RenderParameters parameters)
{
// Can't dispose this new StreamWriter, because it would close the
// passed-in stream, which isn't up to us.
StreamWriter streamWriter = new StreamWriter(stream);
List <Exception> errors = RenderInternal(streamWriter, parameters);
streamWriter.Flush();
return(errors);
}
/// <summary>
/// Renders the template using the specified local variables and returns a string containing the result.
/// </summary>
/// <param name="localVariables"></param>
/// <param name="formatProvider"></param>
/// <returns></returns>
public async Task <string> RenderAsync(Hash localVariables, IFormatProvider formatProvider = null)
{
formatProvider ??= CultureInfo.CurrentCulture;
using var writer = new StringWriter(formatProvider);
formatProvider = writer.FormatProvider;
var parameters = new RenderParameters(formatProvider)
{
LocalVariables = localVariables,
};
return(await this.RenderAsync(writer, parameters).ConfigureAwait(false));
}
public string Render(TextWriter writer, RenderParameters parameters)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
RenderInternal(writer, parameters);
return(writer.ToString());
}
/// <summary>
/// Render takes a hash with local variables.
///
/// if you use the same filters over and over again consider registering them globally
/// with <tt>Template.register_filter</tt>
///
/// Following options can be passed:
///
/// * <tt>filters</tt> : array with local filters
/// * <tt>registers</tt> : hash with register variables. Those can be accessed from
/// filters and tags and might be useful to integrate liquid more with its host application
/// </summary>
private void RenderInternal(TextWriter result, RenderParameters parameters)
{
if (Root == null)
{
return;
}
Context context;
parameters.Evaluate(this, out context);
// Render the nodelist.
Root.Render(context, result);
}
public async Task <string> RenderAsync(TextWriter writer, RenderParameters parameters)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
await RenderInternalAsync(writer, parameters).ConfigureAwait(false);
return(writer.ToString());
}
/// <summary>
/// Renders the template using the specified local variables and returns a string containing the result.
/// </summary>
/// <param name="localVariables"></param>
/// <param name="formatProvider"></param>
/// <returns></returns>
public string Render(Hash localVariables, IFormatProvider formatProvider = null)
{
formatProvider = formatProvider ?? CultureInfo.CurrentCulture;
using (var writer = new StringWriter(formatProvider))
{
formatProvider = writer.FormatProvider;
var parameters = new RenderParameters(formatProvider)
{
LocalVariables = localVariables
};
return(Render(writer, parameters));
}
}
/// <summary>
/// 描画指定的模板到数据流中
/// </summary>
/// <param name="path">模板路径</param>
/// <param name="argument">传给模板的参数</param>
/// <param name="stream">数据流</param>
public void RenderTemplate(string path, object argument, Stream stream) {
// 构建模板的参数
var parameters = new RenderParameters();
if (argument is IDictionary<string, object>) {
parameters.LocalVariables = Hash.FromDictionary((IDictionary<string, object>)argument);
} else {
parameters.LocalVariables = Hash.FromAnonymousObject(argument);
}
// 查找模板，找不到时写入错误信息
var template = Template.FileSystem.ReadTemplateFile(null, path) as Template;
if (template == null) {
using (var writer = new StreamWriter(stream)) {
writer.WriteLine($"template file {path} not found");
writer.Flush();
}
return;
}
// 使用模板描画到数据流中
template.Render(stream, parameters);
}
/// <summary>
/// Handles the Click event of the lbGenerate control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void lbGenerate_Click(object sender, EventArgs e)
{
var page = new PageService(new RockContext()).Get(ppPage.SelectedValueAsId().Value);
var pages = PageAndDescendants(page);
string lavaTemplate = GetAttributeValue("LavaTemplate");
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(RockPage);
mergeFields.Add("RootPage", page);
mergeFields.Add("Pages", pages);
mergeFields.Add("ReversePages", pages);
DotLiquid.Template template = DotLiquid.Template.Parse(lavaTemplate);
DotLiquid.RenderParameters parameters = new DotLiquid.RenderParameters
{
LocalVariables = DotLiquid.Hash.FromDictionary(mergeFields),
Filters = new Type[] { typeof(LavaAdditions) }
};
lResults.Text = template.Render(parameters).EncodeHtml();
pResults.Visible = true;
}
public static void RenderWithTracing(this Template template, TextWriter result, RenderParameters parameters)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
try
{
template.Render(result, parameters);
}
catch (Exception ex)
{
Trace.TraceError(FlattenException(ex));
}
finally
{
if (template.Errors.Any())
{
template.Errors.ForEach(e => Trace.TraceError(FlattenException(e)));
}
}
}
/// <summary>
/// Resolves the merge fields.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="mergeObjects">The merge objects.</param>
/// <param name="enabledLavaCommands">The enabled lava commands.</param>
/// <param name="encodeStrings">if set to <c>true</c> [encode strings].</param>
/// <param name="throwExceptionOnErrors">if set to <c>true</c> [throw exception on errors].</param>
/// <returns></returns>
public static string ResolveMergeFields( this string content, IDictionary<string, object> mergeObjects, string enabledLavaCommands, bool encodeStrings = false, bool throwExceptionOnErrors = false )
{
try
{
if ( !content.HasMergeFields() )
{
return content ?? string.Empty;
}
if ( GlobalAttributesCache.Read().LavaSupportLevel == Lava.LavaSupportLevel.LegacyWithWarning && mergeObjects.ContainsKey( "GlobalAttribute" ) )
{
if ( hasLegacyGlobalAttributeLavaMergeFields.IsMatch( content ) )
{
Rock.Model.ExceptionLogService.LogException( new Rock.Lava.LegacyLavaSyntaxDetectedException( "GlobalAttribute", "" ), System.Web.HttpContext.Current );
}
}
Template template = Template.Parse( content );
template.InstanceAssigns.Add( "EnabledCommands", enabledLavaCommands );
if ( encodeStrings )
{
// if encodeStrings = true, we want any string values to be XML Encoded (
RenderParameters renderParameters = new RenderParameters();
renderParameters.LocalVariables = Hash.FromDictionary( mergeObjects );
renderParameters.ValueTypeTransformers = new Dictionary<Type, Func<object, object>>();
renderParameters.ValueTypeTransformers[typeof( string )] = EncodeStringTransformer;
return template.Render( renderParameters );
}
else
{
return template.Render( Hash.FromDictionary( mergeObjects ) );
}
}
catch ( Exception ex )
{
if ( throwExceptionOnErrors )
{
throw;
}
else
{
return "Error resolving Lava merge fields: " + ex.Message;
}
}
}
/// <summary>
/// Renders the template using the specified parameters and returns a string containing the result.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public string Render(RenderParameters parameters)
{
List <Exception> errors;
return(Render(parameters, out errors));
}
/// <summary>
/// Render template by content and parameters
/// </summary>
/// <param name="templateContent"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public string RenderTemplate(string templateContent, Dictionary<string, object> parameters)
{
if (String.IsNullOrEmpty(templateContent))
{
return templateContent;
}
if (parameters == null)
{
parameters = new Dictionary<string, object>();
}
Template.FileSystem = this;
var renderParams = new RenderParameters()
{
LocalVariables = Hash.FromDictionary(parameters)
};
var parsedTemplate = _cacheManager.Get(GetCacheKey("ParseTemplate", templateContent.GetHashCode().ToString()), "LiquidTheme", () => { return Template.Parse(templateContent); });
var retVal = parsedTemplate.RenderWithTracing(renderParams);
return retVal;
}
/// <summary>
/// Renders the template into the specified StreamWriter.
/// </summary>
/// <param name="result"></param>
/// <param name="parameters"></param>
public List <Exception> Render(TextWriter result, RenderParameters parameters)
{
return(RenderInternal(result, parameters));
}
public void Render(ViewContext viewContext, TextWriter writer)
{
if (viewContext == null)
{
throw new ArgumentNullException("viewContext");
}
// Copy data from the view context over to DotLiquid
var localVars = new Hash();
if (viewContext.ViewData.Model != null)
{
var model = viewContext.ViewData.Model;
if (model is ILiquidizable)
{
model = ((ILiquidizable)model).ToLiquid();
}
if (model is Hash)
{
localVars = model as Hash;
}
else if (model is IDictionary<string, object>)
{
var modelDictionary = model as IDictionary<string, object>;
foreach (var item in modelDictionary.Keys)
{
localVars.Add(item, modelDictionary[item]);
}
}
}
foreach (var item in viewContext.ViewData)
{
localVars.Add(Template.NamingConvention.GetMemberName(item.Key), item.Value);
}
foreach (var item in viewContext.TempData)
{
localVars.Add(Template.NamingConvention.GetMemberName(item.Key), item.Value);
}
var renderParams = new RenderParameters { LocalVariables = Hash.FromDictionary(localVars) };
var template = _parser.Parse(this.ViewResult);
if (this.MasterViewResult == null)
{
template.RenderWithTracing(writer, renderParams);
}
else // add master
{
var renderedContents = template.RenderWithTracing(renderParams);
// read layout from context
var layout = template.Registers["layout"].ToNullOrString();
var layoutPath = layout == null
? this.MasterViewResult
: _locator.LocateView(layout);
// render master with contents
var masterTemplate = _parser.Parse(layoutPath);
var headerTemplate = _parser.Parse(_locator.LocatePartialView("content_header"));
var renderedHeaderContents = headerTemplate.RenderWithTracing(renderParams);
renderParams.LocalVariables.Add("content_for_layout", renderedContents);
renderParams.LocalVariables.Add("content_for_header", renderedHeaderContents);
masterTemplate.RenderWithTracing(writer, renderParams);
}
}
/// <summary>
/// Renders the template into the specified StreamWriter.
/// </summary>
/// <param name="result"></param>
/// <param name="parameters"></param>
/// <param name="restrictTypes"></param>
public void Render(TextWriter result, RenderParameters parameters, bool restrictTypes = true)
{
RenderInternal(result, parameters, restrictTypes);
}
/// <summary>
/// Renders the template into the specified StreamWriter.
/// </summary>
/// <param name="result"></param>
/// <param name="parameters"></param>
public void Render(TextWriter result, RenderParameters parameters)
{
RenderInternal(result, parameters);
}
/// <summary>
/// Render template by content and parameters
/// </summary>
/// <param name="templateContent"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public string RenderTemplate(string templateContent, Dictionary<string, object> parameters)
{
if (String.IsNullOrEmpty(templateContent))
{
return templateContent;
}
if (parameters == null)
{
parameters = new Dictionary<string, object>();
}
Template.FileSystem = this;
var renderParams = new RenderParameters()
{
LocalVariables = Hash.FromDictionary(parameters)
};
var parsedTemplate = _cacheManager.Get(GetCacheKey("ParseTemplate", templateContent.GetHashCode().ToString()), "LiquidTheme", () => { return Template.Parse(templateContent); });
var retVal = parsedTemplate.RenderWithTracing(renderParams);
//Copy key values which were generated in rendering to out parameters
if (parameters != null && parsedTemplate.Registers != null)
{
foreach (var registerPair in parsedTemplate.Registers)
{
parameters[registerPair.Key] = registerPair.Value;
}
}
return retVal;
}
public string Render(Hash hash)
{
var renderParams = new RenderParameters();
TextWriter textWriter = new StringWriter();
hash.Add("Context", CreateContextHash());
renderParams.LocalVariables = hash;
renderParams.RethrowErrors = true;
ParsedTemplate.Render(textWriter, renderParams);
textWriter.Flush();
return textWriter.ToString().Trim();
}
