/// <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(); }