public override Task GetContentItemAspectAsync(ContentItemAspectContext context, HtmlBodyPart part)
{
return(context.ForAsync <BodyAspect>(async bodyAspect =>
{
if (_bodyAspect != null)
{
bodyAspect.Body = _bodyAspect;
return;
}
try
{
var model = new HtmlBodyPartViewModel()
{
Html = part.Html,
HtmlBodyPart = part,
ContentItem = part.ContentItem
};
var result = await _liquidTemplateManager.RenderAsync(part.Html, _htmlEncoder, model,
scope => scope.SetValue("ContentItem", model.ContentItem));
bodyAspect.Body = _bodyAspect = new HtmlString(result);
}
catch
{
bodyAspect.Body = HtmlString.Empty;
}
}));
}
private static async Task <object> RenderHtml(ResolveFieldContext <HtmlBodyPart> ctx)
{
var serviceProvider = ctx.ResolveServiceProvider();
var shortcodeService = serviceProvider.GetRequiredService <IShortcodeService>();
var contentDefinitionManager = serviceProvider.GetRequiredService <IContentDefinitionManager>();
var contentTypeDefinition = contentDefinitionManager.GetTypeDefinition(ctx.Source.ContentItem.ContentType);
var contentTypePartDefinition = contentTypeDefinition.Parts.FirstOrDefault(x => string.Equals(x.PartDefinition.Name, "HtmlBodyPart"));
var settings = contentTypePartDefinition.GetSettings <HtmlBodyPartSettings>();
var html = ctx.Source.Html;
if (!settings.SanitizeHtml)
{
var model = new HtmlBodyPartViewModel()
{
Html = ctx.Source.Html,
HtmlBodyPart = ctx.Source,
ContentItem = ctx.Source.ContentItem
};
var liquidTemplateManager = serviceProvider.GetRequiredService <ILiquidTemplateManager>();
var htmlEncoder = serviceProvider.GetService <HtmlEncoder>();
html = await liquidTemplateManager.RenderAsync(html, htmlEncoder, model,
scope => scope.SetValue("ContentItem", model.ContentItem));
}
return(await shortcodeService.ProcessAsync(html,
new Context
{
["ContentItem"] = ctx.Source.ContentItem,
["TypePartDefinition"] = contentTypePartDefinition
}));
}
public override Task GetContentItemAspectAsync(ContentItemAspectContext context, HtmlBodyPart part)
{
return context.ForAsync<BodyAspect>(async bodyAspect =>
{
if (_bodyAspect != null)
{
bodyAspect.Body = _bodyAspect;
return;
}
try
{
var model = new HtmlBodyPartViewModel()
{
Html = part.Html,
HtmlBodyPart = part,
ContentItem = part.ContentItem
};
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", part.ContentItem);
templateContext.MemberAccessStrategy.Register<HtmlBodyPartViewModel>();
templateContext.SetValue("Model", model);
var result = await _liquidTemplateManager.RenderAsync(part.Html, _htmlEncoder, templateContext);
bodyAspect.Body = _bodyAspect = new HtmlString(result);
}
catch
{
bodyAspect.Body = HtmlString.Empty;
}
});
}
private async ValueTask BuildViewModelAsync(HtmlBodyPartViewModel model, HtmlBodyPart htmlBodyPart)
{
model.Html = htmlBodyPart.Html;
model.HtmlBodyPart = htmlBodyPart;
model.ContentItem = htmlBodyPart.ContentItem;
model.Html = await _liquidTemplateManager.RenderAsync(htmlBodyPart.Html, _htmlEncoder, model,
scope => scope.SetValue("ContentItem", model.ContentItem));
}
public override async Task <IDisplayResult> UpdateAsync(HtmlBodyPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new HtmlBodyPartViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Source);
model.Html = viewModel.Source;
return(Edit(model, context));
}
private async ValueTask BuildViewModelAsync(HtmlBodyPartViewModel model, HtmlBodyPart htmlBodyPart, HtmlBodyPartSettings settings)
{
model.Html = htmlBodyPart.Html;
model.HtmlBodyPart = htmlBodyPart;
model.ContentItem = htmlBodyPart.ContentItem;
if (!settings.SanitizeHtml)
{
model.Html = await _liquidTemplateManager.RenderAsync(htmlBodyPart.Html, _htmlEncoder, model,
scope => scope.SetValue("ContentItem", model.ContentItem));
}
model.Html = await _shortCodeService.ProcessAsync(model.Html);
}
private async ValueTask BuildViewModelAsync(HtmlBodyPartViewModel model, HtmlBodyPart htmlBodyPart)
{
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", htmlBodyPart.ContentItem);
templateContext.MemberAccessStrategy.Register <HtmlBodyPartViewModel>();
model.Html = htmlBodyPart.Html;
model.HtmlBodyPart = htmlBodyPart;
model.ContentItem = htmlBodyPart.ContentItem;
templateContext.SetValue("Model", model);
model.Html = await _liquidTemplatemanager.RenderAsync(htmlBodyPart.Html, _htmlEncoder, templateContext);
}
public override Task GetContentItemAspectAsync(ContentItemAspectContext context, HtmlBodyPart part)
{
return(context.ForAsync <BodyAspect>(async bodyAspect =>
{
if (bodyAspect != null && part.ContentItem.Id == _contentItemId)
{
bodyAspect.Body = _bodyAspect;
return;
}
try
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(part.ContentItem.ContentType);
var contentTypePartDefinition = contentTypeDefinition.Parts.FirstOrDefault(x => string.Equals(x.PartDefinition.Name, "HtmlBodyPart"));
var settings = contentTypePartDefinition.GetSettings <HtmlBodyPartSettings>();
var html = part.Html;
if (!settings.SanitizeHtml)
{
var model = new HtmlBodyPartViewModel()
{
Html = part.Html,
HtmlBodyPart = part,
ContentItem = part.ContentItem
};
html = await _liquidTemplateManager.RenderAsync(html, _htmlEncoder, model,
scope => scope.SetValue("ContentItem", model.ContentItem));
}
html = await _shortcodeService.ProcessAsync(html,
new Context
{
["ContentItem"] = part.ContentItem,
["TypePartDefinition"] = contentTypePartDefinition
});
bodyAspect.Body = _bodyAspect = new HtmlString(html);
_contentItemId = part.ContentItem.Id;
}
catch
{
bodyAspect.Body = HtmlString.Empty;
_contentItemId = default;
}
}));
}
private static async Task <object> RenderHtml(ResolveFieldContext <HtmlBodyPart> ctx)
{
var serviceProvider = ctx.ResolveServiceProvider();
var liquidTemplateManager = serviceProvider.GetService <ILiquidTemplateManager>();
var htmlEncoder = serviceProvider.GetService <HtmlEncoder>();
var model = new HtmlBodyPartViewModel()
{
Html = ctx.Source.Html,
HtmlBodyPart = ctx.Source,
ContentItem = ctx.Source.ContentItem
};
return(await liquidTemplateManager.RenderAsync(ctx.Source.Html, htmlEncoder, model,
scope => scope.SetValue("ContentItem", model.ContentItem)));
}
private async Task BuildViewModelAsync(HtmlBodyPartViewModel model, HtmlBodyPart HtmlBodyPart, ContentTypePartDefinition definition)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(HtmlBodyPart.ContentItem.ContentType);
var contentTypePartDefinition = contentTypeDefinition.Parts.FirstOrDefault(p => p.Name == nameof(HtmlBodyPart));
var settings = contentTypePartDefinition.GetSettings <HtmlBodyPartSettings>();
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", HtmlBodyPart.ContentItem);
templateContext.MemberAccessStrategy.Register <HtmlBodyPartViewModel>();
model.Html = await _liquidTemplatemanager.RenderAsync(HtmlBodyPart.Html, HtmlEncoder.Default, templateContext);
model.ContentItem = HtmlBodyPart.ContentItem;
model.Source = HtmlBodyPart.Html;
model.HtmlBodyPart = HtmlBodyPart;
model.TypePartDefinition = definition;
}
public override async Task <IDisplayResult> UpdateAsync(HtmlBodyPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new HtmlBodyPartViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Html))
{
if (!string.IsNullOrEmpty(viewModel.Html) && !_liquidTemplateManager.Validate(viewModel.Html, out var errors))
{
var partName = context.TypePartDefinition.DisplayName();
context.Updater.ModelState.AddModelError(nameof(model.Html), S["{0} doesn't contain a valid Liquid expression. Details: {1}", partName, string.Join(" ", errors)]);
}
else
{
model.Html = viewModel.Html;
}
}
return(Edit(model, context));
}
private async ValueTask BuildViewModelAsync(HtmlBodyPartViewModel model, HtmlBodyPart htmlBodyPart, BuildPartDisplayContext context)
{
model.Html = htmlBodyPart.Html;
model.HtmlBodyPart = htmlBodyPart;
model.ContentItem = htmlBodyPart.ContentItem;
var settings = context.TypePartDefinition.GetSettings <HtmlBodyPartSettings>();
if (!settings.SanitizeHtml)
{
model.Html = await _liquidTemplateManager.RenderAsync(htmlBodyPart.Html, _htmlEncoder, model,
scope => scope.SetValue("ContentItem", model.ContentItem));
}
model.Html = await _shortcodeService.ProcessAsync(model.Html,
new Context
{
["ContentItem"] = htmlBodyPart.ContentItem,
["TypePartDefinition"] = context.TypePartDefinition
});
}
private static async Task <object> RenderHtml(ResolveFieldContext <HtmlBodyPart> ctx)
{
var serviceProvider = ctx.ResolveServiceProvider();
var liquidTemplateManager = serviceProvider.GetService <ILiquidTemplateManager>();
var htmlEncoder = serviceProvider.GetService <HtmlEncoder>();
var model = new HtmlBodyPartViewModel()
{
HtmlBodyPart = ctx.Source,
ContentItem = ctx.Source.ContentItem
};
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", ctx.Source.ContentItem);
templateContext.MemberAccessStrategy.Register <HtmlBodyPartViewModel>();
templateContext.SetValue("Model", model);
return(await liquidTemplateManager.RenderAsync(ctx.Source.Html, htmlEncoder, templateContext));
}
public override async Task <IDisplayResult> UpdateAsync(ContentItem model, UpdateEditorContext context)
{
var htmlBodyPart = model.As <HtmlBodyPart>();
if (htmlBodyPart == null)
{
return(null);
}
var typePartDefintion = GetContentTypePartDefinition(htmlBodyPart);
// If it's a FroalaEditor editor the files are automatically handled by _attachedMediaFieldFileService
if (String.Equals(typePartDefintion?.Editor, "FroalaEditor", StringComparison.OrdinalIgnoreCase))
{
var viewModel = new HtmlBodyPartViewModel();
if (await context.Updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Html))
{
//var settings = context.TypePartDefinition.GetSettings<HtmlBodyPartSettings>();
var settings = GetPartSettings(htmlBodyPart);
// Deserializing an empty string doesn't return an array
var items = string.IsNullOrWhiteSpace(viewModel.Paths)
? new List <EditMediaFieldItemInfo>()
: JsonConvert.DeserializeObject <EditMediaFieldItemInfo[]>(viewModel.Paths).ToList();
if (items.Any())
{
try
{
await _attachedMediaToContentItemService.HandleFilesOnContentPartUpdateAsync(items,
model.ContentItem);
//replace body temp file paths with new folder paths
//because froala encodes url paths to avoid xss must decode first before finding and replacing paths
var decodedHtml = HttpUtility.UrlDecode(viewModel.Html);
foreach (var mediaFieldItemInfo in items)
{
if (!String.IsNullOrEmpty(mediaFieldItemInfo.NewPath))
{
// vm.Body= vm.Body.Replace(mediaFieldItemInfo.Path, mediaFieldItemInfo.NewPath);
decodedHtml = decodedHtml?.Replace(mediaFieldItemInfo.Path,
mediaFieldItemInfo.NewPath);
}
}
//set back html to viewmodel
viewModel.Html = decodedHtml;
}
catch (Exception)
{
context.Updater.ModelState.AddModelError(Prefix,
S["{0}: There was an error handling the files.",
typePartDefintion?.DisplayName]);
}
htmlBodyPart.Html = settings.SanitizeHtml
? _htmlSanitizerService.Sanitize(viewModel.Html)
: viewModel.Html;
}
}
}
return(await EditAsync(model, context));
}
