public override void Render(object toRender, Stream output)
{
AppContentResponder appContentResponder = ContentResponder.AppContentResponders[AppName];
ITemplateRenderer dustRenderer = appContentResponder.AppTemplateRenderer;
string templateName = GetTemplateName(toRender);
string templates = dustRenderer.CompiledTemplates;
string result = DustScript.Render(templates, templateName, toRender);
string layout;
byte[] data;
if (HttpArgs.Has("layout", out layout))
{
string absolutePath = ExecutionRequest.Request.Url.AbsolutePath;
string extension = Path.GetExtension(absolutePath);
string path = absolutePath.Truncate(extension.Length);
LayoutModel layoutModel = appContentResponder.GetLayoutModelForPath(path);
layoutModel.LayoutName = layout;
layoutModel.PageContent = result;
MemoryStream ms = new MemoryStream();
appContentResponder.CommonTemplateRenderer.RenderLayout(layoutModel, ms);
ms.Seek(0, SeekOrigin.Begin);
data = ms.GetBuffer();
}
else
{
data = Encoding.UTF8.GetBytes(result);
}
output.Write(data, 0, data.Length);
}
public ConsoleEmailSender(MailTemplatingSettings mailSettings, ILogger <ConsoleEmailSender> logger, ITemplateRenderer templateRenderer, IEmailQueue emailQueue)
{
_logger = logger;
_templateRenderer = templateRenderer;
_emailQueue = emailQueue;
_mailSettings = mailSettings;
}
public EmailService(
IEmailSender emailSender,
ITemplateRenderer templateRenderer)
{
_emailSender = emailSender;
_templateRenderer = templateRenderer;
}
public void RenderTemplateAsyncWithIntermediaryWithSuccess(ITemplateRenderer renderer, AzureIntegrationServicesModel model, MessagingObject messagingObject, string templateContent, string renderedContent, Exception e)
{
"Given a template renderer"
.x(() => renderer = new LiquidTemplateRenderer(_mockLogger.Object));
"And a model"
.x(() => model = _model);
"And a messaging object"
.x(() => messagingObject = model.FindMessagingObject("ContosoMessageBus:System:MessageAgent").messagingObject);
"And a template content"
.x(() => templateContent = _templateIntermediaryContent);
"When rendering the template"
.x(async() => e = await Record.ExceptionAsync(async() => renderedContent = await renderer.RenderTemplateAsync(templateContent, model, messagingObject)));
"Then the render should succeed"
.x(() => e.Should().BeNull());
"And the rendered content should have expected values from the model"
.x(() =>
{
renderedContent.Should().NotBeNull().And.ContainAny("MessageAgent").And.NotContainAny("{{").And.NotContainAny("}}");
});
}
public Template(ITemplateRenderer renderer, ITemplatePreprocessor preprocessor)
{
if (renderer == null && preprocessor == null)
{
throw new ArgumentNullException("Both renderer and preprocessor are null");
}
Renderer = renderer;
Preprocessor = preprocessor;
Name = renderer?.Name ?? preprocessor?.Name;
ScriptName = preprocessor?.Path;
var templateInfo = GetTemplateInfo(Name);
Extension = templateInfo.Extension;
Type = templateInfo.DocumentType;
TemplateType = templateInfo.TemplateType;
ContainsGetOptions = Preprocessor?.ContainsGetOptions == true;
ContainsModelTransformation = Preprocessor?.ContainsModelTransformation == true;
Resources = ExtractDependentResources(Name);
if (Renderer == null && !ContainsGetOptions && !ContainsModelTransformation)
{
Logger.LogWarning($"Template {Name} contains neither preprocessor to process model nor template to render model. Please check if the template is correctly defined. Allowed preprocessor functions are [exports.getOptions] and [exports.transform].");
}
}
public UmbracoComponentRenderer(IUmbracoContextAccessor umbracoContextAccessor, IMacroRenderer macroRenderer, ITemplateRenderer templateRenderer, HtmlLocalLinkParser linkParser)
{
_umbracoContextAccessor = umbracoContextAccessor;
_macroRenderer = macroRenderer;
_templateRenderer = templateRenderer ?? throw new ArgumentNullException(nameof(templateRenderer));
_linkParser = linkParser;
}
public Template(string template, string templateName, string script, ResourceCollection resourceProvider)
{
if (string.IsNullOrEmpty(templateName))
{
throw new ArgumentNullException(nameof(templateName));
}
if (string.IsNullOrEmpty(template))
{
throw new ArgumentNullException(nameof(template));
}
Name = templateName;
var typeAndExtension = GetTemplateTypeAndExtension(templateName);
Extension = typeAndExtension.Item2;
Type = typeAndExtension.Item1;
IsPrimary = typeAndExtension.Item3;
_script = script;
if (resourceProvider != null)
{
if (Path.GetExtension(templateName).Equals(".liquid", StringComparison.OrdinalIgnoreCase))
{
_renderer = LiquidTemplateRenderer.Create(resourceProvider, template);
}
else
{
_renderer = new MustacheTemplateRenderer(resourceProvider, template);
}
}
Resources = ExtractDependentResources();
}
public void RenderTemplateAsyncWithResourceTemplateWithSuccess(ITemplateRenderer renderer, AzureIntegrationServicesModel model, MessagingObject messagingObject, TargetResourceTemplate resourceTemplate, string templateContent, string renderedContent, Exception e)
{
"Given a template renderer"
.x(() => renderer = new LiquidTemplateRenderer(_mockLogger.Object));
"And a model"
.x(() => model = _model);
"And a messaging object"
.x(() => messagingObject = model.FindMessagingObject("ContosoMessageBus:System:FtpReceive").messagingObject);
"And a resource template object"
.x(() => resourceTemplate = new TargetResourceTemplate()
{
ResourceName = "endpointFtpReceiveLogicAppConsumption"
});
"And a template content"
.x(() => templateContent = _templateResourceTemplateContent);
"When rendering the template"
.x(async() => e = await Record.ExceptionAsync(async() => renderedContent = await renderer.RenderTemplateAsync(templateContent, model, null, resourceTemplate)));
"Then the render should succeed"
.x(() => e.Should().BeNull());
"And the rendered content should have expected values from the model"
.x(() =>
{
renderedContent.Should().NotBeNull().And.ContainAny("endpointFtpReceiveLogicAppConsumption").And.NotContainAny("{{").And.NotContainAny("}}");
});
}
/// <summary>
/// Add a template engine for binding templates
/// </summary>
/// <param name="engine"></param>
public void Register(ITemplateRenderer engine)
{
if (!this._templateRenderers.Contains(engine))
{
this._templateRenderers.Add(engine);
}
}
public CustomRendererDemo(ServiceProvider?services)
{
if (services is null)
{
throw new ArgumentNullException(nameof(services));
}
_templateRenderer = services.GetServices <ITemplateRenderer>().First(s => s.GetType() == typeof(CustomTemplateRenderer));
}
public TemplateProcessor(ITemplateRenderer renderer, IObservableConsul client, string templatePath, string outputPath, PropertyBag properties = null)
{
_renderer = renderer;
_client = client;
TemplatePath = templatePath;
OutputPath = outputPath;
Properties = properties;
}
public SendEmailTask(IMailMergeService mailMergeService, ITemplateRenderer renderer, ITenantContext tenantContext, IStringLocalizer <EmailResource> localizer, ILogger <SendEmailTask> logger)
{
_mailMergeService = mailMergeService;
_renderer = renderer;
_localizer = localizer;
_tenantContext = tenantContext;
_logger = logger;
}
public static Task <string> RenderAsync([NotNull] this ITemplateRenderer renderer,
string template, CancellationToken cancellationToken = default)
{
Check.NotNull(renderer, nameof(renderer));
return(string.IsNullOrEmpty(template)
? Task.FromResult(string.Empty)
: renderer.RenderAsync(template, null, cancellationToken));
}
public void Render(TextWriter writer, ConsulState model, ITemplateRenderer renderer, PropertyBag properties)
{
Writer = writer;
Model = model;
Renderer = renderer;
Properties = properties ?? new PropertyBag();
ExecuteAsync().GetAwaiter().GetResult();
}
/// <summary>
/// Add a template engine for binding templates
/// </summary>
/// <param name="renderer"></param>
public TemplateManager Register(ITemplateRenderer renderer)
{
if (!this._templateRenderers.Contains(renderer))
{
this._templateRenderers.Add(renderer);
}
return(this);
}
public AccountEmailVerifySender(
IEmailSender emailSender,
ITemplateRenderer templateRenderer,
IStringLocalizer <AccountResource> stringLocalizer,
IAppUrlProvider appUrlProvider,
ICurrentTenant currentTenant)
: base(emailSender, templateRenderer, stringLocalizer, appUrlProvider, currentTenant)
{
}
/// <summary>
/// Creates a new instance of a <see cref="TemplateRendererConverter"/> class.
/// </summary>
/// <param name="fileRepository">The file repository.</param>
/// <param name="repository">The repository.</param>
/// <param name="renderer">The renderer.</param>
/// <param name="model">The model.</param>
/// <param name="context">The context.</param>
/// <param name="logger">A logger.</param>
public TemplateRendererConverter(IFileRepository fileRepository, ITemplateRepository repository, ITemplateRenderer renderer, IApplicationModel model, MigrationContext context, ILogger logger)
: base(nameof(TemplateRendererConverter), model, context, logger)
{
// Validate and set the member.
_fileRepository = fileRepository ?? throw new ArgumentNullException(nameof(fileRepository));
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_renderer = renderer ?? throw new ArgumentNullException(nameof(renderer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public EmailFactory(ITemplateRenderer renderer, ISender sender, IOptions <MailingSettings> settingsOptions)
{
_renderer = renderer ?? Email.DefaultRenderer;
_sender = sender ?? Email.DefaultSender;
var settings = settingsOptions?.Value.GuardIsNotNull(nameof(settingsOptions));
FromAddress = settings.FromAddress.GuardIsNotNull(nameof(settings.FromAddress));
FromName = settings.FromName.GuardIsNotNull(nameof(settings.FromName));
}
public void RenderCommonTemplate(string templateName, object toRender, Stream output)
{
Args.ThrowIfNull(AppConf, "AppConf");
Args.ThrowIfNull(AppConf.BamConf, "AppConf.BamConf");
Args.ThrowIfNull(AppConf.BamConf.Server, "AppConf.BamConf.Server");
BamServer server = AppConf.BamConf.Server;
ITemplateRenderer renderer = server.GetAppTemplateRenderer(AppConf.Name);
renderer.Render(templateName, toRender, output);
}
public string GetSubjectFromTemplate <T>(string emailName, T model, ITemplateRenderer renderer)
{
var template = "";
using (var reader = new StreamReader(File.OpenRead(GetSubjectTemplateFile(emailName))))
{
template = reader.ReadToEnd().Trim();
}
return(renderer.Parse(template, model, false));
}
public NotificationService(
IMessagingService messagingService,
ITemplateRenderer templateRenderer,
IOptions <NotificationOptions> optionAccessor,
ILogger <NotificationService> logger)
{
_messagingService = messagingService ?? throw new ArgumentNullException(nameof(messagingService));
_templateRenderer = templateRenderer ?? throw new ArgumentNullException(nameof(templateRenderer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_options = optionAccessor?.Value ?? throw new ArgumentNullException(nameof(optionAccessor));
}
public EmailConfirmationService(
UserManager<DbUser> userManager,
IAppUrlBuilder appUrlBuilder,
IEmailSender emailSender,
ITemplateRenderer templateRenderer)
{
_userManager = userManager;
_appUrlBuilder = appUrlBuilder;
_emailSender = emailSender;
_templateRenderer = templateRenderer;
}
/// <summary>
/// Creates a new Email instance using the given engines and mailing address.
/// </summary>
/// <param name="renderer">The template rendering engine</param>
/// <param name="sender">The email sending implementation</param>
/// <param name="emailAddress">Email address to send from</param>
/// <param name="name">Name to send from</param>
public Email(ITemplateRenderer renderer, ISender sender, string emailAddress, string name = "")
{
Data = new EmailData
{
FromAddress = new Address {
EmailAddress = emailAddress, Name = name
}
};
Renderer = renderer;
Sender = sender;
}
public UserSecurityCodeSender(
ISmsSender smsSender,
IEmailSender emailSender,
ITemplateRenderer templateRenderer,
IStringLocalizer <IdentityResource> localizer)
{
SmsSender = smsSender;
EmailSender = emailSender;
TemplateRenderer = templateRenderer;
Localizer = localizer;
}
public NotifyByEmailAutomationActionProvider(
IAutomationContextProvider automationContextProvider,
IRecipientResolver recipientResolver,
ITemplateRenderer templateRenderer,
IEmailSender emailSender)
{
_automationContextProvider = automationContextProvider;
_recipientResolver = recipientResolver;
_templateRenderer = templateRenderer;
_emailSender = emailSender;
}
public IEnumerable <ITemplatePreprocessor> LoadFromRenderer(ITemplateRenderer renderer)
{
var viewPath = renderer.Path;
var preproceesorPath = Path.ChangeExtension(viewPath, TemplateJintPreprocessor.Extension);
var res = _reader.GetResource(preproceesorPath);
var preprocessor = Load(new ResourceInfo(preproceesorPath, res), renderer.Name);
if (preprocessor != null)
{
yield return(preprocessor);
}
}
public SolutionGeneratorService(IGitService gitService, ITemplateRenderer templateRenderer,
IProjectTypeConverterService projectTypeConverterService, IReferencesService referencesService)
{
Argument.IsNotNull(() => gitService);
Argument.IsNotNull(() => templateRenderer);
Argument.IsNotNull(() => projectTypeConverterService);
Argument.IsNotNull(() => referencesService);
_gitService = gitService;
_templateRenderer = templateRenderer;
_projectTypeConverterService = projectTypeConverterService;
_referencesService = referencesService;
}
public ForgotPasswordHandler(
ILogger <ForgotPasswordHandler> logger,
UserManager <DbUser> userManager,
IAppUrlBuilder appUrlBuilder,
IEmailSender emailSender,
ITemplateRenderer templateRenderer)
{
_logger = logger;
_userManager = userManager;
_appUrlBuilder = appUrlBuilder;
_emailSender = emailSender;
_templateRenderer = templateRenderer;
}
public AccountMailer(
IEmailSender emailSender,
ITemplateRenderer templateRenderer,
IStringLocalizer <EmailingResource> stringLocalizer,
IAppUrlProvider appUrlProvider,
ICurrentTenant currentTenant)
{
EmailSender = emailSender;
StringLocalizer = stringLocalizer;
AppUrlProvider = appUrlProvider;
CurrentTenant = currentTenant;
TemplateRenderer = templateRenderer;
}
public SendInvitationsHandler(
IUnitOfWorkFactory unitOfWorkFactory,
IDbContextFactory dbContextFactory,
IAppUrlBuilder appUrlBuilder,
IEmailSender emailSender,
ITemplateRenderer templateRenderer)
{
_unitOfWorkFactory = unitOfWorkFactory;
_dbContextFactory = dbContextFactory;
_appUrlBuilder = appUrlBuilder;
_emailSender = emailSender;
_templateRenderer = templateRenderer;
}
public SolutionGeneratorService(IGitService gitService, ITemplateRenderer templateRenderer,
IProjectTypeConverterService projectTypeConverterService, IReferencesService referencesService)
{
Argument.IsNotNull(() => gitService);
Argument.IsNotNull(() => templateRenderer);
Argument.IsNotNull(() => projectTypeConverterService);
Argument.IsNotNull(() => referencesService);
_gitService = gitService;
_templateRenderer = templateRenderer;
_projectTypeConverterService = projectTypeConverterService;
_referencesService = referencesService;
}
public WorkflowServiceFacade(
ISecurityService accessItemService,
ITemplateRenderer renderer,
IWorkflowServiceResolver serviceResolver,
IWFObjectInitializer objectInitializer,
IWorkflowStrategyService strategyService,
IHelperJsonConverter helperJsonConverter)
{
_accessItemService = accessItemService;
_renderer = renderer;
_serviceResolver = serviceResolver;
_objectInitializer = objectInitializer;
_strategyService = strategyService;
_helperJsonConverter = helperJsonConverter;
}
public Template(string template, string templateName, string script, ResourceCollection resourceCollection)
{
if (string.IsNullOrEmpty(templateName)) throw new ArgumentNullException(nameof(templateName));
if (string.IsNullOrEmpty(template)) throw new ArgumentNullException(nameof(template));
Name = templateName;
var typeAndExtension = GetTemplateTypeAndExtension(templateName);
Extension = typeAndExtension.Item2;
Type = typeAndExtension.Item1;
IsPrimary = typeAndExtension.Item3;
_script = script;
_engine = CreateEngine(script);
_renderer = CreateRenderer(resourceCollection, templateName, template);
Resources = ExtractDependentResources();
}
public Template(string template, string templateName, string script, ResourceCollection resourceProvider)
{
if (string.IsNullOrEmpty(templateName)) throw new ArgumentNullException(nameof(templateName));
if (string.IsNullOrEmpty(template)) throw new ArgumentNullException(nameof(template));
Name = templateName;
var typeAndExtension = GetTemplateTypeAndExtension(templateName);
Extension = typeAndExtension.Item2;
Type = typeAndExtension.Item1;
IsPrimary = typeAndExtension.Item3;
_script = script;
if (resourceProvider != null)
{
if (Path.GetExtension(templateName).Equals(".liquid", StringComparison.OrdinalIgnoreCase))
{
_renderer = LiquidTemplateRenderer.Create(resourceProvider, template);
}
else
{
_renderer = new MustacheTemplateRenderer(resourceProvider, template);
}
}
Resources = ExtractDependentResources();
}
public ControllerWrapper(ContentItem item, ITemplateRenderer renderer)
{
ViewData = new ViewDataDictionary(item);
this.renderer = renderer;
this.item = item;
}
public MvcOnWebFormPartAdapter(ITemplateRenderer renderer)
{
this.renderer = renderer;
}
