public async Task <string> ParseAsync <T>(string template, T model, bool isHtml = true)
{
var project = new InMemoryRazorLightProject();
var engine = new RazorLightEngineBuilder().UseProject(project).Build();
return(await engine.CompileRenderStringAsync <T>(Guid.NewGuid().ToString(), template, model));
}
public virtual string ExecuteHtml(string viewTemplate, OperationPackage package)
{
string date = $"{DateTime.Now:dd.MM.yy HH:mm:ss}";
if (!package.DataSets.Any())
{
return("No information obtained by query");
}
var packageValues = PackageParser.GetPackageValues(package);
var dataSet = packageValues.First();
var model = new
{
dataSet.Headers,
Content = dataSet.Rows,
Date = date
};
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
var result = engine.CompileRenderStringAsync("templateKey", viewTemplate, model).Result;
return(result);
}
private async Task Compile(string templateContent)
{
var engine = new RazorLightEngineBuilder()
// required to have a default RazorLightProject type,
// but not required to create a template from string.
.UseEmbeddedResourcesProject(typeof(Window))
.UseMemoryCachingProvider()
.Build();
bool isError = false;
string result = string.Empty;
try
{
result = await engine.CompileRenderStringAsync("templateKey", templateContent, new EmptyModel());
}
catch (Exception ex)
{
isError = true;
result = "Error: " + ex.Message;
}
if (settings.TrimOutput)
{
result = result.Trim('\r', '\n', ' ');
}
await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
UpdateUiResult(result, isError);
}));
}
public static async Task Main()
{
var engine = new RazorLightEngineBuilder()
.UseMemoryCachingProvider()
.UseEmbeddedResourcesProject(typeof(Program).Assembly, rootNamespace: "RazorLight.Sandbox.Views")
.Build();
//string result = await engine.CompileRenderAsync<object>("Home", null, null);
//Console.WriteLine(result);
await using var tempStream = new MemoryStream();
await using var compressionStream = new CompressionStream(tempStream);
await GetStream(64).CopyToAsync(compressionStream);
await using var decompressionStream = new DecompressionStream(tempStream);
await UnwrapStream(decompressionStream);
//System.GC.SuppressFinalize(decompressionStream);
var model = new { UnwrappedValue = new Lazy <string>(() =>
{
var x = UnwrapStream(decompressionStream).Result;
return(Encoding.Default.GetString(x));
}) };
string dynamicTemplateResult =
await engine.CompileRenderStringAsync("templateKey", @"@using RazorLight
@Model.UnwrappedValue.Value", model, null);
Console.WriteLine(dynamicTemplateResult);
Console.WriteLine("Finished");
}
protected override async Task DoWorkAsync(CancellationToken cancellationToken)
{
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
var smtpClient = _scopedServiceProvider.GetService <SmtpClient>();
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
var emailTemplate = "<div>Hi @Model.Name </div><div>You just won $1 million dollars!</div>";
var recipient = new EmailRecipient
{
Name = "Jane Doe",
Email = "*****@*****.**"
};
var emailBody = await engine.CompileRenderStringAsync("templateKey", emailTemplate, recipient);
var mailMessage = new MailMessage("*****@*****.**", recipient.Email);
mailMessage.Body = emailBody;
mailMessage.IsBodyHtml = true;
await smtpClient.SendMailAsync(mailMessage);
await Task.Delay(3000, cancellationToken);
}
}
public async Task Ensure_Content_Added_To_DynamicTemplates()
{
var options = new RazorLightOptions();
const string key = "key";
const string content = "content";
var project = new TestRazorProject {
Value = new TextSourceRazorProjectItem(key, content)
};
var engine = new RazorLightEngineBuilder()
#if NETFRAMEWORK
.SetOperatingAssembly(typeof(Root).Assembly)
#endif
.UseProject(project)
.UseOptions(options)
.AddDynamicTemplates(new Dictionary <string, string>
{
[key] = content,
})
.Build();
var actual = await engine.CompileRenderStringAsync(key, content, new object(), new ExpandoObject());
Assert.NotEmpty(options.DynamicTemplates);
Assert.Contains(options.DynamicTemplates, t => t.Key == key && t.Value == content);
Assert.Equal(content, actual);
}
public async Task <string> Compile(string text, dynamic model)
{
var razorEngine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(MessageCompiler))
.UseMemoryCachingProvider()
.Build();
string result = await razorEngine.CompileRenderStringAsync(model.GetHashCode(), text, model);
return(result);
}
public async Task <string> TransformAsync(Guid postId, string content)
{
var razor = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(RazorTransformer))
.Build();
var razorTemplateHelper = new RazorTemplateHelper {
Host = "", PostId = postId
};
return(await razor.CompileRenderStringAsync(postId.ToString(), content, razorTemplateHelper));
}
public async Task <string> ParseTemplate <T>(T model, string content)
{
//return Razor.Parse(content, model);
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
string result = await engine.CompileRenderStringAsync("templateKey", content, model);
return(result);
}
/// <summary>
/// Renders "cshtml" email template to string.
/// </summary>
/// <param name="assembly">Assembly where the embedded resource resides.</param>
/// <param name="embeddedResourceName"></param>
/// <param name="model">The model to pass to the view.</param>
private async Task <string> RenderPartialView <T>(Assembly assembly, string embeddedResourceName, T model)
{
var modelType = typeof(T);
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(T))
.UseMemoryCachingProvider()
.Build();
var source = assembly.GetEmbeddedResourceText(embeddedResourceName);
return(await engine.CompileRenderStringAsync(modelType.FullName, source, model));
}
public async Task <string> ParseTemplate <T>(T model, string content)
{
var engine = new RazorLightEngineBuilder()
// required to have a default RazorLightProject type,
// but not required to create a template from string.
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
string result = await engine.CompileRenderStringAsync <T>("templateKey", content, model);
return(result);
}
public async Task <string> GetHtmlString(List <Enclosure> enclosures)
{
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Enclosure))
.UseMemoryCachingProvider().Build();
var pdf = new Pages.Pdf(enclosures);
var template = await File.ReadAllTextAsync("Pages/Pdf.cshtml");
var result = await engine.CompileRenderStringAsync("pdf", template, pdf);
return(result);
}
public async Task Ensure_QuickStart_Demo_Code_Works()
{
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Root))
.UseMemoryCachingProvider()
.Build();
string template = "Hello, @Model.Name. Welcome to RazorLight repository";
var model = new { Name = "John Doe" };
string result = await engine.CompileRenderStringAsync("templateKey", template, model);
Assert.Equal("Hello, John Doe. Welcome to RazorLight repository", result);
}
public async Task <IActionResult> Get2()
{
var path = Path.Combine(_hostingEnvironment.ContentRootPath, "Views");
var engine = new RazorLightEngineBuilder()
.UseFileSystemProject(path)
.UseMemoryCachingProvider()
.Build();
var result = await engine.CompileRenderStringAsync("test", @"@using RazorLightTest.Controllers
@model Test
Hello @Model.Name", new Test { Name = "World" });
return(Ok(result));
}
public async Task Ensure_Content_Added_To_DynamicTemplates_When_Both_RazorLightProject_And_Options_Not_Set_Explicitly()
{
const string key = "key";
const string content = "content";
var engine = new RazorLightEngineBuilder()
#if NETFRAMEWORK
.SetOperatingAssembly(typeof(Root).Assembly)
#endif
.Build();
var actual = await engine.CompileRenderStringAsync(key, content, new object(), new ExpandoObject());
Assert.NotEmpty(engine.Options.DynamicTemplates);
Assert.Contains(engine.Options.DynamicTemplates, t => t.Key == key && t.Value == content);
Assert.Equal(typeof(NoRazorProject), (engine.Handler.Compiler as RazorTemplateCompiler)?.ProjectType);
Assert.Equal(content, actual);
}
public async Task Ensure_Option_DisablEncoding_Renders_Models_Raw()
{
//Assing
var engine = new RazorLightEngineBuilder()
.UseMemoryCachingProvider()
.UseFileSystemProject(DirectoryUtils.RootDirectory)
.DisableEncoding()
.Build();
string key = "key";
string content = "@Model.Entity";
var model = new { Entity = "<pre></pre>" };
// act
var result = await engine.CompileRenderStringAsync(key, content, model);
// assert
Assert.Contains("<pre></pre>", result);
}
private async Task <string> Template(MutationProjectReportModel model)
{
var currentAssembly = Assembly.GetExecutingAssembly();
var resourceName = currentAssembly
.GetManifestResourceNames()
.Single(str => str.EndsWith("HTML.cshtml"));
using var streamReader = new StreamReader(currentAssembly.GetManifestResourceStream(resourceName));
var template = await streamReader.ReadToEndAsync();
var engine = new RazorLightEngineBuilder()
// required to have a default RazorLightProject type,
// but not required to create a template from string.
.UseEmbeddedResourcesProject(typeof(HtmlReporter))
.UseMemoryCachingProvider()
.Build();
var result = await engine.CompileRenderStringAsync("templateKey", template, model);
return(result);
}
public async Task Simple()
{
#region Simple
var engine = new RazorLightEngineBuilder()
// required to have a default RazorLightProject type,
// but not required to create a template from string.
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
string template = "Hello, @Model.Name. Welcome to RazorLight repository";
ViewModel model = new ViewModel {
Name = "John Doe"
};
string result = await engine.CompileRenderStringAsync("templateKey", template, model);
#endregion
Assert.NotNull(result);
}
/// <summary>
/// テンプレートファイル展開を行う
/// </summary>
/// <param name="TemplateString"></param>
/// <param name="info"></param>
/// <returns></returns>
public static string TemplateExpansion(
string TemplateKey,
string TemplateString,
SiteInfos info)
{
// NetCoreへの対応状況により
// 以下ライブラリに差し替えする
// https://github.com/toddams/RazorLight
// ToDo
// 暫定で一番簡単な方法で実装する。
// 別途パフォーマンス調整の方法があるハズ
var engine = new RazorLightEngineBuilder()
// required to have a default RazorLightProject type,
// but not required to create a template from string.
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
var result = engine.CompileRenderStringAsync(TemplateKey, TemplateString, info);
result.Wait();
var cacheResult = engine.Handler.Cache.RetrieveTemplate(TemplateKey);
if (cacheResult.Success)
{
var templatePage = cacheResult.Template.TemplatePageFactory();
var tresult = engine.RenderTemplateAsync(templatePage, info);
tresult.Wait();
var v = tresult.Result;
return(v);
}
return("");
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string name = req.Query["name"];
var engine = new RazorLightEngineBuilder()
.SetOperatingAssembly(Assembly.GetExecutingAssembly())
.UseEmbeddedResourcesProject(typeof(RenderTemplate))
.UseMemoryCachingProvider()
.Build();
string template = "Hello, @Model.Name. Welcome to RazorLight repository at @Model.Time";
var model = new { Name = "John Doe", Time = DateTime.UtcNow };
string result = await engine.CompileRenderStringAsync("templateKey", template, model);
return(new OkObjectResult(result));
}
public async Task <EmailMessage> PrepareEmailMessage(string base64Json)
{
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(EmailMessageBuilder))
.UseMemoryCachingProvider()
.Build();
var template = Encoding.UTF8.GetString(EmailTemplates.Hello);
var jsonString = base64Json.Base64Decode();
using var input = new StringReader(jsonString);
var model = JSON.Deserialize <CustomViewModel>(input);
var result = await engine.CompileRenderStringAsync("templateKey", template, model);
return(new EmailMessage
{
Content = result
});
}
public override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
receiveData ??= new DataToSentTable();
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(this.GetType())
.UseMemoryCachingProvider()
.Build();
var key = Guid.NewGuid().ToString();
var found = await engine.CompileRenderStringAsync(key, InputTemplate, receiveData);
base.CreateOutputIfNotExists(receiveData);
base.OutputString.Rows.Add(null, key, found);
return(receiveData);
}
public async static Task <IRestResponse> SendReceipt(string email, Receipt receipt)
{
string template = File.ReadAllText("Utils/Receipt_template.html", System.Text.Encoding.UTF8);
const string key = "templateKey";
// mock model for testing
//var receipt1 = new Receipt
//{
// OrderId = "fj32lkj322443sd",
// ReceiptItems = new List<ReceiptItem>
// {
// new ReceiptItem
// {
// ProductName = "Valheim",
// ActivationCodes = new List<string> { "1234dsdf45", "231984u", "3209ufsldifj"},
// UnitPrice = 18,
// Qty = 3
// },
// new ReceiptItem
// {
// ProductName = "Three Kingdom",
// ActivationCodes = new List<string> { "1dfdsf45", "32ds546di65fj"},
// UnitPrice = 38,
// Qty = 2
// }
// }
//};
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Receipt))
.SetOperatingAssembly(typeof(Receipt).Assembly)
.Build();
string msg = await engine.CompileRenderStringAsync(key, template, receipt);
return(await SendEmail(msg, email));
}
private async Task <string> BuildEmailTemplate(Message model)
{
using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("BorovClub.EmailMessageNotification.cshtml");
TextReader tr = new StreamReader(stream);
string razorTemplate = tr.ReadToEnd();
var engine =
new RazorLightEngineBuilder().UseMemoryCachingProvider().UseFileSystemProject("C:/tor").Build();
var cacheResult = engine.Handler.Cache.RetrieveTemplate("UnreadMessageTemplate");
string renderedTemplate;
if (cacheResult.Success)
{
renderedTemplate = await engine.RenderTemplateAsync(cacheResult.Template.TemplatePageFactory.Invoke(), model);
}
else
{
renderedTemplate = await engine.CompileRenderStringAsync("UnreadMessageTemplate", razorTemplate, model);
}
return(renderedTemplate);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string name = req.Query["name"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
name = name ?? data?.name;
#region Razor
var engine = new RazorLightEngineBuilder()
// required to have a default RazorLightProject type,
// but not required to create a template from string.
.UseEmbeddedResourcesProject(typeof(ViewModel))
.UseMemoryCachingProvider()
.Build();
string template = "Hello, @Model.Name. Welcome to RazorLight repository";
ViewModel model = new ViewModel {
Name = "John Doe"
};
string result = await engine.CompileRenderStringAsync("templateKey", template, model);
#endregion
string responseMessage = string.IsNullOrEmpty(name)
? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
: $"Hello, {name}. This HTTP triggered function executed successfully.";
return(new OkObjectResult(result));
}
/// <summary>
/// Generate output third party notice with collected license information.
/// </summary>
public async Task GenerateOutputFileAsync()
{
if (mLicenses == null || mLicenses.Count == 0 || mFinishProcessing)
{
sLog.Write(LogLevel.Notice, "Nothing to store, because there are no licenses found.");
return;
}
// overwrite existing file if necessary
if (File.Exists(mOutputPath))
{
File.Delete(mOutputPath);
}
RazorLightEngine engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(AppCore))
.UseMemoryCachingProvider()
.DisableEncoding()
.Build();
string template = LicenseTemplate;
if (!string.IsNullOrEmpty(mLicenseTemplatePath) && File.Exists(mLicenseTemplatePath))
{
sLog.Write(LogLevel.Notice, "Load user defined razor template '{0}' for third party notices", mLicenseTemplatePath);
template = File.ReadAllText(mLicenseTemplatePath);
}
string patchedTemplate = await engine
.CompileRenderStringAsync("Third party notices", template, mLicenses)
.ConfigureAwait(false);
File.WriteAllText(mOutputPath, patchedTemplate);
sLog.Write(LogLevel.Notice, "Successful write collected licenses to '{0}'", mOutputPath);
sLog.Write(LogLevel.Notice, "--------------------------------------------------------------------------------");
}
public override string Populate()
{
InvoiceReportModel model = new InvoiceReportModel
{
Id = data.Id,
Customer = data.Customer,
TimeEntries = data.TimeEntries.Select(y => new TimeEntryFormViewModel()
{
Description = y.Description,
TotalPrice = y.TotalPrice
}).ToList(),
User = data.User,
Date = data.Date
};
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
string content = TemplateLogic.GetTemplate(name);
return(engine.CompileRenderStringAsync(name, content, model).Result);
}
static async Task Main(string[] args)
{
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
var template = "Hello, @Model.Bar";
var model = new Foo {
Bar = "Bar"
};
// Each template must have a templateKey that is associated with it, so you can render the same template next time without recompilation
const string key = "templateKey";
string result = await engine.CompileRenderStringAsync(key, template, model);
Console.WriteLine(result); // Hello, Bar
var cacheResult = engine.Handler.Cache.RetrieveTemplate(key);
if (cacheResult.Success)
{
var templatePage = cacheResult.Template.TemplatePageFactory();
result = await engine.RenderTemplateAsync(templatePage, new Foo()
{
Bar = "bar"
});
Console.WriteLine(result); // Hello, bar
}
await FileSourceTemplatesAsync();
await EmbeddedResourceTemplatesAsync();
}
/// <summary>
/// 生成ボタン
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <IActionResult> OnPostGenerateAsync(long id)
{
try
{
// エンジンを生成
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.DisableEncoding()
.Build();
// 対象のExcelを読み込む
var data = _db.ExcelFiles.First(x => x.Id == id);
Dictionary <string, List <List <string> > > excel = null;
using (var stream = new MemoryStream(data.Xlsx))
{
excel = RazorHelper.ReadExcel(stream, true);
}
// 外部生成
var outInput = await GenerateOut(excel, engine);
// Modelの作成
dynamic model;
model = RazorHelper.CreateModel(excel, outInput);
// 一時出力先を作成
string outPath = Path.Combine(_hostEnvironment.WebRootPath, "temp");
RazorHelper.DeleteDirectory(outPath, true); // linuxだとパーミッションが消えてダウンロードできなくなるので最初のフォルダは残す
RazorHelper.SafeCreateDirectory(outPath);
// 一時ファイル消す
RazorHelper.DeleteFiles(outPath);
// リストを読んでソース生成する
// ↓この"RootList"は動的に変えられないので、ファイル生成の一覧となるListシートの名前は"RootList"固定にする。
var outFileList = new List <string>();
var razorFileDirectry = Path.Combine(_hostEnvironment.WebRootPath, SystemConstants.FileDirectory, "razors");
// 各ソース生成
List <dynamic> generatedSource = await GenerateSource(model, engine);
for (int i = 0; i < model.RootList.Count; i++)
{
// ファイル名生成（絶対かぶらないように）
var resultFilename = await engine.CompileRenderStringAsync(
$"{model.RootList[i].Name}Name{i}",
model.RootList[i].OutputFileName,
new
{
model.RootList[i].Name,
model.RootList[i].Camel,
model.RootList[i].Pascal,
model.RootList[i].Plural,
model.RootList[i].Hyphen,
model.RootList[i].Snake,
model.RootList[i].CamelPlural,
model.RootList[i].PascalPlural
});
// 生成したファイルを一時保存
// VisualStudioが勘違いを起こすのでファイル末尾に"_"をつける
var outFileName = $"{resultFilename}_";
outFileList.Add(outFileName);
// ディレクトリ分けしたZipを作成する
RazorHelper.SafeCreateDirectory(Path.Combine(outPath, Path.GetDirectoryName(outFileName)));
System.IO.File.WriteAllText(Path.Combine(outPath, outFileName), generatedSource[i], Encoding.UTF8);
}
// 圧縮ファイルの準備
string dateFormat = "yyyyMMddHHmmss";
string outFilePath = Path.Combine(outPath, $"{DateTime.UtcNow.ToString(dateFormat)}.zip");
// 一時保存したファイルをZipにする
using (ZipArchive archive = ZipFile.Open(outFilePath, ZipArchiveMode.Create))
{
foreach (var item in outFileList)
{
archive.CreateEntryFromFile(
Path.Combine(outPath, $"{item}"),
$"{item.TrimEnd('_')}", // ここでスラッシュを入れると、ディレクトリ分けしたZipが作成できる
CompressionLevel.NoCompression
);
}
}
return(File(new FileStream(outFilePath, FileMode.Open), "application/zip", $"{data.RawFileName}.zip"));
}
catch (Exception e)
{
ViewData["Error"] = e.Message;
return(await OnGetAsync());
}
}
public override string ExecuteHtml(string tableName, OperationPackage package)
{
string date = $"{DateTime.Now:dd.MM.yy HH:mm:ss}";
if (!package.DataSets.Any())
{
return("No information obtained by query");
}
var packageValues = PackageParser.GetPackageValues(package);
var dataSet = packageValues.First();
var groupColumns = dataSet.GroupColumns;
var grouping = GetMergedRows(dataSet.Rows, groupColumns, groupColumns);
var groupedT = CreateGroupedHtmlTable(grouping);
groupedT = groupedT.Replace("@", "@"); //needed '@' symbol escaping for proper razorengine work
string tableTemplate =
@"<!DOCTYPE html>
<html>
<head>
<META http-equiv=""Content-Type"" content=""text/html; charset=utf-8"">
<title>ReportServer</title>
<link rel=""stylesheet"" href=""https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css"">
<style>
table
{
border-collapse: collapse;
width: 80%;
}
th, td
{
border: 1px solid Black;
padding: 10px;
}
</style>
</head>
<body>"
+
$@"<h3 align=""center"">{tableName}</h3>"
+
@"<table class=""table table-bordered"">
<tr>
@foreach(var header in @Model.Headers)
{
<th> @header </th>
}
</tr>"
+
groupedT
+
@"</table>
</body>
</html>";
var headers = ChangeHeadersOrder(dataSet.Headers, groupColumns);
var model = new
{
Headers = headers,
Date = date
};
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
var result = engine.CompileRenderStringAsync("templateKey", tableTemplate, model).Result;
return(result);
}