public void OnDisplaying(ShapeDisplayingContext context)
{
// Check to see if the markup for this shape is already in the cache, and if so, there is no need to render it! :)
// We can prevent the render by setting context.ChildContent to anything other than null (the default display manager checks this property before calling render).
// In our case, we want to set this to the placeholder value, so that it can be replaced with the cached markup later on in the request pipeline.
if (AdminFilter.IsApplied(mHttpContextAccessor.Current().Request.RequestContext))
{
return;
}
var contentItem = (IContent)context.Shape.ContentItem;
var itemLevelTokenizationShouldBeBypassed = ItemLevelTokenizationShouldBeBypassed(context);
var markupMustNotBeTokenized = !mItemLevelCacheService.MarkupShouldBeTokenized(contentItem, context.ShapeMetadata.DisplayType);
if (itemLevelTokenizationShouldBeBypassed || markupMustNotBeTokenized)
{
return;
}
var placeholderText = mItemLevelCacheService.GetPlaceholderText(contentItem, context.ShapeMetadata.DisplayType);
context.ShapeMetadata.Wrappers = new List <string>(); // TODO: add in ability to toggle debug info wrappers?
context.ChildContent = new HtmlString(WrapPlaceholderText(placeholderText));
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata.OnDisplaying(displayedContext => {
if (_acceptAlternates.Value == null || !_acceptAlternates.Value.Any())
{
return;
}
// prevent applying alternate again, c.f. http://orchard.codeplex.com/workitem/18298
if (displayedContext.ShapeMetadata.Alternates.Any(x => x.Contains("__api__")))
{
return;
}
// appends alternates to current ones
displayedContext.ShapeMetadata.Alternates = displayedContext.ShapeMetadata.Alternates.SelectMany(
alternate => new[] { alternate }.Union(_acceptAlternates.Value.Select(a => alternate + "__api__" + a))
).ToList();
// appends [ShapeType]__api__[alternate] alternates
displayedContext.ShapeMetadata.Alternates = _acceptAlternates.Value.Select(a => displayedContext.ShapeMetadata.Type + "__api__" + a)
.Union(displayedContext.ShapeMetadata.Alternates)
.ToList();
});
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata.OnDisplaying(displayedContext => {
var alternates = displayedContext.ShapeMetadata.Alternates;
switch (displayedContext.ShapeMetadata.Type)
{
case "Parts_MenuWidget":
var zoneName = displayedContext.Shape.ContentItem.WidgetPart.Zone;
displayedContext.Shape.Menu.Zone = zoneName;
break;
case "Menu":
AddAlternates(alternates, displayedContext.Shape.Zone, "Menu");
break;
case "MenuItem":
AddAlternates(alternates, displayedContext.Shape.Parent.Zone, "MenuItem");
break;
case "MenuItemLink":
AddAlternates(alternates, displayedContext.Shape.Parent.Zone, "MenuItemLink");
break;
}
});
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata.OnDisplaying(displayedContext => {
if (_urlAlternates.Value == null || !_urlAlternates.Value.Any())
{
return;
}
// prevent applying alternate again, c.f. https://github.com/OrchardCMS/Orchard/issues/2125
if (displayedContext.ShapeMetadata.Alternates.Any(x => x.Contains("__url__")))
{
return;
}
// appends Url alternates to current ones
displayedContext.ShapeMetadata.Alternates = displayedContext.ShapeMetadata.Alternates.SelectMany(
alternate => new [] { alternate }.Union(_urlAlternates.Value.Select(a => alternate + "__url__" + a))
).ToList();
// appends [ShapeType]__url__[Url] alternates
displayedContext.ShapeMetadata.Alternates = _urlAlternates.Value.Select(url => displayedContext.ShapeMetadata.Type + "__url__" + url)
.Union(displayedContext.ShapeMetadata.Alternates)
.ToList();
});
}
public void Displaying(ShapeDisplayingContext context)
{
if (_displayBindingTypes.Any())
{
context.ShapeMetadata.BindingType = _displayBindingTypes.Peek();
}
}
private void SetAlternateInHierarchy(string alternateName, ShapeDisplayingContext context, string specializedName = null)
{
var progressiveHierarchyString = alternateName;
var found = false;
if (!context.Shape.Metadata.Alternates.Contains(alternateName))
{
while (progressiveHierarchyString.Contains("__"))
{
progressiveHierarchyString = progressiveHierarchyString.Substring(0, progressiveHierarchyString.LastIndexOf("__"));
if (context.Shape.Metadata.Alternates.Contains(progressiveHierarchyString))
{
context.ShapeMetadata.Alternates.Insert(context.Shape.Metadata.Alternates.IndexOf(progressiveHierarchyString) + 1, alternateName);
found = true;
break;
}
else if (context.Shape.Metadata.Alternates.Contains(progressiveHierarchyString + "__" + specializedName)) // if it's a field, the type of the field should be placed before the field name alternate
{
context.ShapeMetadata.Alternates.Insert(context.Shape.Metadata.Alternates.IndexOf(progressiveHierarchyString + "__" + specializedName), alternateName);
found = true;
break;
}
}
if (!found)
{
context.ShapeMetadata.Alternates.Add(alternateName);
}
}
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata.OnDisplaying(displayedContext => {
if (!IsActivable())
{
return;
}
if (context.ShapeMetadata.Type != "EditorTemplate" &&
context.ShapeMetadata.Type != "Zone")
{
return;
}
ContentItem contentItem = context.Shape.ContentItem;
// if not, check for ContentPart
if (contentItem == null)
{
ContentPart contentPart = context.Shape.ContentPart;
if (contentPart != null)
{
contentItem = contentPart.ContentItem;
}
}
var className = "content-" + _workContext.GetTextDirection(contentItem);
if (!_workContext.Layout.Content.Classes.Contains(className))
{
_workContext.Layout.Content.Classes.Add(className);
}
});
}
public void Displaying(ShapeDisplayingContext context)
{
if (context.ShapeMetadata.Type.Equals("Zone"))
{
return;
}
this.profiler.StepStart(StepKeys.ShapeProfiling, context.ShapeMetadata.Type + " - Display");
}
public void Displaying(ShapeDisplayingContext context)
{
if (context.ShapeMetadata.Type != "LogOn")
{
return;
}
context.Shape.Title = T("Log in here!").Text;
}
private void AddCustomAlternates(
ShapeDisplayingContext context, string custom,
Func <string, bool> shouldVary,
bool considerZone = true)
{
if (!string.IsNullOrWhiteSpace(custom))
{
// prevent adding these alternates again
if (!context.ShapeMetadata.Alternates.Any(x => x.Contains(custom)))
{
// delegate that will add the alternates to the list of usable ones
Action <string> AddAlternate = (s) => AddAlternateName(context.ShapeMetadata.Alternates, s);
// delegate to invoke adding the alternates
Action <string> AddPersonalized = (s) => AddAlternate(s);
// delegate that "multiplies" alternates by combining them with the identifier
Func <string, string[]> AlternateVariations = (baseName) => {
// some alternates should not be varied further
if (!shouldVary(baseName))
{
return(new string[] { baseName });
}
return(new string[] {
baseName,
baseName + custom
});
};
// Add alternates for the specific zone
if (considerZone && !string.IsNullOrWhiteSpace(lastZone))
{
AddPersonalized = (s) => {
AddAlternate(s);
AddAlternate(s + "__" + lastZone);
};
AlternateVariations = (baseName) => {
// some alternates should not be varied further
if (!shouldVary(baseName))
{
return(new string[] { baseName });
}
return(new string[] {
baseName,
baseName + custom,
baseName + custom + "__" + lastZone
});
};
}
// appends IdentityPart alternates to current ones
context.ShapeMetadata.Alternates = context.ShapeMetadata.Alternates
.SelectMany(
alternate => AlternateVariations(alternate)
).ToList();
// appends [ShapeType]__[identifier] alternates
// appends [ShapeType]__[identifier]__[ZoneName] alternates
AddPersonalized(context.ShapeMetadata.Type + custom);
}
}
}
public override void Displaying(ShapeDisplayingContext context)
{
if (context.ShapeMetadata.Type != "Weather")
{
return;
}
context.Shape.WeatherInfo = _weatherService.GetTodaysWeather();
}
public void Displaying(ShapeDisplayingContext context)
{
if (context.ShapeMetadata.Type.Equals("Zone"))
{
return;
}
this.profiler.StepStart(StepKeys.ShapeProfiling, context.ShapeMetadata.Type + " - Display");
}
private static void AddMenuAlternates(ShapeDisplayingContext displayedContext)
{
var alternates = displayedContext.ShapeMetadata.Alternates;
var menu = displayedContext.Shape;
string menuName = menu.MenuName;
AddAlternates(alternates, "SimpleMenu");
AddAlternates(alternates, "SimpleMenu__" + EncodeAlternateElement(menuName));
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata
.OnDisplaying(displayedContext => {
ContentItem contentItem = displayedContext.Shape.ContentItem;
ContentPart contentPart = displayedContext.Shape.ContentPart is ContentPart
? displayedContext.Shape.ContentPart : null;
if (contentItem != null && contentPart != null) {
var displayType = displayedContext.ShapeMetadata.DisplayType;
var shapeName = displayedContext.ShapeMetadata.Type;
var andDisplayType = !string.IsNullOrWhiteSpace(displayType)
&& !displayType.Equals("Detail");
var newShape = "";
var typeShape = "";
if (contentPart is TermPart) {
if (contentItem.Is<ProjectionPart>()) {
// [ShapeName]-WithProjection.cshtml
// [ShapeName]-[ContentTypeName]-WithProjection.cshtml
newShape = shapeName + "__WithProjection";
typeShape = shapeName + "__"
+ contentItem.ContentType + "__WithProjection";
}
} else if (contentPart is ProjectionPart) {
if (contentItem.Is<TermPart>()) {
// [ShapeName]-WithTerm.cshtml
// [ShapeName]-[ContentTypeName]-WithTerm.cshtml
newShape = shapeName + "__WithTerm";
typeShape = shapeName + "__"
+ contentItem.ContentType + "__WithTerm";
}
}
if (!string.IsNullOrWhiteSpace(newShape)) {
if (!displayedContext.ShapeMetadata.Alternates
.Contains(newShape)) {
displayedContext.ShapeMetadata.Alternates
.Add(newShape);
displayedContext.ShapeMetadata.Alternates
.Add(typeShape);
if (andDisplayType) {
displayedContext.ShapeMetadata.Alternates
.Add(newShape + "__" + displayType);
displayedContext.ShapeMetadata.Alternates
.Add(typeShape + "__" + displayType);
}
}
}
}
});
}
public override void Displaying(ShapeDisplayingContext context)
{
var routeValues = new RouteValueDictionary(mWorkContextAccessor.GetContext().HttpContext.Request.RequestContext.RouteData.Values);
var list = new List <string> {
TakeValue(routeValues, "area"), TakeValue(routeValues, "controller"), TakeValue(routeValues, "action")
};
list.AddRange(routeValues.OrderBy(x => x.Key).Select(x => (string)x.Value));
AddAlternates(context.ShapeMetadata, list);
}
public void Displaying(ShapeDisplayingContext context)
{
var processors = BuildShapeProcessors();
Func <dynamic, IHtmlString> processor;
if (processors.TryGetValue(context.ShapeMetadata.Type, out processor))
{
context.ChildContent = processor(context.Shape);
}
}
public override void Displaying(ShapeDisplayingContext context)
{
if (String.CompareOrdinal(context.ShapeMetadata.Type, "Body_Editor") != 0)
{
return;
}
if (!String.Equals(context.Shape.EditorFlavor, "ueditor", StringComparison.InvariantCultureIgnoreCase))
{
}
}
protected override void OnAlterShape(ShapeDisplayingContext context)
{
var eventData = (IDictionary <string, object>)context.Shape.EventData;
var oldSettings = _settingsFormatter.Map(XmlHelper.Parse((string)eventData["OldSettings"]));
var newSettings = _settingsFormatter.Map(XmlHelper.Parse((string)eventData["NewSettings"]));
var diff = oldSettings.GetDiff(newSettings);
context.Shape.OldSettings = oldSettings;
context.Shape.NewSettings = newSettings;
context.Shape.Diff = diff;
}
protected override void OnAlterShape(ShapeDisplayingContext context)
{
var eventData = (IDictionary <string, object>)context.Shape.EventData;
var oldSettings = AuditTrailManagerExtensions.DeserializeEventData((string)eventData["OldSettings"], Logger);
var newSettings = AuditTrailManagerExtensions.DeserializeEventData((string)eventData["NewSettings"], Logger);
var diff = GetDiffQuery(oldSettings, newSettings).ToArray();
context.Shape.OldSettings = oldSettings;
context.Shape.NewSettings = newSettings;
context.Shape.Diff = diff;
}
private static void Ajaxify(ShapeDisplayingContext context, string ajaxifiedShapeType)
{
var ajaxifyPart = ((IContent)context.Shape.ContentItem).As <AjaxifyPart>();
if (ajaxifyPart == null || !ajaxifyPart.Ajaxify || context.Shape.Ajaxified == true)
{
return;
}
context.ShapeMetadata.Type = ajaxifiedShapeType;
}
private static void AddMenuItemAlternates(ShapeDisplayingContext displayedContext)
{
var alternates = displayedContext.ShapeMetadata.Alternates;
var menuItem = displayedContext.Shape;
var menu = menuItem.Menu;
int level = menuItem.Level;
AddAlternates(alternates, "SimpleMenuItem");
AddAlternates(alternates, "SimpleMenuItem__" + EncodeAlternateElement(menu.MenuName));
AddAlternates(alternates, "SimpleMenuItem__" + EncodeAlternateElement(menu.MenuName) + "__level__" + level);
}
private bool ItemLevelTokenizationShouldBeBypassed(ShapeDisplayingContext context)
{
try
{
return(context.Shape.BypassDonutTokenization);
}
catch (RuntimeBinderException)
{
return(false);
}
}
public void CKEditor_Config_Displaying(ShapeDisplayingContext displaying)
{
// Build other key/value pairs
var context = new CKEditorConfigContext();
foreach (var provider in _ckEditorConfigProviders.Value)
{
provider.PopulateConfiguration(context);
}
displaying.Shape.ConfigPairs = context.Config.Values;
}
private void AddShapeWrapper(ShapeDisplayingContext shapeDisplayingContext, string wrapperName, bool includeUniqueIndentifier = true)
{
var settings = _orchardServices.WorkContext.CurrentSite.As <DisqusSettingsPart>();
shapeDisplayingContext.Shape.DisqusSettings = settings;
shapeDisplayingContext.ShapeMetadata.Wrappers.Add(wrapperName);
if (includeUniqueIndentifier)
{
shapeDisplayingContext.Shape.DisqusUniqueId = GetUniqueIdentifier(shapeDisplayingContext.Shape.ContentPart.ContentItem);
}
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata.OnDisplaying(displayedContext => {
if (displayedContext.ShapeMetadata.Type == "Layout" && IsActivable())
{
var supportedCultures = _cultureManager.ListCultures().ToList();
if (supportedCultures.Count() > 1)
{
_workContext.Layout.Header.Add(Shape.AdminCultureSelector(SupportedCultures: supportedCultures));
}
}
});
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata.OnDisplaying(displayedContext =>
{
if (displayedContext.ShapeMetadata.Type == "Layout" && IsActivable())
{
var userNameList = _contentManager.Query <UserPart, UserPartRecord>()
.OrderBy(userPart => userPart.UserName)
.List().Select(user => user.UserName).ToList();
_workContextAccessor.GetContext().Layout.Header.Add(Shape.AdminSwitchUser(Users: userNameList));
}
});
}
public override void Displaying(ShapeDisplayingContext context)
{
if (String.CompareOrdinal(context.ShapeMetadata.Type, "Body_Editor") != 0)
{
return;
}
if (!String.Equals(context.Shape.EditorFlavor, "html", StringComparison.InvariantCultureIgnoreCase))
{
return;
}
context.Shape.Language = GetTinyMceLanguageIdentifier();
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata.OnDisplaying(displayedContext => {
// appends Url alternates to current ones
displayedContext.ShapeMetadata.Alternates = displayedContext.ShapeMetadata.Alternates.SelectMany(
alternate => new [] { alternate }.Union(_urlAlternates.Select(a => alternate + "__url__" + a))
).ToList();
// appends [ShapeType]__url__[Url] alternates
displayedContext.ShapeMetadata.Alternates = _urlAlternates.Select(url => displayedContext.ShapeMetadata.Type + "__url__" + url)
.Union(displayedContext.ShapeMetadata.Alternates)
.ToList();
});
}
protected override void OnAlterShape(ShapeDisplayingContext context)
{
var eventData = (IDictionary <string, object>)context.Shape.EventData;
var previousDefinitionXml = eventData.GetXml("PreviousDefinition");
var newDefinitionXml = eventData.GetXml("NewDefinition");
var diffGram = eventData.GetXml("DiffGram");
context.Shape.NewDefinitionXml = newDefinitionXml;
if (diffGram != null)
{
var diffNodes = _analyzer.Analyze(previousDefinitionXml, diffGram).ToArray();
context.Shape.DiffNodes = diffNodes;
}
}
public override void Displaying(ShapeDisplayingContext context)
{
context.ShapeMetadata
.OnDisplaying(displayedContext => {
if (displayedContext.ShapeMetadata.Type == "Zone")
{
lastZone = displayedContext.Shape.ZoneName;
}
else if (displayedContext.Shape.ContentItem is ContentItem)
{
ContentItem contentItem = displayedContext.Shape.ContentItem;
ContentPart contentPart = displayedContext.Shape.ContentPart is ContentPart ? displayedContext.Shape.ContentPart : null;
ContentField contentField = displayedContext.Shape.ContentField is ContentField ? displayedContext.Shape.ContentField : null;
var displayType = displayedContext.ShapeMetadata.DisplayType;
var shapeName = displayedContext.ShapeMetadata.Type;
var zoneName = lastZone;
if (contentPart.Is <ProjectionPart>() && contentPart.PartDefinition.Name == "ProjectionPart")
{
var suffix = "";
if (displayedContext.ShapeMetadata.Type == "List" && displayedContext.Shape.PagerId != null) // è una lista ma all'interno c'è il pager
{
suffix = "__Pager";
if (!displayedContext.ShapeMetadata.Alternates.Contains(shapeName + "__" + contentItem.ContentType + suffix))
{
displayedContext.ShapeMetadata.Alternates.Add(shapeName + "__" + contentItem.ContentType + suffix);
}
}
if (contentPart.As <ProjectionPart>().Record.QueryPartRecord != null)
{
var queryName = _queryService.GetQuery(contentPart.As <ProjectionPart>().Record.QueryPartRecord.Id).Name;
queryName = queryName.Normalize(System.Text.NormalizationForm.FormD).ToLower().Replace(" ", "");
if (!displayedContext.ShapeMetadata.Alternates.Contains(shapeName + "__" + contentItem.ContentType + suffix + "__ForQuery__" + queryName))
{
displayedContext.ShapeMetadata.Alternates.Add(shapeName + "__" + contentItem.ContentType + suffix + "__ForQuery__" + queryName);
}
if (!String.IsNullOrWhiteSpace(zoneName))
{
if (!displayedContext.ShapeMetadata.Alternates.Contains(shapeName + "__" + contentItem.ContentType + suffix + "__ForQuery__" + queryName + "__" + zoneName))
{
displayedContext.ShapeMetadata.Alternates.Add(shapeName + "__" + contentItem.ContentType + suffix + "__ForQuery__" + queryName + "__" + zoneName);
}
}
}
}
}
});
}
public void Displaying(ShapeDisplayingContext context)
{
if (!IsMobileDevice())
{
return;
}
var shapeMetadata = context.ShapeMetadata;
if (shapeMetadata.Type != "HeadLinks" && shapeMetadata.Type != "Metas")
{
return;
}
var workContext = _workContextAccessor.GetContext(_httpContextAccessor.Current());
var resourceManager = workContext.Resolve <IResourceManager>();
if (shapeMetadata.Type == "HeadLinks")
{
// <link rel="alternate" type="text/html" media="handheld" href="" />
var handheldLink = new LinkEntry
{
Type = "text/html",
Rel = "alternate",
Href = ""
};
handheldLink.AddAttribute("media", "handheld");
resourceManager.RegisterLink(handheldLink);
// Set the transcoding protection http response headers
workContext.HttpContext.Response.Cache.SetNoTransforms();
workContext.HttpContext.Response.AppendHeader("Vary", "User-Agent");
}
else if (shapeMetadata.Type == "Metas")
{
resourceManager.SetMeta(new MetaEntry
{
// HACK: Orchard doesn't allow metas without a name.
Name = "no-transform",
HttpEquiv = "Cache-control",
Content = "no-transform"
});
}
}
public void OnDisplaying(ShapeDisplayingContext context)
{
IContent content = null;
if (context.Shape.ContentItem != null)
{
content = context.Shape.ContentItem;
}
else if (context.Shape.ContentPart != null)
{
content = context.Shape.ContentPart;
}
var message = string.Format(
"Shape Display: {0} ({1}) ({2})",
context.ShapeMetadata.Type,
context.ShapeMetadata.DisplayType,
(string)(content != null ? content.ContentItem.ContentType : "non-content"));
this.profiler.StepStart(StepKeys.ShapeProfiling, message, true);
}
