/// <summary>
/// Validate the model
/// </summary>
/// <param name="context">the validation context</param>
/// <returns></returns>
public IEnumerable <ValidationResult> Validate(ValidationContext context)
{
var templateService = HostContainer.GetInstance <IWidgetTemplateService>();
var localizedResourceService = HostContainer.GetInstance <IEzCMSLocalizedResourceService>();
if (templateService.IsTemplateNameExisted(Id, Name))
{
yield return(new ValidationResult(localizedResourceService.T("WidgetTemplate_Message_ExistingName"), new[] { "Name" }));
}
var type = Type.GetType(DataType);
if (type != null)
{
var razorValidMessage = EzRazorEngineHelper.ValidateTemplate(Name, FullContent, type);
if (!string.IsNullOrEmpty(razorValidMessage))
{
yield return(new ValidationResult(string.Format(localizedResourceService.T("WidgetTemplate_Message_FullContentCompileFailure"), razorValidMessage), new[] { "FullContent" }));
}
//Generate content from widgets
var content = WidgetHelper.GetFullTemplate(Content, string.Empty, string.Empty, DataType, Shortcuts);
razorValidMessage = EzRazorEngineHelper.ValidateTemplate(Name, content, type);
if (!string.IsNullOrEmpty(razorValidMessage))
{
yield return(new ValidationResult(string.Format(localizedResourceService.T("WidgetTemplate_Message_ContentCompileFailure"), razorValidMessage), new[] { "Content" }));
}
razorValidMessage = EzRazorEngineHelper.ValidateTemplate(Name, Script, type);
if (!string.IsNullOrEmpty(razorValidMessage))
{
yield return(new ValidationResult(string.Format(localizedResourceService.T("WidgetTemplate_Message_ScriptCompileFailure"), razorValidMessage), new[] { "Script" }));
}
razorValidMessage = EzRazorEngineHelper.ValidateTemplate(Name, Style, type);
if (!string.IsNullOrEmpty(razorValidMessage))
{
yield return(new ValidationResult(string.Format(localizedResourceService.T("WidgetTemplate_Message_StyleCompileFailure"), razorValidMessage), new[] { "Style" }));
}
if (Shortcuts != null)
{
var widgetValidationMessages = new Dictionary <string, string>();
foreach (var widget in Shortcuts)
{
razorValidMessage = EzRazorEngineHelper.ValidateTemplate(widget.Name, widget.Content, type);
if (!string.IsNullOrEmpty(razorValidMessage))
{
widgetValidationMessages.Add(widget.Name, razorValidMessage);
}
}
if (widgetValidationMessages.Any())
{
var message = string.Join(FrameworkConstants.BreakLine, widgetValidationMessages.Select(widget => localizedResourceService.TFormat("WidgetTemplate_Message_WidgetCompileFailure", widget.Key, widget.Value)));
yield return(new ValidationResult(message, new[] { "Widgets" }));
}
}
}
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
var localizedResourceService = HostContainer.GetInstance <IEzCMSLocalizedResourceService>();
var type = Type.GetType(DataType);
if (type != null)
{
var razorValidMessage = string.Empty;
try
{
var cacheName = Subject.GetTemplateCacheName(Body);
EzRazorEngineHelper.TryCompileAndAddTemplate(Body, cacheName, type);
}
catch (TemplateParsingException exception)
{
razorValidMessage = exception.Message;
}
catch (TemplateCompilationException exception)
{
razorValidMessage = string.Join("\n", exception.CompilerErrors.Select(e => e.ErrorText));
}
catch (Exception exception)
{
razorValidMessage = exception.Message;
}
if (!string.IsNullOrEmpty(razorValidMessage))
{
yield return(new ValidationResult(string.Format(localizedResourceService.T("EmailTemplate_Message_TemplateCompileFailure"), razorValidMessage), new[] { "Body" }));
}
}
}
/// <summary>
/// Render template using RazorEngine
/// </summary>
/// <param name="templateName"></param>
/// <param name="model"></param>
/// <param name="viewBag"></param>
/// <returns></returns>
public MvcHtmlString RenderTemplate(string templateName, dynamic model, dynamic viewBag)
{
var template = _widgetTemplateService.GetTemplateByName(templateName);
if (template != null)
{
return(new MvcHtmlString(EzRazorEngineHelper.CompileAndRun(template.Content, model, viewBag, template.CacheName)));
}
return(new MvcHtmlString(string.Empty));
}
/// <summary>
/// Render widget
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public override string Render(string[] parameters)
{
ParseParams(parameters);
var model = new LocatorWidget(Country);
var template = _widgetTemplateService.GetTemplateByName(Template) ??
_widgetTemplateService.GetTemplateByName(GetSetup().DefaultTemplate);
return EzRazorEngineHelper.CompileAndRun(template.Content, model, null, template.CacheName);
}
/// <summary>
/// Generate virtual file from template
/// </summary>
/// <param name="virtualPath"></param>
/// <param name="template"></param>
public EzCMSVirtualFile(string virtualPath, PageTemplate template)
: base(virtualPath)
{
var pageService = HostContainer.GetInstance <IPageService>();
var pageId = WorkContext.ActivePageId;
var model = pageService.RenderContent(pageId);
// Get raw page template
var rawMasterHtml = template.Content;
if (template.ParentId.HasValue)
{
rawMasterHtml = rawMasterHtml.InsertMasterPage(template.Parent.CacheName).ParseProperties(typeof(PageRenderModel));
}
//Replace the @RenderBody() with markup to disable rendering body
rawMasterHtml = rawMasterHtml.Replace(EzCMSContants.RenderBody, EzCMSContants.RenderBodyWidget);
//Render master html
var masterCacheName = template.Name.GetTemplateCacheName(rawMasterHtml);
var masterHtml = EzRazorEngineHelper.CompileAndRun(rawMasterHtml, model, null, masterCacheName);
// Parse the html
masterHtml = masterHtml.ResolveContent();
//Adding the @RenderBody() back to use the template as Master
masterHtml = masterHtml.Replace(EzCMSContants.RenderBodyWidget,
EzCMSContants.RenderBody);
//Convert content to Unicode
//using (var memoryStream = new MemoryStream())
//{
// using (var writer = new StreamWriter(memoryStream, new UnicodeEncoding()))
// {
// writer.Write(content);
// _data = memoryStream.ToArray();
// }
//}
_data = Encoding.UTF8.GetBytes(masterHtml);
var firstBytes = new byte[]
{
239, 187, 191
};
int newSize = firstBytes.Length + _data.Length;
var ms = new MemoryStream(new byte[newSize], 0, newSize, true, true);
ms.Write(firstBytes, 0, firstBytes.Length);
ms.Write(_data, 0, _data.Length);
_data = ms.GetBuffer();
}
/// <summary>
/// Parse the Subscription
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="template"></param>
/// <param name="model"></param>
/// <returns></returns>
public SubscriptionTemplateResponseModel ParseSubscription <TModel>(SubscriptionTemplate template, TModel model)
{
if (template == null)
{
return(null);
}
var bodyCacheName = template.Body.GetEnumName().GetTemplateCacheName(template.Body);
var response = new SubscriptionTemplateResponseModel
{
Body = EzRazorEngineHelper.CompileAndRun(template.Body, model, bodyCacheName)
};
return(response);
}
/// <summary>
/// Parse the notification
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="template"></param>
/// <param name="model"></param>
/// <returns></returns>
public NotificationTemplateResponseModel ParseNotification <TModel>(NotificationTemplate template, TModel model)
{
if (template == null)
{
return(null);
}
var cacheName = template.Module.GetEnumName().GetTemplateCacheName(template.Body);
var response = new NotificationTemplateResponseModel
{
Subject = template.Subject,
Body = EzRazorEngineHelper.CompileAndRun(template.Body, model, cacheName)
};
return(response);
}
/// <summary>
/// Validate the model
/// </summary>
/// <param name="context">the validation context</param>
/// <returns></returns>
public IEnumerable <ValidationResult> Validate(ValidationContext context)
{
var widgetService = HostContainer.GetInstance <IWidgetService>();
var localizedResourceService = HostContainer.GetInstance <IEzCMSLocalizedResourceService>();
if (_pageTemplateService.IsPageTemplateNameExisted(Id, Name))
{
yield return(new ValidationResult(localizedResourceService.T("PageTemplate_Message_ExistingName"), new[] { "Name" }));
}
//Check if content is valid
if (widgetService.IsPageTemplateValid(Content))
{
yield return(new ValidationResult(localizedResourceService.T("PageTemplate_Message_InvalidContentFormat"), new[] { "Content" }));
}
var razorValidMessage = string.Empty;
try
{
var cacheName = Name.GetTemplateCacheName(Content);
// Template is updated here
EzRazorEngineHelper.TryCompileAndAddTemplate(Content, cacheName, typeof(PageRenderModel), ResolveType.Layout);
}
catch (TemplateParsingException exception)
{
razorValidMessage = exception.Message;
}
catch (TemplateCompilationException exception)
{
razorValidMessage = string.Join("\n", exception.CompilerErrors.Select(e => e.ErrorText));
}
catch (Exception exception)
{
razorValidMessage = exception.Message;
}
if (!string.IsNullOrEmpty(razorValidMessage))
{
yield return(new ValidationResult(string.Format(localizedResourceService.T("PageTemplate_Message_TemplateCompileFailure"), razorValidMessage), new[] { "Content" }));
}
}
/// <summary>
/// Render widget
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public override string Render(string[] parameters)
{
ParseParams(parameters);
if (LocationId == 0)
{
return(string.Empty);
}
var model = _locationService.GetLocationWidget(LocationId);
if (model == null)
{
return(_localizedResourceService.T("Widget_Location_Message_LocationNotFound"));
}
var template = _widgetTemplateService.GetTemplateByName(Template) ??
_widgetTemplateService.GetTemplateByName(GetSetup().DefaultTemplate);
return(EzRazorEngineHelper.CompileAndRun(template.Content, model, null, template.CacheName));
}
/// <summary>
/// Parse the email from template and model
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="template"></param>
/// <param name="model"></param>
/// <returns></returns>
public EmailTemplateResponseModel ParseEmail <TModel>(EmailTemplate template, TModel model)
{
if (template == null)
{
return(null);
}
var subjectCacheName = template.Type.GetEnumName().GetTemplateCacheName(template.Subject);
var bodyCacheName = template.Type.GetEnumName().GetTemplateCacheName(template.Body);
var response = new EmailTemplateResponseModel
{
From = template.From,
FromName = template.FromName,
CC = MailUtilities.FormatEmailList(template.CC),
CCList = MailUtilities.ParseEmailList(template.CC),
BCC = MailUtilities.FormatEmailList(template.BCC),
BCCList = MailUtilities.ParseEmailList(template.BCC),
Subject = EzRazorEngineHelper.CompileAndRun(template.Subject, model, subjectCacheName),
Body = EzRazorEngineHelper.CompileAndRun(template.Body, model, bodyCacheName)
};
return(response);
}
/// <summary>
/// Render template using RazorEngine
/// </summary>
/// <param name="templateName"></param>
/// <param name="templateContent"></param>
/// <param name="model"></param>
/// <param name="viewBag"></param>
/// <returns></returns>
public MvcHtmlString RenderTemplate(string templateName, string templateContent, dynamic model, dynamic viewBag)
{
return(new MvcHtmlString(EzRazorEngineHelper.CompileAndRun(templateContent, model, viewBag, templateName.GetTemplateCacheName(templateContent))));
}
/// <summary>
/// Add template to cache
/// </summary>
/// <param name="template"></param>
/// <param name="cacheName"></param>
/// <param name="type"></param>
/// <param name="resolveType"></param>
public static ITemplateKey TryCompileAndAddTemplate(string template, string cacheName, Type type, ResolveType resolveType = ResolveType.Global)
{
return(EzRazorEngineHelper.TryCompileAndAddTemplate(template, cacheName, type, resolveType));
}
/// <summary>
/// Get cache template name
/// </summary>
/// <param name="templateName"></param>
/// <param name="content"></param>
/// <returns></returns>
public static string GetTemplateCacheName(this string templateName, string content)
{
return(EzRazorEngineHelper.GetTemplateCacheName(templateName, content));
}
/// <summary>
/// Render template using Razor engine
/// </summary>
/// <param name="template"></param>
/// <param name="model"></param>
/// <param name="cacheName"></param>
/// <param name="resolveType"></param>
/// <returns></returns>
public static string CompileAndRun(string template, dynamic model, string cacheName = "", ResolveType resolveType = ResolveType.Global)
{
return(EzRazorEngineHelper.CompileAndRun(template, model, null, cacheName, resolveType));
}
/// <summary>
/// Reset cache name for all hierarchies templates of page
/// If null then reset all the application
/// </summary>
/// <param name="pageTemplateId"></param>
public void Initialize(int?pageTemplateId = null)
{
var currentPageTemplate = GetById(pageTemplateId);
// Get all templates
List <PageTemplate> pageTemplates;
// If has current template, then only refresh the Template tree
if (currentPageTemplate != null)
{
pageTemplates = _pageTemplateRepository.GetHierarchies(currentPageTemplate).ToList();
}
// If no current template then reload all trees
else
{
pageTemplates = GetAll().OrderBy(t => t.Hierarchy).ToList();
}
// Reset all effected templates
foreach (var pageTemplate in pageTemplates)
{
var template = pageTemplate.Content.ParseProperties(typeof(PageRenderModel));
var parentTemplate = GetById(pageTemplate.ParentId);
//If parent template cache name is null, then it has parsing errors and all children templates is not valid
if (parentTemplate != null && string.IsNullOrEmpty(parentTemplate.CacheName))
{
pageTemplate.IsValid = false;
pageTemplate.CacheName = string.Empty;
pageTemplate.CompileMessage = parentTemplate.CompileMessage;
}
//Generate child template with parent as master
else if (parentTemplate != null)
{
var parentCacheName = parentTemplate.CacheName;
template = template.InsertMasterPage(parentCacheName);
// Generate new template cache name base on parent Template and content
pageTemplate.CacheName = pageTemplate.Name.GetTemplateCacheName(template);
}
else
{
pageTemplate.CacheName = pageTemplate.Name.GetTemplateCacheName(template);
}
if (!string.IsNullOrEmpty(pageTemplate.CacheName))
{
var compileMessage = string.Empty;
try
{
var templateKey = EzRazorEngineHelper.TryCompileAndAddTemplate(template, pageTemplate.CacheName,
typeof(PageRenderModel), ResolveType.Layout);
pageTemplate.IsValid = true;
pageTemplate.CompileMessage = string.Empty;
pageTemplate.CacheName = templateKey.Name;
}
catch (TemplateParsingException exception)
{
compileMessage = exception.Message;
}
catch (TemplateCompilationException exception)
{
compileMessage = string.Join("\n", exception.CompilerErrors.Select(e => e.ErrorText));
}
catch (Exception exception)
{
compileMessage = exception.Message;
}
finally
{
if (!string.IsNullOrEmpty(compileMessage))
{
pageTemplate.IsValid = false;
pageTemplate.CompileMessage = TFormat("PageTemplate_Message_InvalidPageTemplate",
pageTemplate.Name, compileMessage);
pageTemplate.CacheName = string.Empty;
}
}
}
Update(pageTemplate);
}
}
/// <summary>
/// Parse template
/// </summary>
/// <param name="template"></param>
/// <param name="model"></param>
/// <param name="viewbag"></param>
/// <returns></returns>
public string ParseTemplate(WidgetTemplateRenderModel template, dynamic model, dynamic viewbag = null)
{
return(EzRazorEngineHelper.CompileAndRun(template.Content, model, viewbag, template.CacheName));
}
/// <summary>
/// Validate template
/// </summary>
/// <param name="name"></param>
/// <param name="content"></param>
/// <param name="type"></param>
/// <returns></returns>
public static string ValidateTemplate(string name, string content, Type type)
{
return(EzRazorEngineHelper.ValidateTemplate(name, content, type));
}
