// TODO: something generic, move out of here
protected virtual bool IsInEditMode(ModelPropertyContext context)
{
var editMode = false;
var modeDetected = false;
var requestContext = context.ExecutionContext.RequestContext;
object contextMode;
if (requestContext.RouteData.DataTokens.TryGetValue("contextmode", out contextMode))
{
editMode = (ContextMode)contextMode == ContextMode.Edit;
modeDetected = true;
}
if (!modeDetected)
{
editMode = PageEditing.PageIsInEditMode;
}
// skip processing for block previews to render them in ordinary view mode
if (editMode && IsInBlockPreviewMode(context))
{
return(false);
}
return(editMode);
}
protected virtual bool FilterByType(ModelPropertyContext context)
{
return((context.Property.PropertyType.Is <IHtmlString>() &&
context.Property.PropertyType != typeof(ContentArea)) || // TODO: let's skip content areas for now
context.Property.PropertyType.GetCollectionItemType().IfNotNull(t => t.Is <IHtmlString>()) ||
(context.PropertyValue != null && context.PropertyValue.GetType().Is(typeof(EditableCollection <>))));
}
public virtual void Process(ModelPropertyContext context)
{
var url = (string)context.PropertyValue;
var friendlyUrl = _urlRewriter.GetFriendlyUrl(url, context.ExecutionContext.RequestContext, RouteTable.Routes);
context.PropertyValue = friendlyUrl;
}
public virtual void Process(ModelPropertyContext context)
{
var url = ((IHtmlString)context.PropertyValue).IfNotNull(x => x.ToHtmlString());
var friendlyUrl = _urlRewriter.GetFriendlyUrl(url, context.ExecutionContext.RequestContext, RouteTable.Routes);
context.PropertyValue = HtmlStringActivator.CreateInstance(context.Property.PropertyType, friendlyUrl);
}
public override void Process(ModelPropertyContext context)
{
base.Process(context);
var fieldHtml = InsertPageEditorMarkup(context, (IHtmlString)context.PropertyValue);
context.PropertyValue = fieldHtml; // TODO: we could have an exception here (different types of property and setting value)
}
private IHtmlString GetFieldEditHint(string editName, ModelPropertyContext context)
{
var editHint = context.Property.Get <EditHintAttribute>() ?? new EditHintAttribute();
var cssClassAttr = editHint.CssClass.IfNotNullOrEmpty(css => string.Format(" class=\"{0}\"", css));
var html = string.Format("<span{0}>[{1}]</span>", cssClassAttr, editName.ToFriendlyString());
return(new HtmlString(html));
}
public virtual void Process(ModelPropertyContext context)
{
var links = (IEnumerable <Link>)context.PropertyValue;
foreach (var link in links)
{
link.Url = _urlRewriter.GetFriendlyUrl(link.Url, context.ExecutionContext.RequestContext, RouteTable.Routes);
}
}
public override void Process(ModelPropertyContext context)
{
var editName = GetFieldEditName(context);
var fakeLink = new Link
{
Url = "#",
Text = "[" + editName.ToFriendlyString() + "]"
};
context.PropertyValue = new List <Link>(new[] { fakeLink });
}
public virtual void Process(ModelPropertyContext context)
{
if (context.Property.PropertyType.Is <IEnumerable>())
{
if (context.PropertyValue == null || !context.PropertyValue.GetType().Is(typeof(EditableCollection <>)))
{
var itemType = context.Property.PropertyType.GetCollectionItemType();
var collectionTemplate = typeof(EditableCollection <>).MakeGenericType(itemType);
context.PropertyValue = Activator.CreateInstance(collectionTemplate, context.PropertyValue);
}
}
}
private bool IsInBlockPreviewMode(ModelPropertyContext context)
{
if (context.Model.GetType().Name.EndsWith("BlockModel"))
{
var httpContext = context.ExecutionContext.RequestContext.HttpContext;
var contentStack = httpContext.Items[ContentContext.ContentContextKey] as Stack <ContentContext.ContentPropertiesStack>;
// TODO: check the stask and return true if the parent item is a content area.
return(false);
}
return(false);
}
public virtual void Process(ModelPropertyContext context)
{
var value = (XhtmlString)context.PropertyValue;
var result = new StringBuilder();
using (var writer = new StringWriter(result))
{
RenderXhtmlStringToWriter(value, writer,
context.ExecutionContext.Controller,
context.ExecutionContext.RequestContext
);
}
context.PropertyValue = HtmlStringActivator.CreateInstance(context.Property.PropertyType, result.ToString());
}
protected virtual string GetFieldEditName(ModelPropertyContext context)
{
var field = context.Property;
var editNameHint = field.Get <EditHintAttribute>().IfNotNull(x => x.EditName);
if (editNameHint.IsNotNullOrEmpty())
{
return(editNameHint);
}
if (field.Has <EditHintNoPrefixAttribute>())
{
return(field.Name);
}
var editPrefix = context.Model.GetType().Get <EditHintPrefixAttribute>().IfNotNull(x => x.EditPrefix);
return(editPrefix + field.Name);
}
private bool IsInBlockPreviewMode(ModelPropertyContext context)
{
if (!context.Model.GetType().Name.EndsWith("BlockModel"))
{
return(false);
}
var parentViewContext = context.ExecutionContext.ParentActionViewContext;
if (parentViewContext == null)
{
return(false);
}
var controllerType = parentViewContext.Controller.GetType();
return(!controllerType.Has <TemplateDescriptorAttribute>(
with: attr => attr.Tags.Contains(RenderingTags.Preview)
));
}
private IHtmlString InsertPageEditorMarkup(ModelPropertyContext context, IHtmlString fieldHtml)
{
var editHtml = fieldHtml is IEditHtmlString ? (IEditHtmlString)fieldHtml : new EditableHtmlString(fieldHtml);
var htmlBuilder = new StringBuilder();
var editHint = context.Property.Get <EditHintAttribute>() ?? new EditHintAttribute();
using (var writer = new StringWriter(htmlBuilder))
{
using (var editContainer = new MvcEditContainer(
requestContext: context.ExecutionContext.RequestContext,
epiPropertyKey: PageEditing.DataEPiPropertyName,
epiPropertyName: GetFieldEditName(context),
editElementName: editHint.EditTag,
editElementCssClass: editHint.EditCssClass,
writer: writer))
{
Func <string> renderSettingsWriter = null;
var renderSettings = new RouteValueDictionary();
if (editHint.CssClass.IsNotNullOrEmpty())
{
renderSettings.Add("CssClass", editHint.CssClass);
}
if (editHint.ChildrenCssClass.IsNotNullOrEmpty())
{
renderSettings.Add("ChildrenCssClass", editHint.ChildrenCssClass);
}
renderSettingsWriter = () => AttrsWriter(renderSettings, PageEditing.DataEPiPropertyRenderSettings);
editContainer.CreateStartElementForEditMode(renderSettingsWriter);
editHtml.EditorStart = new HtmlString(writer.ToString());
htmlBuilder.Clear();
}
editHtml.EditorEnd = new HtmlString(writer.ToString());
}
return(editHtml);
}
public override void Process(ModelPropertyContext context)
{
base.Process(context);
var editName = GetFieldEditName(context);
var editHint = GetFieldEditHint(editName, context);
var fieldType = context.Property.PropertyType;
if (fieldType.Is <IEditHtmlString>())
{
var fieldValue = Activator.CreateInstance(fieldType);
((IEditHtmlString)fieldValue).DefaultValue = editHint;
context.PropertyValue = fieldValue;
}
else if (fieldType == typeof(IHtmlString))
{
context.PropertyValue = editHint;
}
else
{
// Don't know how to insert the hint, skipping this field..
}
}
protected override bool FilterByType(ModelPropertyContext context)
{
return(context.Property.PropertyType.Is <IEnumerable <Link> >());
}
protected override bool FilterByValue(ModelPropertyContext context)
{
return(context.PropertyValue == null || ((IEnumerable <Link>)context.PropertyValue).IsEmpty());
}
public virtual bool CanHandle(ModelPropertyContext context)
{
return(IsInEditMode(context) && FilterByType(context) && FilterIgnored(context) && FilterByValue(context));
}
public override bool CanHandle(ModelPropertyContext context)
{
return(base.CanHandle(context) && !IsInBlockPreviewMode(context));
}
protected override bool FilterByValue(ModelPropertyContext context)
{
return(context.PropertyValue == null);
}
protected virtual bool FilterIgnored(ModelPropertyContext context)
{
return(!context.Model.GetType().Has <EditIgnoreAttribute>() && !context.Property.Has <EditIgnoreAttribute>());
}
protected virtual bool FilterByValue(ModelPropertyContext context)
{
return(true);
}
public virtual bool CanHandle(ModelPropertyContext context)
{
return(context.PropertyValue != null && context.PropertyValue.GetType() == typeof(XhtmlString));
}
public virtual void Process(ModelPropertyContext context)
{
var link = (Link)context.PropertyValue;
link.Url = _urlRewriter.GetFriendlyUrl(link.Url, context.ExecutionContext.RequestContext, RouteTable.Routes);
}
public virtual bool CanHandle(ModelPropertyContext context)
{
return(context.PropertyValue is string &&
context.Property.Has <UIHintAttribute>(with: x => x.UIHint == UIHint.Document));
}
public virtual bool CanHandle(ModelPropertyContext context)
{
return(context.PropertyValue is Link);
}
public virtual bool CanHandle(ModelPropertyContext context)
{
return(context.PropertyValue is IEnumerable <Link>);
}
