public void SimplestRazorEngineWithModelTest()
{
string template = @"@model Person
Hello World @Model.Name. Time is: @DateTime.Now";
var host = new RazorEngine<RazorTemplateBase>();
host.AddNamespace("RazorHostingTests");
string result = host.RenderTemplate(template, new Person { Name = "Joe Doe" });
Assert.IsNotNull(result, host.ErrorMessage);
Assert.IsTrue(result.Contains("Joe Doe"));
Console.WriteLine(result);
}
/// <summary>
/// Routine that returns an instance of the RazorHost hosted
/// in a separate AppDomain. Checks for existance of the host
/// and creates only if needed. You need to cache the host
/// to avoid excessive resource use.
/// </summary>
/// <returns></returns>
private RazorEngine<RazorTemplateBase> CreateHost()
{
if (this.Host != null)
return this.Host;
// Use Static Methods - no error message if host doesn't load
//this.Host = RazorHostFactory<RazorTemplateBase>.CreateRazorHost();
this.Host = RazorEngineFactory<RazorTemplateBase>.CreateRazorHostInAppDomain();
if (this.Host == null)
{
MessageBox.Show("Unable to load Razor Template Host",
"Razor Hosting", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
// Use instance methods
//RazorEngineFactory<RazorTemplateBase> factory = new RazorEngineactory<RazorTemplateBase>();
//this.Host = factory.GetRazorHostInAppDomain();
//if (this.Host == null)
//{
// MessageBox.Show("Unable to load Razor Template Host\r\n" + factory.ErrorMessage,
// "Razor Hosting", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
//}
return this.Host;
}
public void CreateFile(int[] campIDList, int[] testList)
{
if (campIDList == null || testList == null)
{ }
else
{
foreach (var item in campIDList)
{
RedBloodDataContext db = new RedBloodDataContext();
var DINs = db.Donations.Where(r => r.CampaignID == item && r.Status == Donation.StatusX.HasPack_UnLock)
.Select(r => new { r.DIN, r.CollectedDate })
.ToList()
.Select(r => new { r.DIN, Date = r.CollectedDate.ToStringyyyyMMdd() })
.ToList();
var cam = db.Campaigns.SingleOrDefault(r => r.ID == item);
var camID = "";
var camGeo1 = "";
if (cam == null)
{ }
else
{
camID = cam.ID.ToString();
camGeo1 = cam.HostOrg.Geo1.Name;
}
string template = File.ReadAllText(HttpContext.Current.Server.MapPath("~/BLL/CobasIT_Temp1.cshtml"));
foreach (var i in DINs)
{
var timeStamp = DateTime.Now.ToString("yyyyMMddHHmmss");
var data = new
{
//DINs = new List<string> { "=" + i.DIN + "00" },
DINs = new List<string> { i.DIN },
Date = i.Date,
TestList = testList,
Time = timeStamp,
CamID = camID,
CamGeo1 = camGeo1.RemoveDiacritics()
};
string result = Razor.Parse(template, data);
string namePat = "{0}\\ORDER{1}_{2}";
var file = string.Format(namePat + ".dat", AppConfigBLL.CobasIT_Temp_Order, timeStamp, i.DIN);
File.WriteAllText(file, result);
}
}
Ftp.FtpOrder2HisAndLabCom();
}
}
private static RazorEngine<RazorTemplateBase> CreateHost()
{
var host = new RazorEngine<RazorTemplateBase>();
// add this assembly
host.AddAssemblyFromType(typeof(ResultsParser));
host.AddAssemblyFromType(typeof (AppConfiguration));
return host;
}
public string Render(List<LogItem> logs, string title)
{
var engine = new RazorEngine<RazorTemplateBase>();
var html = engine.RenderTemplate(Resources.HtmlLogTemplate, new[] { typeof(Browser).Assembly.Location, "System.Web.dll" }, new RazorModel {
CaptureDate = DateTime.UtcNow,
TotalDuration = logs.Count == 0 ? TimeSpan.MinValue : logs.Last().ServerTime - logs.First().ServerTime,
Title = title,
Logs = logs,
RequestsCount = logs.Count(l => l is HttpRequestLog)
});
return html ?? engine.ErrorMessage;
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
if (!(string.IsNullOrEmpty(RazorScriptFile)))
{
var razorEngine = new RazorEngine(RazorScriptFile, ModuleContext, LocalResourceFile);
var writer = new StringWriter();
razorEngine.Render(writer);
Controls.Add(new LiteralControl(HttpUtility.HtmlDecode(writer.ToString())));
}
}
public void SimplestRazorEngineTest()
{
string template = @"Hello World @Model.Name. Time is: @DateTime.Now";
template = Templates.BasicTemplateStringWithPersonModel;
var host = new RazorEngine();
string result = host.RenderTemplate(template, new Person { Name = "Joe Doe" });
Assert.IsNotNull(result,host.ErrorMessage);
Assert.IsTrue(result.Contains("Joe Doe"));
Console.WriteLine(result);
Console.WriteLine(host.LastGeneratedCode);
}
private RazorEngine<RazorTemplateBase> CreateHost()
{
if (this.Engine != null)
return this.Engine;
this.Engine = new RazorEngine<RazorTemplateBase>();
// Use Static Methods - no error message if host doesn't load
//this.Host = RazorEngineFactory<RazorTemplateBase>.CreateRazorHost();
if (this.Engine == null)
throw new ApplicationException("Unable to load Razor Template Host");
return this.Engine;
}
protected override void OnStartup(StartupEventArgs e)
{
var cul = new CultureInfo("ar-EG");
Thread.CurrentThread.CurrentCulture = cul;
Thread.CurrentThread.CurrentUICulture = cul;
Data.Core.StartUp_Engine();
if (string.IsNullOrWhiteSpace(Phony.Properties.Settings.Default.PrimaryColor))
{
Phony.Properties.Settings.Default.PrimaryColor = "Teal";
Phony.Properties.Settings.Default.Save();
}
if (string.IsNullOrWhiteSpace(Phony.Properties.Settings.Default.AccentColor))
{
Phony.Properties.Settings.Default.AccentColor = "Yellow";
Phony.Properties.Settings.Default.Save();
}
try
{
Helpers.ThemeHelper.ApplyBase(Phony.Properties.Settings.Default.IsDarkTheme);
Helpers.ThemeHelper.ApplyPrimary(Helpers.ThemeHelper.Swatches.First(x => x.Name == Phony.Properties.Settings.Default.PrimaryColor));
Helpers.ThemeHelper.ApplyAccent(Helpers.ThemeHelper.Swatches.First(x => x.Name == Phony.Properties.Settings.Default.AccentColor));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
// Init Razor Engine to be faster at first load
new Thread(new ThreadStart(() =>
{
IRazorEngine razorEngine = new RazorEngine();
IRazorEngineCompiledTemplate template = razorEngine.Compile("Hello @Model.Name");
string result = template.Run(new
{
Name = "RazorEngine"
});
System.Diagnostics.Debug.WriteLine(result);
})).Start();
base.OnStartup(e);
}
public void TestSaveToStream()
{
RazorEngine razorEngine = new RazorEngine();
IRazorEngineCompiledTemplate initialTemplate = razorEngine.Compile("Hello @Model.Name");
MemoryStream memoryStream = new MemoryStream();
initialTemplate.SaveToStream(memoryStream);
memoryStream.Position = 0;
IRazorEngineCompiledTemplate loadedTemplate = RazorEngineCompiledTemplate.LoadFromStream(memoryStream);
string initialTemplateResult = initialTemplate.Run(new { Name = "Alex" });
string loadedTemplateResult = loadedTemplate.Run(new { Name = "Alex" });
Assert.AreEqual(initialTemplateResult, loadedTemplateResult);
}
public void Render(Schema schema)
{
_host = RazorEngineFactory<RazorTemplateBase>.CreateRazorHost();
var document = _host.RenderTemplate(
Resources.DocumentTemplate,
new string[] { "SQLDocumentor.Model.dll", "SQLDocumentor.RazorRenderer.dll" },
schema);
using (var sw = new StreamWriter("detail_razor.html"))
{
sw.Write(document);
sw.Close();
}
Process.Start("detail_razor.html");
}
public void GetIdentifier_ReturnsNull_ForEmptyRelativePath()
{
// Arrange
var sourceDocument = RazorSourceDocument.Create("content", new RazorSourceDocumentProperties("Test.cshtml", string.Empty));
var codeDocument = RazorCodeDocument.Create(sourceDocument);
var feature = new DefaultMetadataIdentifierFeature()
{
Engine = RazorEngine.Create(),
};
// Act
var result = feature.GetIdentifier(codeDocument, sourceDocument);
// Assert
Assert.Null(result);
}
public void Execute_NoOps_ForDesignTime()
{
// Arrange
var irDocument = new DocumentIntermediateNode
{
DocumentKind = MvcViewDocumentClassifierPass.MvcViewDocumentKind,
Options = RazorCodeGenerationOptions.CreateDesignTimeDefault(),
};
var builder = IntermediateNodeBuilder.Create(irDocument);
var @namespace = new NamespaceDeclarationIntermediateNode
{
Content = "SomeNamespace",
Annotations =
{
[CommonAnnotations.PrimaryNamespace] = CommonAnnotations.PrimaryNamespace
},
};
builder.Push(@namespace);
var @class = new ClassDeclarationIntermediateNode
{
ClassName = "SomeName",
Annotations =
{
[CommonAnnotations.PrimaryClass] = CommonAnnotations.PrimaryClass,
},
};
builder.Add(@class);
var pass = new AssemblyAttributeInjectionPass
{
Engine = RazorEngine.Create(),
};
var source = TestRazorSourceDocument.Create("test", new RazorSourceDocumentProperties(filePath: null, relativePath: "/Views/Index.cshtml"));
var document = RazorCodeDocument.Create(source);
// Act
pass.Execute(document, irDocument);
// Assert
Assert.Collection(
irDocument.Children,
node => Assert.Same(@namespace, node));
}
public void GetIdentifier_SanitizesRelativePath(string relativePath, string expected)
{
// Arrange
var sourceDocument = RazorSourceDocument.Create("content", new RazorSourceDocumentProperties("Test.cshtml", relativePath));
var codeDocument = RazorCodeDocument.Create(sourceDocument);
var feature = new DefaultMetadataIdentifierFeature()
{
Engine = RazorEngine.Create(),
};
// Act
var result = feature.GetIdentifier(codeDocument, sourceDocument);
// Assert
Assert.Equal(expected, result);
}
public void InstrumentationPass_SkipsCSharpExpression_InsideTagHelperProperty()
{
// Arrange
var document = new DocumentIntermediateNode();
var builder = IntermediateNodeBuilder.Create(document);
builder.Push(new TagHelperIntermediateNode());
builder.Push(new TagHelperPropertyIntermediateNode());
builder.Push(new CSharpExpressionIntermediateNode()
{
Source = CreateSource(5)
});
builder.Add(new IntermediateToken()
{
Content = "Hi",
Kind = TokenKind.CSharp,
});
var pass = new InstrumentationPass()
{
Engine = RazorEngine.CreateEmpty(b => { }),
};
// Act
pass.Execute(TestRazorCodeDocument.CreateEmpty(), document);
// Assert
Children(
document,
n =>
{
Assert.IsType <TagHelperIntermediateNode>(n);
Children(
n,
c =>
{
Assert.IsType <TagHelperPropertyIntermediateNode>(c);
Children(
c,
s => CSharpExpression("Hi", s));
});
});
}
public void Pass_DoesNothing_ForUnknownDocumentKind()
{
// Arrange
var document = new DocumentIntermediateNode();
var builder = IntermediateNodeBuilder.Create(document);
builder.Push(new DirectiveIntermediateNode()
{
Directive = NamespaceDirective.Directive,
Source = new SourceSpan(null, 0, 0, 0, 0),
});
builder.Add(new DirectiveTokenIntermediateNode()
{
Content = "WebApplication.Account"
});
builder.Pop();
var @namespace = new NamespaceDeclarationIntermediateNode()
{
Content = "default"
};
builder.Push(@namespace);
var @class = new ClassDeclarationIntermediateNode()
{
ClassName = "default"
};
builder.Add(@class);
document.DocumentKind = null;
var codeDocument = RazorCodeDocument.Create(RazorSourceDocument.Create("ignored", "/Account/Manage/AddUser.cshtml"));
var pass = new NamespaceDirective.Pass();
pass.Engine = RazorEngine.CreateEmpty(b => { });
// Act
pass.Execute(codeDocument, document);
// Assert
Assert.Equal("default", @namespace.Content);
Assert.Equal("default", @class.ClassName);
}
public void Pass_SetsNamespace_SanitizesClassAndNamespace()
{
// Arrange
var document = new DocumentIntermediateNode();
var builder = IntermediateNodeBuilder.Create(document);
builder.Push(new DirectiveIntermediateNode()
{
Directive = NamespaceDirective.Directive,
Source = new SourceSpan("/Account/_ViewImports.cshtml", 0, 0, 0, 0),
});
builder.Add(new DirectiveTokenIntermediateNode()
{
Content = "WebApplication.Account"
});
builder.Pop();
var @namespace = new NamespaceDeclarationIntermediateNode()
{
Content = "default"
};
builder.Push(@namespace);
var @class = new ClassDeclarationIntermediateNode()
{
ClassName = "default"
};
builder.Add(@class);
document.DocumentKind = RazorPageDocumentClassifierPass.RazorPageDocumentKind;
var codeDocument = RazorCodeDocument.Create(RazorSourceDocument.Create("ignored", "/Account/Manage-Info/Add+User.cshtml"));
var pass = new NamespaceDirective.Pass();
pass.Engine = RazorEngine.CreateEmpty(b => { });
// Act
pass.Execute(codeDocument, document);
// Assert
Assert.Equal("WebApplication.Account.Manage_Info", @namespace.Content);
Assert.Equal("default", @class.ClassName);
}
public void Setup()
{
var razorProject = RazorProject.Create(AppDomain.CurrentDomain.BaseDirectory);
var razorEngine = RazorEngine.Create(b =>
{
b.SetNamespace("Some.Namespace");
b.SetBaseType(typeof(MinimalistRazorTemplate).FullName);
});
var razorTemplateEngine = new RazorTemplateEngine(razorEngine, razorProject);
var references = AppDomain.CurrentDomain.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => MetadataReference.CreateFromFile(a.Location))
.ToList();
var emitOptions = new EmitOptions(debugInformationFormat: We.SupportFullPdb() ? DebugInformationFormat.Pdb : DebugInformationFormat.PortablePdb);
_renderer = new RazorViewCompiler(razorTemplateEngine, references, emitOptions);
}
public void GetDefaultImports_IncludesDefaultTagHelpers()
{
// Arrange
var mvcRazorTemplateEngine = new MvcRazorTemplateEngine(
RazorEngine.Create(),
new TestRazorProject());
// Act
var imports = mvcRazorTemplateEngine.Options.DefaultImports;
// Assert
var importContent = GetContent(imports)
.Split(new[] { Environment.NewLine }, StringSplitOptions.None)
.Where(line => line.StartsWith("@addTagHelper"));
Assert.Contains("@addTagHelper Microsoft.AspNetCore.Mvc.Razor.TagHelpers.UrlResolutionTagHelper, Microsoft.AspNetCore.Mvc.Razor", importContent);
}
public override RazorTemplateEngine Create(string projectPath, Action <IRazorEngineBuilder> configure)
{
if (projectPath == null)
{
throw new ArgumentNullException(nameof(projectPath));
}
// In 15.5 we expect projectPath to be a directory, NOT the path to the csproj.
var project = FindProject(projectPath);
var configuration = (project?.Configuration as MvcExtensibilityConfiguration) ?? DefaultConfiguration;
RazorEngine engine;
if (configuration.RazorAssembly.Identity.Version.Major == 1)
{
engine = RazorEngine.CreateDesignTime(b =>
{
configure?.Invoke(b);
Mvc1_X.RazorExtensions.Register(b);
if (configuration.MvcAssembly.Identity.Version.Minor >= 1)
{
Mvc1_X.RazorExtensions.RegisterViewComponentTagHelpers(b);
}
});
var templateEngine = new Mvc1_X.MvcRazorTemplateEngine(engine, RazorProject.Create(projectPath));
templateEngine.Options.ImportsFileName = "_ViewImports.cshtml";
return(templateEngine);
}
else
{
engine = RazorEngine.CreateDesignTime(b =>
{
configure?.Invoke(b);
MvcLatest.RazorExtensions.Register(b);
});
var templateEngine = new MvcLatest.MvcRazorTemplateEngine(engine, RazorProject.Create(projectPath));
templateEngine.Options.ImportsFileName = "_ViewImports.cshtml";
return(templateEngine);
}
}
public void GetChangeToken_WatchesAllCshtmlFilesUnderFileSystemRoot()
{
// Arrange
var fileProvider = new Mock <IFileProvider>();
var accessor = Mock.Of <IRazorViewEngineFileProviderAccessor>(a => a.FileProvider == fileProvider.Object);
var templateEngine = new RazorTemplateEngine(
RazorEngine.Create(),
new FileProviderRazorProject(accessor));
var options = Options.Create(new RazorPagesOptions());
var changeProvider = new PageActionDescriptorChangeProvider(templateEngine, accessor, options);
// Act
var changeToken = changeProvider.GetChangeToken();
// Assert
fileProvider.Verify(f => f.Watch("/Pages/**/*.cshtml"));
}
public async Task TestSaveToStreamAsync()
{
RazorEngine razorEngine = new RazorEngine();
IRazorEngineCompiledTemplate initialTemplate = await razorEngine.CompileAsync("Hello @Model.Name");
MemoryStream memoryStream = new MemoryStream();
await initialTemplate.SaveToStreamAsync(memoryStream);
memoryStream.Position = 0;
IRazorEngineCompiledTemplate loadedTemplate = await RazorEngineCompiledTemplate.LoadFromStreamAsync(memoryStream);
string initialTemplateResult = await initialTemplate.RunAsync(new { Name = "Alex" });
string loadedTemplateResult = await loadedTemplate.RunAsync(new { Name = "Alex" });
Assert.AreEqual(initialTemplateResult, loadedTemplateResult);
}
protected RazorEngine CreateRuntimeEngine(IEnumerable <MetadataReference> references)
{
return(RazorEngine.Create(b =>
{
RazorExtensions.Register(b);
b.Features.Add(GetMetadataReferenceFeature(references));
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultTagHelperDescriptorProvider()
{
DesignTime = true
});
b.Features.Add(new ViewComponentTagHelperDescriptorProvider()
{
ForceEnabled = true
});
}));
}
private static RazorSyntaxTree GetSyntaxTree(StringTextSnapshot source, IEnumerable <DirectiveDescriptor> directives = null)
{
directives = directives ?? Enumerable.Empty <DirectiveDescriptor>();
var engine = RazorEngine.CreateDesignTime(builder =>
{
foreach (var directive in directives)
{
builder.AddDirective(directive);
}
});
var sourceDocument = RazorSourceDocument.Create(source.GetText(), "test.cshtml");
var codeDocument = RazorCodeDocument.Create(sourceDocument);
engine.Process(codeDocument);
return(codeDocument.GetSyntaxTree());
}
public void AddDirective_NoFeature_CreatesFeature()
{
// Arrange
var engine = RazorEngine.CreateEmpty(b =>
{
// Act
b.AddDirective(DirectiveDescriptor.CreateDirective("test", DirectiveKind.SingleLine));
});
// Assert
var actual = Assert.Single(engine.Features.OfType <IRazorDirectiveFeature>());
Assert.IsType <DefaultRazorDirectiveFeature>(actual);
var directive = Assert.Single(actual.Directives);
Assert.Equal("test", directive.Directive);
}
public void AddTargetExtensions_NoFeature_CreatesFeature()
{
// Arrange
var extension = new MyTargetExtension();
var engine = RazorEngine.CreateEmpty(b =>
{
// Act
b.AddTargetExtension(extension);
});
// Assert
var actual = Assert.Single(engine.Features.OfType <IRazorTargetExtensionFeature>());
Assert.IsType <DefaultRazorTargetExtensionFeature>(actual);
Assert.Same(extension, Assert.Single(actual.TargetExtensions));
}
public void TestSettingTemplateFilename()
{
RazorEngine razorEngine = new RazorEngine();
var errorThrown = false;
try
{
IRazorEngineCompiledTemplate initialTemplate = razorEngine.Compile("@{ this is a syntaxerror }",
builder => { builder.Options.TemplateFilename = "templatefilenameset.txt"; });
}
catch (Exception e)
{
Assert.IsTrue(e.Message.Contains("templatefilenameset.txt"));
errorThrown = true;
}
Assert.IsTrue(errorThrown);
}
public DaoGenerator()
{
logger = this.CreateLogger();
engine = RazorEngine.Create(builder =>
{
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.Features.Add(new SqlDocumentClassifierPassBase());
});
assembly = GetType().Assembly;
assemblyName = Path.GetRandomFileName();
types = new List <Type>();
syntaxTrees = new List <SyntaxTree>();
Extractor = new Extractor();
}
public void GenerateCodeWithBaseType()
{
// Arrange
var fileSystem = new DefaultRazorProjectFileSystem(TestProjectRoot);
var razorEngine = RazorEngine.Create(engine =>
{
engine.Features.Add(new SuppressChecksumOptionsFeature());
engine.SetBaseType("MyBaseType");
});
var templateEngine = new RazorTemplateEngine(razorEngine, fileSystem);
// Act
var cSharpDocument = templateEngine.GenerateCode($"{FileName}.cshtml");
// Assert
AssertCSharpDocumentMatchesBaseline(cSharpDocument);
}
private DocumentIntermediateNode CreateIRDocument(RazorEngine engine, RazorCodeDocument codeDocument)
{
for (var i = 0; i < engine.Phases.Count; i++)
{
var phase = engine.Phases[i];
phase.Execute(codeDocument);
if (phase is IRazorDocumentClassifierPhase)
{
break;
}
}
var irDocument = codeDocument.GetDocumentIntermediateNode();
irDocument.DocumentKind = MvcViewDocumentClassifierPass.MvcViewDocumentKind;
return(irDocument);
}
public void GenerateCodeWithSetNamespace()
{
// Arrange
var project = new FileSystemRazorProject(TestProjectRoot);
var razorEngine = RazorEngine.Create(engine =>
{
engine.Features.Add(new SuppressChecksumOptionsFeature());
engine.SetNamespace("MyApp.Razor.Views");
});
var templateEngine = new RazorTemplateEngine(razorEngine, project);
// Act
var cSharpDocument = templateEngine.GenerateCode($"{FileName}.cshtml");
// Assert
AssertCSharpDocumentMatchesBaseline(cSharpDocument);
}
public void SimplestRazorEngineWithModelTest()
{
string template = @"@model Person
Hello World @Model.Name. Time is: @DateTime.Now";
var host = new RazorEngine <RazorTemplateBase>();
host.AddNamespace("RazorHostingTests");
string result = host.RenderTemplate(template, new Person {
Name = "Joe Doe"
});
Assert.IsNotNull(result, host.ErrorMessage);
Assert.IsTrue(result.Contains("Joe Doe"));
Console.WriteLine(result);
}
static void Main(string[] args)
{
RazorEngine razorEngine = new RazorEngine();
RazorEngineCompiledTemplate template = razorEngine.Compile(Content);
string result = template.Run(new
{
Name = "Alexander",
Items = new List <string>()
{
"item 1",
"item 2"
}
});
Console.WriteLine(result);
Console.ReadKey();
}
/// <summary>
/// implementing operate on rows (instead of row) to allow loading of external (file based) templates first
/// </summary>
/// <param name="rows"></param>
/// <returns></returns>
public override IEnumerable <IRow> Operate(IEnumerable <IRow> rows)
{
if (!Run)
{
yield break;
}
var fileBasedTemplate = Context.Process.Templates.FirstOrDefault(t => t.Name == Context.Operation.Template);
if (fileBasedTemplate != null)
{
Context.Operation.Template = fileBasedTemplate.Content;
}
var input = MultipleInput();
var matches = Context.Entity.GetFieldMatches(Context.Operation.Template);
_input = input.Union(matches).ToArray();
var engine = new RazorEngine();
IRazorEngineCompiledTemplate template;
try {
template = engine.Compile(Context.Operation.Template);
} catch (RazorEngineCompilationException ex) {
foreach (var error in ex.Errors)
{
var line = error.Location.GetLineSpan();
Context.Error($"C# error on line {line.StartLinePosition.Line}, column {line.StartLinePosition.Character}.");
Context.Error(error.GetMessage());
}
Context.Error(ex.Message.Replace("{", "{{").Replace("}", "}}"));
Utility.CodeToError(Context, Context.Operation.Template);
yield break;
}
foreach (var row in rows)
{
var output = template.Run(row.ToFriendlyExpandoObject(_input));
row[Context.Field] = _convert(output);
yield return(row);
}
}
static IList <SyntaxTree> GetSyntaxTrees(RazorEngine engine, string rootDir, string[] filenames)
{
var codeDocs = GetCodeDocuments(rootDir, filenames);
var tagNamesToSourceFiles = codeDocs
.Where(cd => !string.IsNullOrEmpty(cd.Items["DetectedTagName"] as string))
.ToDictionary(
cd => cd.Items["DetectedTagName"] as string,
cd => "./" + MakeRelativePath(rootDir, cd.Source.FileName).Replace('\\', '/'));
foreach (var codeDoc in codeDocs)
{
codeDoc.Items["tagNamesToSourceFiles"] = tagNamesToSourceFiles;
engine.Process(codeDoc);
}
return(codeDocs.Select(codeDoc =>
{
var csharpDocument = codeDoc.GetCSharpDocument();
var generatedCode = csharpDocument.GeneratedCode;
var usingNamespaces = (IEnumerable <string>)codeDoc.Items["UsingNamespaces"];
var allNamespaces = new List <string>
{
"System",
"System.Collections.Generic",
"System.Linq",
"System.Net.Http",
"System.Threading.Tasks",
"Blazor.Util",
};
allNamespaces.AddRange(usingNamespaces);
// If there's a better way to do this, it's not clear what it is. Don't see any public extension points
// for this.
generatedCode = string.Join(string.Empty, allNamespaces.Select(ns => $"using {ns};{Environment.NewLine}")) + generatedCode;
generatedCode = generatedCode.Replace(
"public async override global::System.Threading.Tasks.Task ExecuteAsync()",
"protected override void RenderVirtualDom()");
Log(generatedCode);
var syntaxTree = CSharpSyntaxTree.ParseText(generatedCode);
return syntaxTree;
}).ToList());
}
private static RazorSyntaxTree GetSyntaxTree(string source)
{
var taghelper = TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("taghelper"))
.TypeName("TestTagHelper")
.Build();
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.AddTagHelpers(taghelper);
});
var sourceDocument = RazorSourceDocument.Create(source, "test.cshtml");
var addTagHelperImport = RazorSourceDocument.Create("@addTagHelper *, TestAssembly", "import.cshtml");
var codeDocument = RazorCodeDocument.Create(sourceDocument, new[] { addTagHelperImport });
engine.Process(codeDocument);
return(codeDocument.GetSyntaxTree());
}
private RazorEngine <RazorTemplateBase> CreateHost()
{
if (this.Engine != null)
{
return(this.Engine);
}
this.Engine = new RazorEngine <RazorTemplateBase>();
// Use Static Methods - no error message if host doesn't load
//this.Host = RazorEngineFactory<RazorTemplateBase>.CreateRazorHost();
if (this.Engine == null)
{
throw new ApplicationException("Unable to load Razor Template Host");
}
return(this.Engine);
}
public async Task TestCompileAndRun_DynamicModel_NestedAsync()
{
RazorEngine razorEngine = new RazorEngine();
var model = new
{
Name = "Alex",
Membership = new
{
Level = "Gold"
}
};
var template = await razorEngine.CompileAsync("Name: @Model.Name, Membership: @Model.Membership.Level");
string actual = await template.RunAsync(model);
Assert.AreEqual("Name: Alex, Membership: Gold", actual);
}
private static DocumentIntermediateNode Lower(RazorCodeDocument codeDocument, RazorEngine engine)
{
for (var i = 0; i < engine.Phases.Count; i++)
{
var phase = engine.Phases[i];
phase.Execute(codeDocument);
if (phase is IRazorDocumentClassifierPhase)
{
break;
}
}
var irDocument = codeDocument.GetDocumentIntermediateNode();
Assert.NotNull(irDocument);
return(irDocument);
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
try
{
if (! (string.IsNullOrEmpty(RazorScriptFile)))
{
var razorEngine = new RazorEngine(RazorScriptFile, ModuleContext, LocalResourceFile);
var writer = new StringWriter();
razorEngine.Render(writer);
Controls.Add(new LiteralControl(Server.HtmlDecode(writer.ToString())));
}
}
catch (Exception ex)
{
Exceptions.ProcessModuleLoadException(this, ex);
}
}
public void SimplestRazorEngineWithCompileTest()
{
string template = @"Hello World @Model.Name. Time is: @DateTime.Now";
var host = new RazorEngine();
string assemblyId = host.CompileTemplate(template);
string result = null;
// this will now reuse the same compile template
for (int i = 0; i < 10; i++)
{
result += host.RenderTemplateFromAssembly(assemblyId, new { Name = "Joe Doe" }) + "\r\n";
}
Assert.IsNotNull(result, host.ErrorMessage);
Assert.IsTrue(result.Contains("Joe Doe"));
Console.WriteLine(result);
}
public void Render(object source, HtmlTextWriter htmlWriter, TemplateDefinition liveDefinition)
{
if (!(string.IsNullOrEmpty(liveDefinition.TemplateVirtualPath)))
{
var resolver = new PathResolver(liveDefinition.Folder);
dynamic model = new ExpandoObject();
model.Source = source;
model.ControlID = DNNContext.Current.HostControl.ClientID;
model.Options = ConvertToJson(liveDefinition.ClientOptions);
model.DNNPath = resolver.Resolve("/", PathResolver.RelativeTo.Dnn);
model.ManifestPath = resolver.Resolve("/", PathResolver.RelativeTo.Manifest);
model.PortalPath = resolver.Resolve("/", PathResolver.RelativeTo.Portal);
model.SkinPath = resolver.Resolve("/", PathResolver.RelativeTo.Skin);
var modelDictionary = model as IDictionary<string, object>;
liveDefinition.TemplateArguments.ForEach(a => modelDictionary.Add(a.Name, a.Value));
var razorEngine = new RazorEngine(liveDefinition.TemplateVirtualPath, null, null);
var writer = new StringWriter();
razorEngine.Render<dynamic>(writer, model);
htmlWriter.Write(writer.ToString());
}
}
private void tbRunLowLevel_Click(object sender, EventArgs e)
{
// we can pass any object as context - here create a custom context
var context = new CustomContext()
{
WinForm = this,
Entered = DateTime.Now.AddDays(-10)
};
var engine = new RazorEngine<RazorTemplateBase>();
string assId = null;
using (StringReader reader = new StringReader(this.txtSource.Text))
{
assId = engine.ParseAndCompileTemplate(new string[] { "System.Windows.Forms.dll" }, reader);
}
string output = engine.RenderTemplateFromAssembly(assId, context);
if (output == null)
this.txtResult.Text = "*** ERROR:\r\n" + engine.ErrorMessage;
else
this.txtResult.Text = output;
}
public StartProcessor(ISiteContext context, RazorEngine.Configuration.TemplateServiceConfiguration config)
{
_context = context;
_startTemplateService = new RazorEngine.Templating.TemplateService(config);
}
private static string buildNuGetSpecFile(PackageDescription context)
{
var engine = new RazorEngine<RazorTemplateBase>();
using(var reader = new StreamReader("Package.cshtml", true))
{
var output = engine.RenderTemplate(reader, new[] {"System.Windows.Forms.dll"}, context);
if( output==null )
{
throw new InvalidOperationException("*** ERROR:\r\n" + engine.ErrorMessage);
}
return output;
}
}
/////////////////////////////////////////////////////////////////////////////
private string Runner( string text, bool returnSource, RazorRunnerException.RunHow runContext )
{
// ******
//dynamic context = new ExpandoObject();
//context.Version = 2.0;
// ******
var asmId = string.Empty;
var result = string.Empty;
var reader = new StringReader( text );
// ******
// as arguments to ctor pass the PrePostHandler() and a method to customize
// the host and whatever else
//
// for the host we set the names for section, etc
var razor = new RazorEngine<NmpRazorTemplateBase>( DefaultNamespaces, PrePostRenderHandler, CreateHostHandler );
razor.SetError();
try {
asmId = razor.ParseAndCompileTemplate( assemblyPaths, reader );
}
catch ( Exception ex ) {
ThreadContext.MacroError( "error Parsing and Compiling Razor template: {0}", ex.Message );
}
if( null == asmId ) {
//
// error
//
const string ErrMsg = "Razor failed to compile the generated source.";
throw new RazorRunnerException( runContext, ErrMsg, razor.ErrorMessage, razor.LastGeneratedCode );
}
// ******
try {
result = razor.RenderTemplateFromAssembly( asmId, null );
}
catch ( Exception ex ) {
ThreadContext.MacroError( "error Rendering Razor Template from Assembly template: {0}", ex.Message );
}
if( null == result ) {
const string ErrMsg = "Razor failed to execute the template.";
throw new RazorRunnerException( runContext, ErrMsg, razor.ErrorMessage, razor.LastGeneratedCode );
}
// ******
if( RazorRunnerException.RunHow.Run == runContext ) {
//
// (#block `razor'
//
}
// ******
return FileReader.FixText( returnSource ? RazorRunnerException.AddLineNumbers(razor.LastGeneratedCode) : result );
}
public void SimplestRazorEngineWithAnonymousModelTest()
{
var model = new { Name = "Joe Doe", Company = "West Wind" };
string template = @"Hello World @Model.Name of @Model.Company. Time is: @DateTime.Now";
var host = new RazorEngine<RazorTemplateBase>();
string cid = host.CompileTemplate(template);
string result = host.RenderTemplateFromAssembly(cid, model);
Console.WriteLine(result + "\r\n" +
host.ErrorMessage + "\r\n" +
host.LastGeneratedCode);
Assert.IsNotNull(result, host.ErrorMessage + "\r\n" + host.LastGeneratedCode);
Assert.IsTrue(result.Contains("Joe Doe"));
}
private void tbRunRaw_Click(object sender, EventArgs e)
{
var engine = new RazorEngine<RazorTemplateBase>();
// we can pass any object as context - here create a custom context
var context = new CustomContext()
{
WinForm = this,
Entered = DateTime.Now.AddDays(-10)
};
string output = engine.RenderTemplate(this.txtSource.Text,
new string[] { "System.Windows.Forms.dll" },
context);
if (output == null)
this.txtResult.Text = "*** ERROR:\r\n" + engine.ErrorMessage;
else
this.txtResult.Text = output;
}
private string GenerateOutput(string Template, string dataJson, string settingsJson)
{
try
{
if (!(string.IsNullOrEmpty(Template)))
{
if (!File.Exists(Server.MapPath(Template)))
Exceptions.ProcessModuleLoadException(this, new Exception(Template + " don't exist"));
if (!string.IsNullOrEmpty(dataJson))
{
//dynamic json = JValue.Parse(struc.Json);
//JObject model = new JObject();
//model["Data"] = JValue.Parse(struc.Json);
//model["Settings"] = JValue.Parse(Data);
//dynamic model = new ExpandoObject();
//model.Data = JsonUtils.JsonToDynamic(struc.Json);
dynamic model = JsonUtils.JsonToDynamic(dataJson);
if (settingsJson != null)
model.Settings = JsonUtils.JsonToDynamic(settingsJson);
model.Context = new { ModuleId = ModuleContext.ModuleId, PortalId = ModuleContext.PortalId };
if (Path.GetExtension(Template) != ".hbs")
{
string webConfig = Path.GetDirectoryName(Server.MapPath(Template));
webConfig = webConfig.Remove(webConfig.LastIndexOf("\\")) + "\\web.config";
if (!File.Exists(webConfig))
{
string filename = HostingEnvironment.MapPath("~/DesktopModules/OpenContent/Templates/web.config");
File.Copy(filename, webConfig);
}
try
{
var razorEngine = new RazorEngine(Template, ModuleContext, LocalResourceFile);
var writer = new StringWriter();
RazorRender(razorEngine.Webpage, writer, model);
return writer.ToString();
}
catch (Exception ex)
{
Exceptions.ProcessModuleLoadException(string.Format("Error while loading template {0}", Template), this, ex);
}
}
else
{
HandlebarsEngine hbEngine = new HandlebarsEngine();
return hbEngine.Execute(Page, Template, model);
}
}
else
{
return "";
}
}
else
{
return "";
}
}
catch (Exception ex)
{
Exceptions.ProcessModuleLoadException(this, ex);
}
return "";
}
public Renderer()
{
_host = RazorEngineFactory<RazorTemplateBase>.CreateRazorHost();
}
public void SimplestRazorEngineWithExplicitCompilationTest()
{
string template = @"Hello World @Model.Name. Time is: @DateTime.Now";
var host = new RazorEngine<RazorTemplateBase>();
string compiledId = host.CompileTemplate(template);
string result = host.RenderTemplateFromAssembly(compiledId,
new Person() { Name = "Joe Doe" });
Assert.IsNotNull(result, host.ErrorMessage);
Assert.IsTrue(result.Contains("Joe Doe"));
}
private void tbUnloadAppDomain_Click(object sender, EventArgs e)
{
RazorEngineFactory<RazorTemplateBase>.UnloadRazorHostInAppDomain();
this.Host = null;
}
