public async Task <string> RenderAsync(string stringTemplate, object model, string language = null)
{
var context = new LiquidTemplateContext()
{
EnableRelaxedMemberAccess = true,
NewLine = Environment.NewLine,
TemplateLoaderLexerOptions = new LexerOptions
{
Mode = ScriptMode.Liquid
},
LoopLimit = _options.LoopLimit
};
var scriptObject = AbstractTypeFactory <NotificationScriptObject> .TryCreateInstance();
scriptObject.Language = language;
scriptObject.Import(model);
foreach (var customFilterType in _options.CustomFilterTypes)
{
scriptObject.Import(customFilterType);
}
context.PushGlobal(scriptObject);
var template = Template.ParseLiquid(stringTemplate);
var result = await template.RenderAsync(context);
return(result);
}
public async Task <MetadataRenderResult[]> Render(MetadataRenderRequest[] requests)
{
var renderedResults = new List <MetadataRenderResult>();
var templates = await new LayoutLoader(_fileSystem, _metadataProvider).Load(_layoutDirectory);
var templateLoader = new MyIncludeFromDisk(_fileSystem, _templateDirectory);
foreach (var request in requests)
{
try
{
var template = templates.FirstOrDefault(t => t.Name.Equals(request.Template));
var content = template?.Content ?? "{{ content }}";
content = content.Replace("{{ content }}", request.Metadata.Content);
var liquidTemplate = Template.ParseLiquid(content);
var context = new LiquidTemplateContext()
{
TemplateLoader = templateLoader
};
var scriptObject = new ScriptObject();
scriptObject.Import(request.Metadata);
context.PushGlobal(scriptObject);
scriptObject.Import(typeof(GlobalFunctions));
foreach (var plugin in _plugins)
{
scriptObject.Import(plugin.Name, new Func <string>(() => plugin.Render(request.Metadata)));
// scriptObject.Import(plugin.Name, new Func<string>(() =>
// return plugin.Render(request.Model)
// );
// scriptObject.Import(plugin.Name, new Func<TemplateContext, string>(templateContext => {
// return plugin.Render(templateContext.CurrentGlobal);
// }));
}
// scriptObject.Import("seo", new Func<TemplateContext, string>(templateContext => {
// return "<strong>{{ build.git_hash }}</strong>";
// }));
var renderedContent = await liquidTemplate.RenderAsync(context);
renderedResults.Add(new MetadataRenderResult {
Content = renderedContent
});
}
catch (Exception)
{
throw;
}
}
return(renderedResults.ToArray());
}
public string Render(object model = null)
{
var context = new LiquidTemplateContext {
TemplateLoader = FileSystem
};
var obj = new ScriptObject();
if (model != null)
{
obj.Import(model);
}
context.PushGlobal(obj);
return(_template.Render(context));
}
/// <summary>
/// Constructs a new instance of the <see cref="LiquidTemplateRenderer"/> class with a logger.
/// </summary>
public LiquidTemplateRenderer(ILogger logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
// Load functions to support Liquid rendering
var funcScriptObject = new ScriptObject();
funcScriptObject.Import(typeof(CustomLiquidFunctions));
// Create template context (disable loop limit)
_context = new LiquidTemplateContext()
{
LoopLimit = int.MaxValue
};
_context.PushGlobal(funcScriptObject);
}
public string Render(object data)
{
var liquidTemplate = Template.ParseLiquid(_raw);
var context = new LiquidTemplateContext();
var ld = LdJson(data);
var scriptObject = new ScriptObject
{
["seo_tag"] = data,
["json_ld"] = ld
};
scriptObject.Import(typeof(GlobalFunctions));
context.PushGlobal(scriptObject);
var pluginResult = liquidTemplate.Render(context);
return(pluginResult);
}
public async Task <string> RenderAsync(string template, object contextObj)
{
var scribanContext = new LiquidTemplateContext()
{
EnableRelaxedMemberAccess = true,
NewLine = Environment.NewLine,
TemplateLoaderLexerOptions = new LexerOptions
{
Mode = ScriptMode.Liquid
}
};
var scriptObject = new ScriptObject();
scriptObject.Import(contextObj);
scribanContext.PushGlobal(scriptObject);
var parsedTemplate = Template.ParseLiquid(template);
return(await parsedTemplate.RenderAsync(scribanContext));
}
/// <summary>
/// Renders a template using a Liquid template engine.
/// </summary>
/// <param name="templateContent">The template content to render.</param>
/// <param name="model">The model used to provide properties to Liquid templates.</param>
/// <param name="messagingObject">An optional messaging object to add to the variable context, accessible to templates.</param>
/// <param name="resourceTemplate">An optional resource template object to add to the variable context, accessible to templates.</param>
/// <returns>The rendered template content.</returns>
public async Task <string> RenderTemplateAsync(string templateContent, AzureIntegrationServicesModel model, MessagingObject messagingObject = null, TargetResourceTemplate resourceTemplate = null)
{
_ = model ?? throw new ArgumentNullException(nameof(model));
_ = templateContent ?? throw new ArgumentNullException(nameof(templateContent));
// Create variables on script object, to be accessible to Liquid templates
var scriptObject = new ScriptObject
{
["model"] = model
};
// Is there a messaging object?
if (messagingObject != null)
{
var messagingObjects = model.FindMessagingObject(messagingObject.Key);
if (messagingObjects.messageBus != null)
{
scriptObject["message_bus"] = messagingObjects.messageBus;
if (messagingObjects.application != null)
{
scriptObject["application"] = messagingObjects.application;
}
if (messagingObjects.messagingObject != null)
{
scriptObject["messaging_object"] = messagingObjects.messagingObject;
switch (messagingObjects.messagingObject.Type)
{
case MessagingObjectType.Message:
scriptObject["message"] = (Message)messagingObjects.messagingObject;
break;
case MessagingObjectType.Channel:
scriptObject["channel"] = (Channel)messagingObjects.messagingObject;
break;
case MessagingObjectType.Intermediary:
scriptObject["intermediary"] = (Intermediary)messagingObjects.messagingObject;
break;
case MessagingObjectType.Endpoint:
scriptObject["endpoint"] = (Endpoint)messagingObjects.messagingObject;
break;
}
}
}
else
{
// Should never happen, unless the messaging object is not attached to the target model
_logger.LogWarning(WarningMessages.MessagingObjectMissingInModel, messagingObject.Key);
}
}
// Is there a resource template?
if (resourceTemplate != null)
{
scriptObject["resource_template"] = resourceTemplate;
}
// Push variables onto the context
_context.PushGlobal(scriptObject);
try
{
// Render template
var template = Template.ParseLiquid(templateContent);
var renderedContent = await template.RenderAsync(_context).ConfigureAwait(false);
return(renderedContent);
}
finally
{
// Pop model from context stack
_context.PopGlobal();
}
}