/// <summary> /// </summary> /// <returns></returns> internal static string ConnectionList() { var fileName = FilePath + "\\ConnectionList.htm"; String content; var stream = new StreamReader(fileName); content = stream.ReadToEnd(); var connectionList = String.Empty; foreach (var item in RuntimeMongoDBContext._mongoConnectionConfigList.Values) { if (item.ReplSetName == String.Empty) { connectionList += "<li><a href = 'Connection?" + item.ConnectionName + "'>" + item.ConnectionName + "@" + (item.Host == String.Empty ? "localhost" : item.Host) + (item.Port == 0 ? String.Empty : ":" + item.Port) + "</a></li>" + Environment.NewLine; } else { connectionList += "<li><a href = 'Connection?" + item.ConnectionName + "'>" + item.ConnectionName + "</a></li>" + Environment.NewLine; } } var config = new TemplateServiceConfiguration(); //config.ReferenceResolver = (IReferenceResolver)((new UseCurrentAssembliesReferenceResolver()).GetReferences(null)); config.Debug = true; var ser = new TemplateService(config); ser.AddNamespace("MongoUtility.Core"); ser.AddNamespace("SystemUtility"); Razor.SetTemplateService(ser); content = Razor.Parse(content, new {SystemConfig.config.ConnectionList}); return content; }
static void Main(string[] agrs) { string template = "This is my sample template, Hello @Model.Name!"; string result = Razor.Parse(template, new { Name = "World" }); Console.WriteLine(result); var config = new TemplateServiceConfiguration { BaseTemplateType = typeof(CustomBaseTemplate<>), Resolver = new CustomTemplateResolver(), }; var service = new TemplateService(config); Razor.SetTemplateService(service); string template3 = "My name @Html.Raw(Model.HtmlString) @Model.HtmlString in UPPER CASE is @Model.Name"; string result3 = Razor.Parse(template3, new { Name = "Max", Email ="*****@*****.**", HtmlString = "<a href=\"/web/x.html\"> asd </a>" }); Console.WriteLine(result3); var context = new ExecuteContext(); var parsedView = Razor.Resolve("TestView").Run(context); Console.WriteLine(parsedView); Console.ReadKey(); }
static void StronglyTypedModel() { var welcomeEmailTemplatePath = Path.Combine(TemplateFolderPath, "WelcomeEmailStronglyTyped.cshtml"); // Generate the email body from our email template var stronglyTypedModel = new UserModel() { Name = "Sarah", Email = "*****@*****.**", IsPremiumUser = false }; var templateService = new TemplateService(); var emailHtmlBody = templateService.Parse(File.ReadAllText(welcomeEmailTemplatePath), stronglyTypedModel, null, null); // Send the email var email = new MailMessage() { Body = emailHtmlBody, IsBodyHtml = true, Subject = "Welcome (generated from strongly-typed model)" }; email.To.Add(new MailAddress(stronglyTypedModel.Email, stronglyTypedModel.Name)); // The From field will be populated from the app.config value by default var smtpClient = new SmtpClient(); smtpClient.Send(email); // In the real world, you'll probably want to use async version instead: // await smtpClient.SendMailAsync(email); }
//[Test] public void IntegrationTest() { const string templatePath = @"..\..\Test Templates\Modeled Basic Template.odt"; const string reportPath = @"..\..\Generated Reports\Very Basic Report.odt"; const string expectedReportPath = @"..\..\Expected Report Outputs\Very Basic Report.odt"; var templateFactory = new TemplateFactory(); var zipFactory = new ZipFactory(); var readerFactory = new StreamReaderWrapperFactory(); var zipHandlerService = new ZipHandlerService( readerFactory ); var buildOdfMetadataService = new BuildOdfMetadataService(); var xmlNamespaceService = new XmlNamespaceService(); var xDocumentParserService = new XDocumentParserService(); var odfHandlerService = new OdfHandlerService( zipFactory, zipHandlerService, buildOdfMetadataService, xmlNamespaceService, xDocumentParserService ); var templateService = new TemplateBuilderService( templateFactory, odfHandlerService, xmlNamespaceService, xDocumentParserService ); var document = File.ReadAllBytes( templatePath ); var template = templateService.BuildTemplate( document ); var razorTemplateService = new TemplateService(); var compileService = new CompileService( razorTemplateService ); compileService.Compile( template, "Template 1" ); var reportService = new ReportGeneratorService( new ZipFactory(), razorTemplateService ); using( var report = new FileStream( reportPath, FileMode.Create ) ) { reportService.BuildReport( template, new BasicModel {Name = "Fancypants McSnooterson"}, report ); } var diffs = GetDifferences( expectedReportPath, reportPath ); var thereAreDifferences = diffs.HasDifferences(); Assert.That( !thereAreDifferences ); }
public void TemplateService_CanSupportCustomActivator_WithUnity() { #if RAZOR4 Assert.Ignore("We need to add roslyn to generate custom constructors!"); #endif var container = new UnityContainer(); container.RegisterType(typeof(ITextFormatter), typeof(ReverseTextFormatter)); var config = new TemplateServiceConfiguration { Activator = new UnityTemplateActivator(container), BaseTemplateType = typeof(CustomTemplateBase<>) }; #pragma warning disable 0618 // Fine because we still want to test if using (var service = new TemplateService(config)) #pragma warning restore 0618 // Fine because we still want to test if { const string template = "<h1>Hello @Format(Model.Forename)</h1>"; const string expected = "<h1>Hello ttaM</h1>"; var model = new Person { Forename = "Matt" }; string result = service.Parse(template, model, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public String Render(TemplateModel templateModel) { var assembly = Assembly.GetExecutingAssembly(); string template; using (var sr = new StreamReader(assembly.GetManifestResourceStream("HotGlue.Generator.MVCRoutes.Templates.Routing.razor"))) { template = sr.ReadToEnd(); } var config = new TemplateServiceConfiguration { BaseTemplateType = typeof (JavaScriptRoutingTemplateBase<>) }; string result; try { using (var service = new TemplateService(config)) { Razor.SetTemplateService(service); result = Razor.Parse(template, templateModel); return result; } } catch (TemplateCompilationException ex) { foreach (var error in ex.Errors) { Console.WriteLine(error.ErrorText); } throw; } }
static void DynamicModel() { var welcomeEmailTemplatePath = Path.Combine(TemplateFolderPath, "WelcomeEmailDynamic.cshtml"); // Generate the email body from our email template // Note: the RazorEngine library supports using an anonymous type as a model without having to transform it to an Expando object first. var anonymousModel = new { Name = "Sarah", Email = "*****@*****.**", IsPremiumUser = false }; var templateService = new TemplateService(); var emailHtmlBody = templateService.Parse(File.ReadAllText(welcomeEmailTemplatePath), anonymousModel, null, null); // Send the email var email = new MailMessage() { Body = emailHtmlBody, IsBodyHtml = true, Subject = "Welcome (generated from dynamic model)" }; email.To.Add(new MailAddress(anonymousModel.Email, anonymousModel.Name)); // The From field will be populated from the app.config value by default var smtpClient = new SmtpClient(); smtpClient.Send(email); }
/// <summary> /// Creates an instance of a <see cref="TemplateService"/>. /// </summary> /// <param name="configuration">The <see cref="TemplateServiceConfigurationElement"/> that represents the configuration.</param> /// <param name="defaultNamespaces">The enumerable of namespaces to add as default.</param> /// <returns>A new instance of <see cref="TemplateService"/>.</returns> public static TemplateService CreateTemplateService(TemplateServiceConfigurationElement configuration, IEnumerable<string> defaultNamespaces = null) { if (configuration == null) throw new ArgumentNullException("configuration"); ILanguageProvider provider = null; MarkupParser parser = null; Type templateBaseType = null; if (!string.IsNullOrEmpty(configuration.LanguageProvider)) provider = (ILanguageProvider)GetInstance(configuration.LanguageProvider); if (!string.IsNullOrEmpty(configuration.MarkupParser)) parser = (MarkupParser)GetInstance(configuration.MarkupParser); if (!string.IsNullOrEmpty(configuration.TemplateBase)) templateBaseType = GetType(configuration.TemplateBase); var namespaces = configuration.Namespaces .Cast<NamespaceConfigurationElement>() .Select(n => n.Namespace); if (defaultNamespaces != null) { namespaces = defaultNamespaces .Concat(namespaces) .Distinct(); } var service = new TemplateService(provider, templateBaseType, parser); foreach (string ns in namespaces) service.Namespaces.Add(ns); return service; }
public static void Main(string[] args) { if (args.Length >= 2) { var fileEncoding = Encoding.UTF8; var config = new FluentTemplateServiceConfiguration(c => c.WithEncoding(RazorEngine.Encoding.Raw)); using (var myConfiguredTemplateService = new TemplateService(config)) { RazorEngine.Razor.SetTemplateService(myConfiguredTemplateService); if (args.Length > 3 && args[2] == "-r") { Assembly.LoadFrom(args[3]); } string razorContent = File.ReadAllText(args[0], fileEncoding); string outputContent = RazorEngine.Razor.Parse(razorContent); File.WriteAllText(args[1], outputContent, fileEncoding); } } else { Console.WriteLine("Usage: RazorParser fileName.cshtml output.[js|ts|css|less] -r Referenced.dll"); } Console.WriteLine("Done"); }
private static string GetEmailBody(string template, object data) { string path = HttpContext.Current.Server .MapPath("~/") + template; TemplateService templateService = new TemplateService(); var emailHtmlBody = templateService.Parse(File.ReadAllText(path), data, null, null); return PreMailer.Net.PreMailer.MoveCssInline(emailHtmlBody, true).Html; }
private void ProcessSubContent(TemplateService service, Match match, dynamic model) { var subName = match.Groups[1].Value; // got an include/layout match? var subContent = GetContent(subName); // go get that template then ProcessContent(subContent, service, model); // recursively process it service.GetTemplate(subContent, model, subName); // then add it to the service }
public void TestEnginePreparation() { TemplateService templateService = new TemplateService(); templateService.PrepareEngine += new System.Action<Jint.Engine>(templateService_PrepareEngine); Assert.AreEqual("pwet", templateService.Process("<% write('pwet'); %>")); templateService = new TemplateService(TemplateMode.HtmlEscaped); templateService.PrepareEngine += new System.Action<Jint.Engine>(templateService_PrepareEngine); Assert.AreEqual("pwet", templateService.Process("<% write2('pwet'); %>")); }
public void Issue11_TemplateServiceShouldCompileModellessTemplate() { using (var service = new TemplateService()) { const string template = "<h1>Hello World</h1>"; service.Compile(template, null, "issue11"); } }
protected override async Task OnExecute() { var dc = GetDatacenter(required: true); var service = dc.GetService(Service); if (service == null) { await Console.WriteErrorLine(Strings.Config_GenerateCommand_NoSuchService, Service, dc.FullName); return; } // Get the config template for this service if (dc.Environment.ConfigTemplates == null) { await Console.WriteErrorLine(Strings.Config_GenerateCommand_NoTemplateSource, dc.Environment.FullName); } else { if (!String.Equals(dc.Environment.ConfigTemplates.Type, FileSystemConfigTemplateSource.AbsoluteAppModelType, StringComparison.OrdinalIgnoreCase)) { await Console.WriteErrorLine(Strings.Config_GenerateCommand_UnknownConfigTemplateSourceType, dc.Environment.ConfigTemplates.Type); } var configSource = new FileSystemConfigTemplateSource(dc.Environment.ConfigTemplates.Value); var configTemplate = configSource.ReadConfigTemplate(service); if (String.IsNullOrEmpty(configTemplate)) { await Console.WriteErrorLine(Strings.Config_GenerateCommand_NoTemplate, service.FullName); } else { var secrets = await GetEnvironmentSecretStore(Session.CurrentEnvironment); // Render the template var engine = new TemplateService(new TemplateServiceConfiguration() { BaseTemplateType = typeof(ConfigTemplateBase), Language = Language.CSharp }); await Console.WriteInfoLine(Strings.Config_GenerateCommand_CompilingConfigTemplate, service.FullName); engine.Compile(configTemplate, typeof(object), "configTemplate"); await Console.WriteInfoLine(Strings.Config_GenerateCommand_ExecutingTemplate, service.FullName); string result = engine.Run("configTemplate", new ConfigTemplateModel(secrets, service), null); // Write the template if (String.IsNullOrEmpty(OutputFile)) { await Console.WriteDataLine(result); } else { File.WriteAllText(OutputFile, result); await Console.WriteInfoLine(Strings.Config_GenerateCommand_GeneratedConfig, OutputFile); } } } }
public string Parse() { TemplateService templateService = new TemplateService(); string templateName = "TestTemplate"; string body = "@model dynamic" + Environment.NewLine + "<html>Hello, @Model.CustomerName!</html>"; dynamic model = new { CustomerName = "Girish" }; var result = templateService.Parse(body, model, null, templateName); return result; }
public void TestFixtureSetUp() { var templateService = new TemplateService(); var embeddedEmailResourceProvider = new EmbeddedEmailResourceProvider( typeof(SimpleEmailModel).Assembly, "Email.RazorTemplates", "Email.Images", "en-AU"); _emailTemplateInitializer = new RazorEmailTemplateInitializer(embeddedEmailResourceProvider, templateService); _emailFormatter = new RazorEmailFormatter(templateService, _emailTemplateInitializer); }
public KompService( ComponentService componentService, ConfigService configService, TemplateService templateService, AddOnService addOnService) { _componentService = componentService; _configService = configService; _templateService = templateService; _addOnService = addOnService; }
public void TestScriptTransformation() { TemplateService templateService = new TemplateService(TemplateMode.HtmlEscaped); templateService.TransformFoundScript += new Func<string, string>(templateService_TransformFoundScript); Assert.AreEqual("pwet", templateService.Process("<% if(1<2) write("pwet"); %>")); //Assert.AreEqual("pwet", templateService.Process("<% if(1<2) %< <%= 'pwet' %>")); templateService = new TemplateService(TemplateMode.Standard); templateService.TransformFoundScript += new Func<string, string>(templateService_TransformFoundScript); Assert.AreEqual("pwet", templateService.Process("<% if(2>1) { %><%= 'pwet' %><% } %><% else if(2>1) { %><%= 'pwic' %><% } %>")); Assert.AreEqual("pwic", templateService.Process("<% if(1>2) { %><%= 'pwet' %><% } %><% else if(2>1) { %><%= 'pwic' %><% } %>")); }
public ActionResult Edit(int id) { var service = new TemplateService(); var template = service.GetTemplateById(id); var model = new TemplateEdit { TemplateId = template.Id, Name = template.Name, }; return(View(model)); }
public TemplateController( ILogger <AdminController> logger, IIdentityResolver identityResolver, TemplateService templateService, IHypervisorService podService, IHubContext <TopologyHub, ITopoEvent> hub ) : base(logger, identityResolver) { _templateService = templateService; _pod = podService; _hub = hub; }
// GET: Create public ActionResult Create() { var service = new TemplateService(); var templates = service.GetTemplates(); List <SelectListItem> templateSelect = templates.Select(t => new SelectListItem { Value = t.Id.ToString(), Text = t.Name }).ToList(); ViewBag.Templates = templateSelect; return(View()); }
public void TemplateService_CanParseMultipleTemplatesInParallel_WitNoModels() { using (var service = new TemplateService()) { const string template = "<h1>Hello World</h1>"; var templates = Enumerable.Repeat(template, 10); var results = service.ParseMany(templates, true); Assert.That(templates.SequenceEqual(results), "Rendered templates do not match expected."); } }
public void CodeInspector_SupportsAddingCustomInspector() { var config = new TemplateServiceConfiguration(); config.CodeInspectors.Add(new ThrowExceptionCodeInspector()); using (var service = new TemplateService(config)) { const string template = "Hello World"; Assert.Throws<InvalidOperationException>(() => service.Parse(template)); } }
public void TemplateService_CanParseMultipleTemplatesInParallel_WitNoModels() { using (var service = new TemplateService()) { const string template = "<h1>Hello World</h1>"; var templates = Enumerable.Repeat(template, 10); var results = service.ParseMany(templates, null, null, null, true); Assert.That(templates.SequenceEqual(results), "Rendered templates do not match expected."); } }
protected override async void Execute() { EnsureApplicationResources(); TelemetryService.Instance.Init(); //check for new version await TelemetryService.Instance.CheckForUpdates(true); TelemetryService.Instance.SendCrashes(false); var pathToTempFolder = CreateTempPackageFolder(); try { OpenFileDialog fileDialog = new OpenFileDialog(); fileDialog.Filter = @"Transit Project Package Files (*.ppf)|*.ppf"; var dialogResult = fileDialog.ShowDialog(); if (dialogResult == DialogResult.OK) { var path = fileDialog.FileName; var packageService = new PackageService(); var package = await packageService.OpenPackage(path, pathToTempFolder); var templateService = new TemplateService(); var templateList = templateService.LoadProjectTemplates(); var packageModel = new PackageModel { Name = package.Name, Description = package.Description, StudioTemplates = templateList, SourceLanguage = package.SourceLanguage, TargetLanguage = package.TargetLanguage, SourceFiles = package.SourceFiles, TargetFiles = package.TargetFiles }; StarTransitMainWindow window = new StarTransitMainWindow(packageModel); window.ShowDialog(); } } catch (Exception e) { TelemetryService.Instance.HandleException(e); } finally { if (Directory.Exists(pathToTempFolder)) { Directory.Delete(pathToTempFolder, true); } } }
public void TemplateService_CanParseSimpleTemplate_WithNoModel() { using (var service = new TemplateService()) { const string template = "<h1>Hello World</h1>"; const string expected = template; string result = service.Parse(template, null, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void TemplateService_CanParseTildeInTemplate_UsingHtmlEncoding() { using (var service = new TemplateService()) { const string template = "<a href=\"~/index.html\">@Model.String</a>"; const string expected = "<a href=\"/index.html\">Matt</a>"; var model = new { String = "Matt" }; string result = service.Parse(template, model, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
static Render() { var config = new TemplateServiceConfiguration { BaseTemplateType = typeof(HtmlTemplateBase<>) }; var service = new TemplateService(config); Razor.SetTemplateService(service); Razor.Compile(Resources.FormattedSingleFile(), "singleFile"); Razor.Compile(Resources.Directory(), "directory"); }
public static void SendEmail(SubscriptionResult Subscription, IApplicationConfigRepository applicationConfigRepository, IEmailTemplateRepository emailTemplateRepository) { MailMessage mail = new MailMessage(); string FromMail = applicationConfigRepository.GetValuefromApplicationConfig("SMTPFromEmail"); string password = applicationConfigRepository.GetValuefromApplicationConfig("SMTPPassword"); string username = applicationConfigRepository.GetValuefromApplicationConfig("SMTPUserName"); string Subject = emailTemplateRepository.GetSubject(Subscription.SaasSubscriptionStatus.ToString()); bool smtpSsl = bool.Parse(applicationConfigRepository.GetValuefromApplicationConfig("SMTPSslEnabled")); mail.From = new MailAddress(FromMail); mail.Subject = Subject; string body = TemplateService.ProcessTemplate(Subscription, emailTemplateRepository, applicationConfigRepository); mail.Body = body; mail.IsBodyHtml = true; if (!string.IsNullOrEmpty(emailTemplateRepository.GetToRecipients(Subscription.SaasSubscriptionStatus.ToString()))) { string[] ToEmails = (emailTemplateRepository.GetToRecipients(Subscription.SaasSubscriptionStatus.ToString())).Split(';'); foreach (string Multimailid in ToEmails) { mail.To.Add(new MailAddress(Multimailid)); } } if (!string.IsNullOrEmpty(emailTemplateRepository.GetCCRecipients(Subscription.SaasSubscriptionStatus.ToString()))) { string[] CcEmails = (emailTemplateRepository.GetCCRecipients(Subscription.SaasSubscriptionStatus.ToString())).Split(';'); foreach (string Multimailid in CcEmails) { mail.CC.Add(new MailAddress(Multimailid)); } } if (!string.IsNullOrEmpty(emailTemplateRepository.GetBccRecipients(Subscription.SaasSubscriptionStatus.ToString()))) { string[] BccEmails = (emailTemplateRepository.GetBccRecipients(Subscription.SaasSubscriptionStatus.ToString())).Split(';'); foreach (string Multimailid in BccEmails) { mail.Bcc.Add(new MailAddress(Multimailid)); } } SmtpClient smtp = new SmtpClient(); smtp.Host = applicationConfigRepository.GetValuefromApplicationConfig("SMTPHost"); smtp.Port = int.Parse(applicationConfigRepository.GetValuefromApplicationConfig("SMTPPort")); smtp.UseDefaultCredentials = false; smtp.Credentials = new NetworkCredential( username, password); smtp.EnableSsl = smtpSsl; smtp.Send(mail); }
public void TemplateService_CanParseSimpleTemplate_WithNoModel() { using (var service = new TemplateService()) { const string template = "<h1>Hello World</h1>"; const string expected = template; string result = service.Parse(template); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void Issue27_StreamLiningTheITemplateServiceApi_CreateTemplates() { string[] razorTemplates; Type[] templateTypes; int index; using (var service = new TemplateService()) { // Success case razorTemplates = new string[] { "Template1", "Template2", "Template3" }; templateTypes = new Type[] { null, null, null }; IEnumerable <ITemplate> instances = service.CreateTemplates(razorTemplates, templateTypes, null, false); index = 0; foreach (ITemplate instance in instances) { string expected = razorTemplates[index]; string result = service.Run(instance, null); Assert.That(result == expected, "Result does not match expected: " + result); index++; } // No razorTemplates or templateTypes provided Assert.Throws <ArgumentException>(() => { service.CreateTemplates(null, null, null, false); }); // Unbalanced razorTemplates/templateTypes (templateTypes to small) Assert.Throws <ArgumentException>(() => { razorTemplates = new string[] { "Template1", "Template2", "Template3" }; templateTypes = new Type[] { null, null }; service.CreateTemplates(razorTemplates, templateTypes, null, false); }); // Unbalanced razorTemplates/templateTypes (templateTypes too large) Assert.Throws <ArgumentException>(() => { razorTemplates = new string[] { "Template1", "Template2", "Template3" }; templateTypes = new Type[] { null, null, null, null }; service.CreateTemplates(razorTemplates, templateTypes, null, false); }); // Unbalanced razorTemplates/templateTypes (razorTemplates and templateTypes are NULL) Assert.Throws <ArgumentException>(() => { razorTemplates = new string[] { "Template1", "Template2", null }; templateTypes = new Type[] { null, null, null }; service.CreateTemplates(razorTemplates, templateTypes, null, false); }); } }
/// <summary> /// Configures the templating engine. /// </summary> private static void Configure() { var config = RazorEngineConfigurationSection.GetConfiguration(); if (config != null) { if (!string.IsNullOrWhiteSpace(config.Factory)) { SetCompilerServiceFactory(config.Factory); } else { CompilerServiceFactory = new DefaultCompilerServiceFactory(); } if (config.TemplateServices.Count > 0) { string @default = string.IsNullOrWhiteSpace(config.TemplateServices.Default) ? null : config.TemplateServices.Default; foreach (TemplateServiceConfigurationElement serviceConfig in config.TemplateServices) { string name = serviceConfig.Name; var service = ConfigurationServices.CreateTemplateService(serviceConfig);; ConfigurationServices.AddNamespaces(service, config.Namespaces); if (name == @default) { DefaultTemplateService = service; } Services.Add(name, service); } } if (DefaultTemplateService == null) { DefaultTemplateService = new TemplateService(CompilerServiceFactory.CreateCompilerService()); ConfigurationServices.AddNamespaces(DefaultTemplateService, config.Namespaces); } if (!string.IsNullOrWhiteSpace(config.Activator)) { DefaultTemplateService.SetActivator(ConfigurationServices.CreateInstance <IActivator>(config.Activator)); } } else { ConfigureDefault(); } }
public void ReplaceText_OneVariable() { string baseTemplate = "Hello $name$"; var dictVariables = new Dictionary <string, string> { { "name", "Denis" } }; string expected = "Hello Denis"; string result = TemplateService.ApplyTextTemplateAsync(baseTemplate, dictVariables).Result; Assert.Equal(expected, result); }
public void TemplateService_CanParseSimpleTemplate_WithAnonymousModel() { using (var service = new TemplateService()) { const string template = "<h1>Hello @Model.Forename</h1>"; const string expected = "<h1>Hello Matt</h1>"; var model = new { Forename = "Matt" }; string result = service.Parse(template, model); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void FillEnumValueTemplate_ValuesGiven_TemplateFilledWithValues() { _internalStorage.GetEmbeddedResource("TypeGen.Core.Templates.EnumValue.tpl") .Returns("$tg{name} | $tg{number}"); var templateService = new TemplateService(_internalStorage) { GeneratorOptions = new GeneratorOptions() }; string actual = templateService.FillEnumValueTemplate("a", 42); Assert.Equal("a | 42", actual); }
public static string GenerateOutput(ExpandoObject model, string template) { var config = new FluentTemplateServiceConfiguration( c => c.WithEncoding(RazorEngine.Encoding.Raw)); string result; using (var service = new TemplateService(config)) { result = service.Parse(template, model); } return result; }
public void CodeInspector_SupportsAddingCustomInspector() { var config = new TemplateServiceConfiguration(); config.CodeInspectors.Add(new ThrowExceptionCodeInspector()); using (var service = new TemplateService(config)) { const string template = "Hello World"; Assert.Throws <InvalidOperationException>(() => service.Parse(template)); } }
public void FillClassPropertyTemplate_ValuesGiven_TemplateFilledWithValues() { _internalStorage.GetEmbeddedResource("TypeGen.Core.Templates.ClassProperty.tpl") .Returns("$tg{accessor} | $tg{name} | $tg{type}"); var templateService = new TemplateService(_internalStorage) { GeneratorOptions = new GeneratorOptions() }; string actual = templateService.FillClassPropertyTemplate("a", "B", "c"); Assert.Equal("a | B | c", actual); }
public void FillIndexExportTemplate_ValuesGiven_TemplateFilledWithValues() { _internalStorage.GetEmbeddedResource("TypeGen.Core.Templates.IndexExport.tpl") .Returns("$tg{filename}"); var templateService = new TemplateService(_internalStorage) { GeneratorOptions = new GeneratorOptions() }; string actual = templateService.FillIndexExportTemplate("a"); Assert.Equal("a", actual); }
public void FillImportTemplate_ValuesGiven_TemplateFilledWithValues(string typeAlias, string expectedResult) { _internalStorage.GetEmbeddedResource("TypeGen.Core.Templates.Import.tpl") .Returns("$tg{name} | $tg{aliasText} | $tg{path}"); var templateService = new TemplateService(_internalStorage) { GeneratorOptions = new GeneratorOptions() }; string actual = templateService.FillImportTemplate("a", typeAlias, "c"); Assert.Equal(expectedResult, actual); }
public void RazorEngineHost_SupportsModelSpan_UsingCSharpCodeParser() { using (var service = new TemplateService()) { const string template = "@model List<RazorEngine.Tests.TestTypes.Person>\[email protected]"; const string expected = "1"; var model = new List<Person> { new Person() { Forename = "Matt", Age = 27 } }; string result = service.Parse(template, (object)model); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void TemplateBase_CanUseRawOutput_WithHtmlEncoding() { using (var service = new TemplateService()) { const string template = "<h1>Hello @Raw(Model.Name)</h1>"; const string expected = "<h1>Hello <</h1>"; var model = new { Name = "<" }; string result = service.Parse(template, model); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void TemplateService_CanParseSimpleTemplate_WithIteratorModel() { using (var service = new TemplateService()) { const string template = "@foreach (var i in Model) { @i }"; const string expected = "One Two Three"; var model = CreateIterator("One ", "Two ", "Three"); string result = service.Parse(template, model, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void GetAvailableTemplates_returnsTemplates() { var templates = new TemplateService(_loggerFactory.CreateLogger <TemplateService>()) .GetAvailableTemplates(); Assert.NotNull(templates); Assert.NotEmpty(templates); Assert.Contains(templates, x => x.ShortName == "Steeltoe-WebApi" && x.TemplateVersion == TemplateVersion.V2); Assert.Contains(templates, x => x.ShortName == "Steeltoe-WebApi" && x.TemplateVersion == TemplateVersion.V3); Assert.Contains(templates, x => x.ShortName == "Steeltoe-React" && x.TemplateVersion == TemplateVersion.V2); Assert.Contains(templates, x => x.ShortName == "Steeltoe-React" && x.TemplateVersion == TemplateVersion.V3); }
public void Generic_settings_from_parameter_names_should_be_valid() { var templates = TemplateService.Get(); foreach (var template in templates) { var validSettings = template.ParameterNames .ToDictionary(p => p, p => (decimal)10); var validateResult = TemplateService.Validate(template.Id, validSettings); Assert.True(validateResult.IsSuccess); } }
public void FillClassTemplate_ValuesGiven_TemplateFilledWithValues() { _internalStorage.GetEmbeddedResource("TypeGen.Core.Templates.Class.tpl") .Returns("$tg{imports} | $tg{name} | $tg{extends} | $tg{properties} | $tg{customHead} | $tg{customBody}"); var templateService = new TemplateService(_internalStorage) { GeneratorOptions = new GeneratorOptions() }; string actual = templateService.FillClassTemplate("a", "B", "c", "D", "e", "F"); Assert.Equal("a | B | c | D | e | F", actual); }
public void Issue16_LastNullValueShouldReturnEmptyString() { using (var service = new TemplateService()) { const string template = "<h1>Hello @Model.Person.Forename</h1>"; const string expected = "<h1>Hello </h1>"; var model = new { Person = new Person { Forename = null } }; string result = service.Parse(template, model, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public static string RenderTemplate(string templateName, object model = null, DynamicViewBag viewBag = null) { var templateFolderPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Views\Email"); var templateService = new TemplateService(); var confirmationTemplatePath = Path.Combine(templateFolderPath, templateName); return(templateService.Parse( File.ReadAllText(confirmationTemplatePath), model, viewBag, "TemplateCache" )); }
public void TemplateBase_CanUseRawOutput_WithHtmlEncoding() { using (var service = new TemplateService()) { const string template = "<h1>Hello @Raw(Model.Name)</h1>"; const string expected = "<h1>Hello <</h1>"; var model = new { Name = "<" }; string result = service.Parse(template, model, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void ReplaceText_NoVariables() { string baseTemplate = "Hello!"; var dictVariables = new Dictionary <string, string> { }; string expected = "Hello!"; string result = TemplateService.ApplyTextTemplateAsync(baseTemplate, dictVariables).Result; Assert.Equal(expected, result); }
public void TemplateService_ShouldEnableNullableValueTypes() { using (var service = new TemplateService()) { const string template = "<h1>Hello @Model.Number</h1>"; const string expected = "<h1>Hello </h1>"; var model = new { Number = (int?)null }; string result = service.Parse(template, model, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public ActionResult Edit(int id) { var service = new TemplateService(); var property = service.GetTemplatePropById(id); var model = new TemplatePropEdit { PropertyId = property.Id, PropertyName = property.PropertyName, TemplateId = property.TemplateId }; return(View(model)); }
public void ReplaceText_NumberOfVariablesDoesNotMatch_MoreVariables() { string baseTemplate = "Hello $name$. Your account balance is $$balance$. Thanks $name$!"; var dictVariables = new Dictionary <string, string> { { "name", "Denis" } }; Assert.ThrowsAsync <ArgumentException>(() => TemplateService.ApplyTextTemplateAsync(baseTemplate, dictVariables) ); }
public void TemplateService_CanParseSimpleTemplate_WithAnonymousModel() { using (var service = new TemplateService()) { const string template = "<h1>Hello @Model.Forename</h1>"; const string expected = "<h1>Hello Matt</h1>"; var model = new { Forename = "Matt" }; string result = service.Parse(template, model, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void TemplateService_CanParseSimpleHelperTemplate_UsingHtmlEncoding() { using (var service = new TemplateService()) { const string template = "<h1>Hello @NameHelper()</h1>@helper NameHelper() { @Model.String }"; const string expected = "<h1>Hello Matt & World</h1>"; var model = new { String = "Matt & World" }; string result = service.Parse(template, model, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void Issue7_ViewBagShouldPersistThroughLayout() { using (var service = new TemplateService()) { const string layoutTemplate = "<h1>@ViewBag.Title</h1>@RenderSection(\"Child\")"; const string childTemplate = "@{ Layout = \"Parent\"; ViewBag.Title = \"Test\"; }@section Child {}"; service.Compile(layoutTemplate, null, "Parent"); string result = service.Parse(childTemplate, null, null, null); Assert.That(result.StartsWith("<h1>Test</h1>")); } }
public void TemplateBase_CanRenderWithInclude_SimpleInclude() { using (var service = new TemplateService()) { const string child = "<div>Content from child</div>"; const string template = "@Include(\"Child\")"; const string expected = "<div>Content from child</div>"; service.GetTemplate(child, "Child"); string result = service.Parse(template); Assert.That(result == expected, "Result does not match expected: " + result); } }
public void FluentTemplateServiceConfiguration_CanConfigureTemplateService_WithSpecificCodeLanguage() { var config = new FluentTemplateServiceConfiguration( c => c.WithCodeLanguage(Language.VisualBasic)); using (var service = new TemplateService(config)) { const string template = "@Code Dim name = \"Matt\" End Code\n@name"; const string expected = "\nMatt"; string result = service.Parse(template, null, null, null); Assert.That(result == expected, "Result does not match expected: " + result); } }
public string BuildContentResult(string page, string id) { using (var service = new TemplateService()) { // get the top level razor template, e.g. "product" // equivalent of "product.cshtml" var content = GetContent(page); var data = GetData(id); ProcessContent(content, service, data); var result = service.Parse(content, data, null, page); return result; } }