public void RazorEngineService_TestInvalidatingCachingProvider()
{
var cache = new InvalidatingCachingProvider();
var mgr = new DelegateTemplateManager();
var template =
@"@if (Model.MyPrice == 0) {
<text>free</text>
} else {
<text>@Model.MyPrice</text>
}";
var template2 =
@"@if (Model.MyPrice == 0) {
<text>totally free</text>
} else {
<text>@Model.MyPrice</text>
}";
RunTestHelper(service =>
{
var model = new { MyPrice = 0 };
string result = service.RunCompile(template, "key", null, model);
Assert.AreEqual("free", result.Trim());
cache.InvalidateCache(service.GetKey("key"));
mgr.RemoveDynamic(service.GetKey("key"));
string result2 = service.RunCompile(template2, "key", null, model);
Assert.AreEqual("totally free", result2.Trim());
}, config => {
config.CachingProvider = cache;
config.TemplateManager = mgr;
});
}
public void RazorEngineService_TestWatchingResolvePathTemplateManager()
{
var temp = Path.GetTempFileName();
var template2File = Path.GetTempFileName();
File.Delete(temp);
var prev = Environment.GetEnvironmentVariable("MONO_MANAGED_WATCHER");
try
{
if (IsolatedRazorEngineServiceTestFixture.IsRunningOnMono())
{
Environment.SetEnvironmentVariable("MONO_MANAGED_WATCHER", "enabled");
}
Directory.CreateDirectory(temp);
var cache = new InvalidatingCachingProvider();
var mgr = new WatchingResolvePathTemplateManager(new [] { temp }, cache);
var template = @"initial";
var templateChanged = @"next";
var templateFileName = Path.ChangeExtension(Path.GetRandomFileName(), ".cshtml");
var templateName = Path.GetFileNameWithoutExtension(templateFileName);
var templateFile = Path.Combine(temp, templateFileName);
File.WriteAllText(templateFile, template);
RunTestHelper(service =>
{
var model = new { MyPrice = 0 };
string result = service.RunCompile(templateFileName, null, model);
Assert.AreEqual("initial", result.Trim());
File.WriteAllText(templateFile, templateChanged);
Thread.Sleep(2000); // wait for the events to kick in.
string result2 = service.RunCompile(templateFileName, null, model);
Assert.AreEqual("next", result2.Trim());
}, config =>
{
config.CachingProvider = cache;
config.TemplateManager = mgr;
});
}
finally
{
Environment.SetEnvironmentVariable("MONO_MANAGED_WATCHER", prev);
Directory.Delete(temp, true);
if (File.Exists(template2File))
{
File.Delete(template2File);
}
}
}
public FileWatchDebugTemplateManager(string layoutRoot, InvalidatingCachingProvider cachingProvider)
{
m_cachingProvider = cachingProvider;
m_templateManager = new ResolvePathTemplateManager(new[] { layoutRoot });
m_fileWatcher = new SafeFileWatcher(Path.GetFullPath(layoutRoot), "*.*")
{
EnableRaisingEvents = true,
IncludeSubdirectories = true
};
m_fileWatcher.Changed += m_fileWatcher_Changed;
m_fileWatcher.Created += m_fileWatcher_Changed;
m_fileWatcher.Deleted += m_fileWatcher_Changed;
m_fileWatcher.Renamed += m_fileWatcher_Changed;
}
public void RazorEngineService_TestResolvePathTemplateManager()
{
var cache = new InvalidatingCachingProvider();
var temp = Path.GetTempFileName();
var template2File = Path.GetTempFileName();
File.Delete(temp);
try
{
Directory.CreateDirectory(temp);
var mgr = new ResolvePathTemplateManager(new[] { temp });
var template = @"free";
var template2 = @"template2";
File.WriteAllText(template2File, template2);
var templateFileName = Path.ChangeExtension(Path.GetRandomFileName(), ".cshtml");
var templateName = Path.GetFileNameWithoutExtension(templateFileName);
var templateFile = Path.Combine(temp, templateFileName);
File.WriteAllText(templateFile, template);
RunTestHelper(service =>
{
var model = new { MyPrice = 0 };
string result = service.RunCompile(templateName, null, model);
Assert.AreEqual("free", result.Trim());
string result2 = service.RunCompile(template2File, null, model);
Assert.AreEqual("template2", result2.Trim());
}, config =>
{
config.CachingProvider = cache;
config.TemplateManager = mgr;
});
}
finally
{
Directory.Delete(temp, true);
if (File.Exists(template2File))
{
File.Delete(template2File);
}
}
}
public static string Render(string template, object model)
{
string result;
using (var cacheProvidxer = new InvalidatingCachingProvider())
{
var config = new TemplateServiceConfiguration
{
CachingProvider = cacheProvidxer,
BaseTemplateType = typeof(WebApiTemplateBase <>)
};
using (var service = RazorEngineService.Create(config))
{
result = service.RunCompile(GetTemplate(template), Guid.NewGuid().ToString(), null, model);
cacheProvidxer.InvalidateAll();
}
}
return(result);
}
public async Task <ActionResult> RegistrationSuccess()
{
var person = TempData["Person"] as Person;
var viewModel = TempData["RegistrationViewModel"] as RegistrationViewModel;
if (person == null || viewModel == null)
{
return(RedirectToAction("Index"));
}
ViewBag.Email = person.Email;
viewModel.ActivationUrl = Url.Action("Activation", "Account",
new { area = String.Empty, email = person.Email, activationCode = person.ChallangeCode },
protocol: Request.Url.Scheme);
var cacheProvider = new InvalidatingCachingProvider();
var config = new TemplateServiceConfiguration();
config.CachingProvider = cacheProvider;
var service = RazorEngineService.Create(config);
Engine.Razor = service;
var template = emailTemplateProvider.GetEmailTemplate(EmailTemplates.Registration);
var subject = Engine.Razor.RunCompile(template.Subject, "subject", typeof(RegistrationViewModel), viewModel);
cacheProvider.InvalidateAll();
var content = Engine.Razor.RunCompile(template.Content, "content", typeof(RegistrationViewModel), viewModel);
await mailer.SendMail(
String.Format("{0} {1}", person.FirstName, person.LastName),
person.Email,
template.Bcc,
subject,
content);
return(View());
}
public static Type GetModelTypeKey(Type modelType)
{
return(InvalidatingCachingProvider.GetModelTypeKey(modelType));
}
public WebMetalCachingProvider()
{
inner = new InvalidatingCachingProvider();
}
public InvalidatingTemplateManager(InvalidatingCachingProvider cachingProvider)
{
this._cachingProvider = cachingProvider;
}
/// <summary>
/// Creates a new <see cref="RazorEngine{TLanguage}"/> instance.
/// </summary>
/// <param name="templatePath">Template path for view files.</param>
public RazorEngine(string templatePath)
{
if (string.IsNullOrEmpty(templatePath))
{
throw new ArgumentNullException(nameof(templatePath));
}
TLanguage languageType = new TLanguage();
switch (languageType.ResolutionMode)
{
case RazorViewResolutionMode.ResolvePath:
case RazorViewResolutionMode.WatchingResolvePath:
if (!Directory.Exists(templatePath))
{
throw new DirectoryNotFoundException();
}
if (languageType.ResolutionMode == RazorViewResolutionMode.ResolvePath)
{
m_engineService = RazorEngineService.Create(new TemplateServiceConfiguration
{
Language = languageType.TargetLanguage,
TemplateManager = new ResolvePathTemplateManager(new[] { templatePath }),
Debug = false
});
}
else
{
// The watching resolve path template manager should not be used in production since
// assemblies cannot be unloaded from an AppDomain. Every time a change to a .cshtml
// file is picked up by the watcher it is compiled and loaded into the AppDomain and
// the old one cannot be removed (.NET restriction), the net result is a memory leak
InvalidatingCachingProvider cachingProvider = new InvalidatingCachingProvider();
m_engineService = RazorEngineService.Create(new TemplateServiceConfiguration
{
Language = languageType.TargetLanguage,
CachingProvider = cachingProvider,
TemplateManager = new WatchingResolvePathTemplateManager(new[] { templatePath }, cachingProvider),
Debug = true
});
}
break;
case RazorViewResolutionMode.EmbeddedResource:
m_engineService = RazorEngineService.Create(new TemplateServiceConfiguration
{
Language = languageType.TargetLanguage,
TemplateManager = new DelegateTemplateManager(name =>
{
string resourceName = name;
if (!resourceName.Contains("."))
{
resourceName = templatePath + name;
}
Stream stream = WebExtensions.OpenEmbeddedResourceStream(resourceName);
if ((object)stream == null)
{
return("");
}
using (StreamReader reader = new StreamReader(stream))
return(reader.ReadToEnd());
}),
Debug = false
});
break;
}
TemplatePath = templatePath;
}
public async Task <ActionResult> ResendActivationCode(FormCollection form)
{
try
{
var viewModel = new RegistrationViewModel();
var person = personProvider.GetPerson(form["email"]);
if (person != null)
{
if (person.ActivatedWhen.HasValue)
{
return(Json(new
{
Success = false,
ExceptionMessage = "Account " + form["email"] + " has been activated already."
}));
}
Mapper.DynamicMap(person, viewModel);
viewModel.ActivationUrl = Url.Action("Activation", "Account",
new { area = String.Empty, email = viewModel.Email, activationCode = viewModel.ChallangeCode },
protocol: Request.Url.Scheme);
var cacheProvider = new InvalidatingCachingProvider();
var config = new TemplateServiceConfiguration();
config.CachingProvider = cacheProvider;
var service = RazorEngineService.Create(config);
Engine.Razor = service;
cacheProvider.InvalidateAll();
var template = emailTemplateProvider.GetEmailTemplate(EmailTemplates.Registration);
var subject = Engine.Razor.RunCompile(template.Subject, "subject", typeof(RegistrationViewModel),
viewModel);
var content = Engine.Razor.RunCompile(template.Content, "content", typeof(RegistrationViewModel),
viewModel);
await mailer.SendMail(
String.Format("{0} {1}", viewModel.FirstName, viewModel.LastName),
viewModel.Email,
template.Bcc,
subject,
content);
}
else
{
return(Json(new
{
Success = false,
ExceptionMessage =
"Cannot find registration information for " + form["email"]
}));
}
}
catch (Exception ex)
{
return(Json(new
{
Success = false,
ExceptionMessage = ex.Message
}));
}
return(Json(new
{
Success = true
}));
}
