Blog posts by Johan Pettersson2022-05-17T11:49:12.0000000Zhttps://world.optimizely.com/blogs/Johan-Pettersson/Optimizely WorldContent development improvements May '22<p>Lately we have had a slew of notable releases that we would like to highlight. The work of migrating packages to .NET Core continues and more packages are now cross-compiled to .NET5 and .NET6. Note that you can target .NET6 even though not all packages are cross-compiled yet. You can follow our work here <a href="/link/42b7913c321d4886b468000231d9baa4.aspx">https://world.optimizely.com/resources/net5/add-ons/</a>. Clicking on an add-on will take you to the NuGet package details page where you can subscribe to and get notified when it’s updated.</p>
<h2>Updated Templates</h2>
<p>This work is now reflected in <a href="https://www.nuget.org/packages/EPiServer.Templates/">our templates</a>. Latest version (1.2) is now targeting .NET6 and uses the latest dependencies. You should be presented with the following message if you have an outdated version installed when trying to apply a template:</p>
<pre class="language-csharp"><code>An update for template package 'EPiServer.Templates::1.1.0' is available.
To update the package use:
dotnet new --install EPiServer.Templates::1.2.0</code></pre>
<p>You can also do a manual check for updated versions:</p>
<pre class="language-csharp"><code>dotnet new --update-check</code></pre>
<p>If you want to stay on top of what happens in our templates, we recommend staring the GitHub repository at <a href="https://github.com/episerver/content-templates">https://github.com/episerver/content-templates</a>. We recommend doing this even though you do not use the templates, since we will continue to update them with the latest syntax and configuration that you also might want to use in your own templates or projects.</p>
<p>Note that we do not support the new host configuration model yet. This means you still need to have a separate startup class and cannot use <code>WebApplication</code> and <code>WebApplicationBuilder</code>.</p>
<h2>Content Delivery Search</h2>
<p>Search and Navigation (formerly known as Find) is now supported in Content Delivery again. See <a href="https://docs.developers.optimizely.com/content-cloud/v1.5.0-content-delivery-api/docs/content-search-api">https://docs.developers.optimizely.com/content-cloud/v1.5.0-content-delivery-api/docs/content-search-api</a> for documentation.</p>
<h2>OpenID Connect UI</h2>
<p>Last year we released support for OpenID Connect, see <a href="https://docs.developers.optimizely.com/content-cloud/v1.5.0-content-delivery-api/docs/api-authentication">https://docs.developers.optimizely.com/content-cloud/v1.5.0-content-delivery-api/docs/api-authentication</a> for the documentation. The initial release also included a small UI for managing refresh tokens. This UI is now updated to include the possibility to manage applications without the need to deploy code. Applications that are defined in code, or via configuration, are also displayed but only as read-only.</p>
<p><img src="/link/1ec8f95663554d0fafbf6a27334d7832.aspx" alt="" /></p>
<h2>New sample site in JS SDK</h2>
<p>The old sample site has been updated to .NET6 and we have also made a new sample available, see <a href="https://github.com/episerver/content-delivery-js-sdk/tree/master/samples/music-festival-vue-coupled">https://github.com/episerver/content-delivery-js-sdk/tree/master/samples/music-festival-vue-coupled</a>. This sample is hosting the client app, built with Vue CLI, in the same dotnet process. But during development the front-end app is hosted in a separate Node.js process and the backend is proxied to the dotnet process using the new ASP.NET SPA Proxy. This means you get all the nice Node.js tooling, such as webpack’s hot reload, during development.</p>2022-05-17T11:49:12.0000000ZBlog postNew templates and “getting started” experience<p>Since we released CMS 12 and Commerce 14 our “getting started” experience has been lacking a bit. We decided to not upgrade our Visual Studio extension and instead rely on the new <a href="https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-new">dotnet new experience</a>. This meant that we had no item templates or the old trusty Alloy sample site available for CMS 12. We initially released two templates to create empty Content Cloud or Commerce Cloud projects and a CLI tool to create and manage databases. But we felt we could improve this experience further.</p>
<p>First, we decided to open source our templates so the community – you – can contribute and report issues. The new templates are now located on GitHub at <a href="https://github.com/episerver/content-templates">https://github.com/episerver/content-templates</a>.</p>
<p>When you <a href="/link/d3c54953c2514845b0260072d15b5ddc.aspx">install the templates</a> they will be available from the command line as well as show up in the “New project dialog” in Visual Studio 2022 and later. In Visual Studio 2019 this can be enabled by toggling a preview flag, see <a href="https://devblogs.microsoft.com/dotnet/net-cli-templates-in-visual-studio/">https://devblogs.microsoft.com/dotnet/net-cli-templates-in-visual-studio/</a>. Unfortunately, the item templates are not available in Visual Studio yet, but there are plans from Microsoft to enable this in the .NET 7 timeframe.</p>
<p>Install the templates by running following command:</p>
<pre class="language-csharp"><code>dotnet new --install EPiServer.Templates</code></pre>
<p>We also set out to make the templates cross-platform by enabling basic Docker support. The Docker support is not meant to be used when deploying the application, but rather as an effortless way to get started without the need to install Microsoft SQL Server.</p>
<p>The <a href="/link/a05229aa15ed4dbf8fb34edd6d39a87d.aspx">Alloy templates</a> also got a bit of a refresh. We updated Bootstrap to the latest version and updated the look and feel to be a bit more modern.</p>
<p><img src="/link/f5545d9c2c544725a63dae8033469f05.aspx" /></p>
<p>This template previously contained code for creating an administrator user on startup, we have now added this capability in the product instead. This is enabled in all new templates. On first request you are redirected to a view where you can create the first administrator user. This is only enabled on loopback addresses (localhost) and when no user exists.</p>
<p><img src="/link/dd5249213459461495bd69ea66ebe985.aspx" /></p>
<p>The following project templates are available:</p>
<ul>
<li>Alloy (epi-alloy-mvc)<br />Demonstration template. The Alloy template contains a site for a fictional company, Alloy Technologies, to demonstrate the most notable features of Optimizely Content cloud and gives you a site that is ready to explore and to learn from.</li>
<li>Empty Content Cloud (epi-cms-empty)</li>
<li>Empty Commerce Cloud (epi-commerce-empty)</li>
</ul>
<p>And the following item templates:</p>
<ul>
<li>Content component (epi-cms-contentcomponent)<br />View component for blocks and partial content.</li>
<li>Content Type (epi-cms-contenttype)</li>
<li>Initialization Module (epi-cms-initializationmodule)</li>
<li>Scheduled Job (epi-cms-job)</li>
<li>Page Controller (epi-cms-pagecontroller)</li>
<li>Razor Page (epi-cms-razorpage)</li>
</ul>
<p>To use a template, run following command:</p>
<pre class="language-csharp"><code>dotnet new epi-alloy-mvc --name My.Web</code></pre>
<p>The name option is optional. If you don't provide one, the directory name will be used instead.</p>
<p>To see a list of all available options that are template-specific, run following command:</p>
<pre class="language-csharp"><code>dotnet new epi-alloy-mvc --help</code></pre>
<pre class="language-csharp"><code>Optimizely Alloy MVC (C#)
Author: Episerver AB
Description: Example MVC application for testing and learning Optimizely CMS.
Options:
--enable-docker Enable Docker support
bool - Optional
Default: false
--sa-password The password the SA database account should have
string - Optional
Default: Qwerty12345!</code></pre>
<p>Hope this helps and improves your experience working with our products. Don’t hesitate to report any issues or suggestions on GitHub at <a href="https://github.com/episerver/content-templates">https://github.com/episerver/content-templates</a>. Also, look out for an update of the templates soon with full .NET6 support.</p>2022-03-24T17:01:17.0000000ZBlog postPrevent editors from deleting "system" content
<p>Sometimes you have content, e.g. pages, that's necessary for the website to run. This could be the startpage, news archive page, search page and so on. Let's call them 'system content'.</p>
<p>Now, if you want to prevent your editors from accidentally deleting these pages you could change the permissions to these pages. The downside with using the regular content permissions is that you have to stop the inheritance of the permissions, and not just that, you also need to reset them again for every child page that you want the editors to able to delete.</p>
<p>This gets unmanageable after a while.</p>
<p>So what can we do instead? Well, we could hook in to the content events in the content repository and then stop them from being deleted.</p>
<p>First we define an interface to mark all content types that should not be deleted.</p>
<pre class="language-csharp"><code>
namespace DV.ContentTypes.Interfaces
{
using EPiServer.Core;
/// <summary>
/// Decorate content types with this interface to classify them
/// as system content. System content should not be deleted by editors e.g..
/// We will stop editors from deleting these content items unless they have
/// access to that function. Please see <see cref="DV.DeleteSystemContentPermissions"/>
/// and <see cref="DV.SystemContentInitialization"/>.
/// </summary>
public interface ISystemContent : IContent
{
}
}
</code></pre>
<p>Then we decorate our content types.</p>
<pre class="language-csharp"><code>
namespace DV.ContentTypes.Pages
{
[ContentType]
public class HomePage : PageData, ISystemContent
{
}
}
</code></pre>
<p>But hey, wouldn't it be nice if we could delete them anyway, in like special cases? Let's create special permissions, <a href="/link/dc2b2e3bcefc4a7f94191f06f1cb069c.aspx">Permission to Functions</a> to the rescue.</p>
<pre class="language-csharp"><code>
namespace DV
{
using EPiServer.DataAnnotations;
using EPiServer.Security;
[PermissionTypes]
public static class DeleteSystemContentPermissions
{
static DeleteSystemContentPermissions()
{
DeleteContent = new PermissionType(nameof(DeleteSystemContentPermissions), nameof(DeleteContent));
DeleteLanguageVersion = new PermissionType(nameof(DeleteSystemContentPermissions), nameof(DeleteLanguageVersion));
}
public static PermissionType DeleteContent { get; private set; }
public static PermissionType DeleteLanguageVersion { get; private set; }
}
}
</code></pre>
<p>Please follow the guide in the link above to give the permissions more meaningfull descriptions by also creating translations.</p>
<p>Now we can create an initializable module that will actully prevent editors from deleting 'system content' or allow them if they have enough permissions.</p>
<pre class="language-csharp"><code>
namespace DV
{
using EPiServer;
using EPiServer.Core;
using EPiServer.Framework;
using EPiServer.Framework.Initialization;
using EPiServer.Security;
using EPiServer.ServiceLocation;
[InitializableModule]
[ModuleDependency(typeof(EPiServer.Web.InitializationModule))]
public class SystemContentInitialization : IInitializableModule
{
public void Initialize(InitializationEngine context)
{
var contentEvents = ServiceLocator.Current.GetInstance<IContentEvents>();
contentEvents.MovingContent += this.MovingContent;
contentEvents.DeletingContentLanguage += this.DeletingContentLanguage;
}
public void Uninitialize(InitializationEngine context)
{
var contentEvents = ServiceLocator.Current.GetInstance<IContentEvents>();
contentEvents.MovingContent -= this.MovingContent;
contentEvents.DeletingContentLanguage -= this.DeletingContentLanguage;
}
private void MovingContent(object sender, ContentEventArgs e)
{
if (e.Content is ISystemContent == false)
{
return;
}
if (e.TargetLink.Equals(ContentReference.WasteBasket, true) == false)
{
return;
}
bool hasPermission = PrincipalInfo.Current.IsPermitted(DeleteSystemContentPermissions.DeleteContent);
if (hasPermission == false)
{
e.CancelAction = true;
e.CancelReason = "You're not allowed to delete this content. You need permission to this function.";
}
}
private void DeletingContentLanguage(object sender, ContentEventArgs e)
{
if (e.Content is ISystemContent == false)
{
return;
}
bool hasPermission = PrincipalInfo.Current.IsPermitted(DeleteSystemContentPermissions.DeleteLanguageVersion);
if (hasPermission == false)
{
e.CancelAction = true;
e.CancelReason = "You're not allowed to delete this language. You need permission to this function.";
}
}
}
}
</code></pre>
<p>The Version gadget will unfortunately not display our <code>CancelReason</code> message when deleting a language version, but if you try to delete the content (master language), then our message will be displayed. I you're using the Language Add-on, then the add-on will just throw an error when you delete a language. I wish that add-on would handle this better, but hey, it will at least stop the editors from deleting the language.</p>
2017-07-11T17:43:07.0000000ZBlog postIntroducing Episerver Taxonomy
<p><img src="https://raw.githubusercontent.com/JohanPetersson/episerver-taxonomy/master/taxonomy.png" width="300" class="img-rounded pull-right" alt="Screenshot from Episerver editing UI" />Since I started working with Episerver back in 2008 I've been missing better taxonomy support, that and a "bucket" feature where we can put content that doesn't fit into a content tree, but in this post I will just cover taxonomy (buckets might be my next challenge though).</p>
<p>If you're like me, you've probably always wondered why you need admin access to just administer categories and why it's so cumbersome to translate them. Well, you don't have to anymore! Head over to GitHub and check my new project out at <a href="https://github.com/JohanPetersson/episerver-taxonomy">https://github.com/JohanPetersson/episerver-taxonomy</a>.</p>
<p>You'll find more information at GitHub, but in short this Add-on gives editors a new UI to manage taxonomy and us, developers, a new way to define different types of taxonomy.<p>
<p>We can define taxonomy by inheriting from <code>TaxonomyData</code>:</p>
<pre class="language-csharp"><code>
using Dodavinkeln.Taxonomy.Core;
using EPiServer.DataAnnotations;
[ContentType(GUID = "974ebaf3-c6fc-4332-a809-344b7e372f21")]
public class CategoryData : TaxonomyData
{
}</code></pre>
<p>And then add taxonomy properties to content types:</p>
<pre class="language-csharp"><code>
[Taxonomy]
[Display(Name = "News category")]
public virtual ContentReference NewsCategory { get; set; }</code></pre>
<p>The Add-on is not release in a public feed yet, I would like to have some feedback and implement a few more features before releasing 1.0. So please check it out and leave comments here or on GitHub.</p>
</p></p>2016-11-27T17:30:36.0000000ZBlog postUser picker property<p>Lets say you want to give your editors the possibility to select a user (username) in a property so we can display e.g. a byline in an article. The simple solution is to just add a string property to your page type, but then the editor need to enter the username manually. Instead we can use the <a href="/link/59557718dcdd44e7beabbb37e3a26572.aspx">AutoSuggestSelection</a> attribute, then we only need to implement an <code>ISelectionQuery</code>.</p>
<p>Fortunately there is an API in Episerver we can use to query for users, <code>IQueryableNotificationUsers</code>, but keep in mind that the API is internal and may change without notice.</p>
<p>First we need to implement our query:</p>
<pre class="language-csharp"><code>
namespace DV
{
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using EPiServer.Notification;
using EPiServer.ServiceLocation;
using EPiServer.Shell.ObjectEditing;
[ServiceConfiguration(typeof(ISelectionQuery))]
public class UserSelectionQuery : ISelectionQuery
{
private readonly IQueryableNotificationUsers userRepository;
public UserSelectionQuery(IQueryableNotificationUsers userRepository)
{
this.userRepository = userRepository;
}
public ISelectItem GetItemByValue(string value)
{
var task = Task.Run(async () => await this.userRepository.FindAsync(value, 0, 1));
task.Wait();
if (task.Result.TotalCount == 0)
{
return null;
}
var user = task.Result.PagedResult.Single();
return new SelectItem
{
Text = $"{user.DisplayName} ({user.UserName})",
Value = user.UserName
};
}
public IEnumerable<ISelectItem> GetItems(string query)
{
var task = Task.Run(async () => await this.userRepository.FindAsync(query, 0, 10));
task.Wait();
if (task.Result.TotalCount == 0)
{
return Enumerable.Empty<ISelectItem>();
}
return task.Result.PagedResult.Select(user => new SelectItem
{
Text = $"{user.DisplayName} ({user.UserName})",
Value = user.UserName
});
}
}
}
</code></pre>
<p>Then we can use it in the attribute:</p>
<pre class="language-csharp"><code>
[AutoSuggestSelection(typeof(UserSelectionQuery))]
[Display(Name = "Published by")]
public virtual string PublishedBy { get; set; }
</code></pre>
<p>Hope this helps.</p>
2016-10-13T18:29:47.0000000ZBlog postConstants for all Episerver icons<p>I couldn't find constants for all Episerver action icons located here <a href="http://ux.episerver.com/">http://ux.episerver.com/</a> anywhere in Episerver or on the Internet. So I thought I would share those with you. These are really useful if you e.g. are using this <a href="http://blog.nansen.com/2014/10/page-tree-icons-in-episerver-cms-75.html">solution</a>.</p>
<pre class="language-csharp"><code>
public static class ContentIcons
{
public const string Clock = "epi-iconClock";
public const string Checkmark = "epi-iconCheckmark";
public const string Stop = "epi-iconStop";
public const string Versions = "epi-iconVersions";
public const string Revert = "epi-iconRevert";
public const string Undo = "epi-iconUndo";
public const string Redo = "epi-iconRedo";
public const string Pen = "epi-iconPen";
public const string PenDisabled = "epi-iconPenDisabled";
public const string DuplicatePage = "epi-iconDuplicatePage";
public const string Primary = "epi-iconPrimary";
public const string Trash = "epi-iconTrash";
public const string Users = "epi-iconUsers";
public const string Search = "epi-iconSearch";
public const string Plus = "epi-iconPlus";
public const string Minus = "epi-iconMinus";
public const string Star = "epi-iconStar";
public const string Settings = "epi-iconSettings";
public const string Lock = "epi-iconLock";
public const string Pin = "epi-iconPin";
public const string Page = "epi-iconPage";
public const string Folder = "epi-iconFolder";
public const string SharedBlock = "epi-iconSharedBlock";
public const string Up = "epi-iconUp";
public const string Down = "epi-iconDown";
public const string Reload = "epi-iconReload";
public const string Share = "epi-iconShare";
public const string Download = "epi-iconDownload";
public const string DnD = "epi-iconDnD";
public const string ContextMenu = "epi-iconContextMenu";
public const string Rename = "epi-iconRename";
public const string Left = "epi-iconLeft";
public const string Right = "epi-iconRight";
public const string User = "epi-iconUser";
public const string Hidden = "epi-iconHidden";
public const string NewWindow = "epi-iconNewWindow";
public const string Catalog = "epi-iconCatalog";
public const string Category = "epi-iconCategory";
public const string Product = "epi-iconProduct";
public const string SKU = "epi-iconSKU";
public const string Package = "epi-iconPackage";
public const string Bundle = "epi-iconBundle";
public const string Boxes = "epi-iconBoxes";
public const string References = "epi-iconReferences";
public const string Bubble = "epi-iconBubble";
public const string Location = "epi-iconLocation";
public const string Mail = "epi-iconMail";
public const string Telephone = "epi-iconTelephone";
public const string Website = "epi-iconWebsite";
public const string Link = "epi-iconLink";
public const string Upload = "epi-iconUpload";
public const string Error = "epi-iconError";
public const string Warning = "epi-iconWarning";
public const string Info = "epi-iconInfo";
public const string Pricing = "epi-iconPricing";
public const string Cut = "epi-iconCut";
public const string Copy = "epi-iconCopy";
public const string Paste = "epi-iconPaste";
public const string Detach = "epi-iconDetach";
public const string List = "epi-iconList";
public const string Thumbnails = "epi-iconThumbnails";
public const string Tiles = "epi-iconTiles";
public const string Project = "epi-iconProject";
public const string Published = "epi-iconPublished";
public const string PreviouslyPublished = "epi-iconPreviouslyPublished";
public const string Truck = "epi-iconTruck";
public const string Cart = "epi-iconCart";
public const string Sort = "epi-iconSort";
public const string Campaign = "epi-iconCampaign";
public const string PublishProject = "epi-iconPublishProject";
public const string Promotion = "epi-iconPromotion";
public const string Layout = "epi-iconLayout";
public const string SortAscending = "epi-iconSortAscending";
public const string SortDescending = "epi-iconSortDescending";
public const string Edited = "epi-iconEdited";
public const string Bell = "epi-iconBell";
}
</code></pre>
2016-08-31T15:51:42.0000000ZBlog postHow to get the external URL to content<p>This topic comes up from time to time in the forums. I don’t find <a href="http://www.dcaric.com/blog/episerver-how-to-get-external-page-url">some</a> of the <a href="https://andersnordby.wordpress.com/2014/04/29/getting-an-external-url-in-episerver-7-x/">solutions</a> given completely adequate. They usually just makes the URL absolute by appending the current context’s host name, if present. What we should do instead, is to load the <code>SiteDefinition</code> for the content passed in to our method and then load the host from that definition. The site definition can contain multiple hosts and different kinds as well, e.g. primary host.</p> <p>This method also works for <code>MediaData</code>.</p> <pre class="language-csharp"><code>public static string ContentExternalUrl(this ContentReference contentLink, CultureInfo contentLanguage, bool absoluteUrl)
{
var result = ServiceLocator.Current.GetInstance<UrlResolver>().GetUrl(
contentLink,
contentLanguage.Name,
new VirtualPathArguments
{
ContextMode = ContextMode.Default,
ForceCanonical = absoluteUrl
});
// HACK: Temprorary fix until GetUrl and ForceCanonical works as expected,
// i.e returning an absolute URL even if there is a HTTP context that matches the content's site definition and host.
if (absoluteUrl)
{
Uri relativeUri;
if (Uri.TryCreate(result, UriKind.RelativeOrAbsolute, out relativeUri))
{
if (!relativeUri.IsAbsoluteUri)
{
var siteDefinitionResolver = ServiceLocator.Current.GetInstance<SiteDefinitionResolver>();
var siteDefinition = siteDefinitionResolver.GetDefinitionForContent(contentLink, true, true);
var hosts = siteDefinition.GetHosts(contentLanguage, true).ToList();
var host = hosts.FirstOrDefault(h => h.Type == HostDefinitionType.Primary)
?? hosts.FirstOrDefault(h => h.Type == HostDefinitionType.Undefined);
var basetUri = siteDefinition.SiteUrl;
if (host != null && host.Name.Equals("*") == false)
{
// Try to create a new base URI from the host with the site's URI scheme. Name should be a valid
// authority, i.e. have a port number if it differs from the URI scheme's default port number.
Uri.TryCreate(siteDefinition.SiteUrl.Scheme + "://" + host.Name, UriKind.Absolute, out basetUri);
}
var absoluteUri = new Uri(basetUri, relativeUri);
return absoluteUri.AbsoluteUri;
}
}
}
return result;
}</code></pre>2016-01-19T14:53:19.0000000ZBlog postPropertyFor() revisited<p>Since my <a href="/post/make-propertyfor()-more-consistent">last post</a> I’ve discovered a few issues/bugs with my approach while making rendering of properties more consistent. Unfortunately my method didn’t work that well in preview mode and Content Area properties got wrapped twice!</p> <p>I couldn’t find an easy way since there is no method to override when properties are rendered in preview mode (these are rendered inside <code>GetHtmlForEditMode()</code>) and no way of telling if the property is a Content Area inside <code>GetHtmlForDefaultMode()</code>. So instead I had to override the <code>PropertyFor()</code> method which made the code much overly complicated and I also had to reflect some private methods from the default PropertyRenderer.</p> <p>Here is the new complete code:</p> <pre class="language-csharp"><code>/// <summary>
/// Overrides the default renderer of all properties, so if we specify a CustomTag(Name) and optionally CssClass they get
/// rendered in view and preview mode as well. The default renderer only wraps the property in edit mode, except for
/// content areas which are always wrapped.
/// </summary>
public class SitePropertyRenderer : PropertyRenderer
{
private readonly CachingViewEnginesWrapper viewResolver;
public SitePropertyRenderer(CachingViewEnginesWrapper viewResolver)
{
this.viewResolver = viewResolver;
}
public override MvcHtmlString PropertyFor<TModel, TValue>(HtmlHelper<TModel> html, string viewModelPropertyName, object additionalViewData, object editorSettings, Expression<Func<TModel, TValue>> expression, Func<string, MvcHtmlString> displayForAction)
{
var contextMode = html.ViewContext.RequestContext.GetContextMode();
// Properties are always wrapped in edit mode, so no need for custom rendering
if (contextMode == ContextMode.Edit)
{
return base.PropertyFor(html, viewModelPropertyName, additionalViewData, editorSettings, expression, displayForAction);
}
var routeValueDictionaries = new RouteValueDictionary(additionalViewData);
var templateName = this.ResolveTemplateName(html, routeValueDictionaries, expression);
var isContentArea = this.PropertyIsContentArea(html, expression);
// Content areas are always wrapped, so no need for custom rendering in view mode.
if (isContentArea)
{
return displayForAction(templateName);
}
string elementName = null;
if (routeValueDictionaries.ContainsKey("CustomTag"))
{
elementName = routeValueDictionaries["CustomTag"] as string;
}
// Correctly spelled property as well, since Episerver probably made a mistake here
if (routeValueDictionaries.ContainsKey("CustomTagName"))
{
elementName = routeValueDictionaries["CustomTagName"] as string;
}
string cssClass = null;
if (routeValueDictionaries.ContainsKey("CssClass"))
{
cssClass = routeValueDictionaries["CssClass"] as string;
}
return this.GetHtmlForDefaultAndPreviewMode(templateName, elementName, cssClass, displayForAction);
}
private MvcHtmlString GetHtmlForDefaultAndPreviewMode(string templateName, string elementName, string cssClass, Func<string, MvcHtmlString> displayForAction)
{
// Rely on standard behavior if no element is specified
if (string.IsNullOrEmpty(elementName))
{
return displayForAction(templateName);
}
var html = displayForAction(templateName).ToHtmlString();
if (string.IsNullOrEmpty(html))
{
return MvcHtmlString.Empty;
}
var tag = new TagBuilder(elementName)
{
InnerHtml = html
};
if (string.IsNullOrEmpty(cssClass) == false)
{
tag.AddCssClass(cssClass);
}
return new MvcHtmlString(tag.ToString());
}
private bool PropertyIsContentArea<TModel, TValue>(HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression)
{
var contentAreaType = typeof(ContentArea);
var modelMetadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
return contentAreaType.IsAssignableFrom(modelMetadata.ModelType);
}
#region Private methods reflected from base class
private string ResolveTemplateName<TModel, TValue>(HtmlHelper<TModel> html, RouteValueDictionary additionalValues, Expression<Func<TModel, TValue>> expression)
{
var modelMetadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var tag = additionalValues["tag"] as string;
if (string.IsNullOrEmpty(tag) && modelMetadata != null)
{
tag = this.GetTagFromModelMetadata(modelMetadata);
}
if (string.IsNullOrEmpty(tag) == false && modelMetadata != null)
{
var templateResolver = html.ViewData["templateResolver"] as TemplateResolver ?? ServiceLocator.Current.GetInstance<TemplateResolver>();
var templateModel = templateResolver.Resolve(
html.ViewContext.HttpContext,
modelMetadata.ModelType,
modelMetadata.Model,
TemplateTypeCategories.MvcPartialView,
tag);
var templateName = this.GetTemplateName(templateModel, html.ViewContext);
if (string.IsNullOrEmpty(templateName) == false)
{
return templateName;
}
}
if (this.DisplayTemplateWithNameExists(html.ViewContext, tag) == false)
{
return null;
}
return tag;
}
private string GetTagFromModelMetadata(ModelMetadata metaData)
{
if (metaData == null || metaData.ContainerType == null)
{
return null;
}
var property = metaData.ContainerType.GetProperty(metaData.PropertyName);
if (property != null)
{
var uIHintAttributes = property.GetCustomAttributes(true).OfType<UIHintAttribute>();
var uIHintAttribute = uIHintAttributes.FirstOrDefault(a => string.Equals(a.PresentationLayer, "website", StringComparison.OrdinalIgnoreCase));
if (uIHintAttribute != null)
{
return uIHintAttribute.UIHint;
}
uIHintAttribute = uIHintAttributes.FirstOrDefault(a => string.IsNullOrEmpty(a.PresentationLayer));
if (uIHintAttribute != null)
{
return uIHintAttribute.UIHint;
}
}
return null;
}
private string GetTemplateName(TemplateModel templateModel, ControllerContext viewContext)
{
if (templateModel == null)
{
return null;
}
if (this.DisplayTemplateWithNameExists(viewContext, templateModel.Name) == false)
{
return null;
}
return templateModel.Name;
}
private bool DisplayTemplateWithNameExists(ControllerContext viewContext, string templateName)
{
if (string.IsNullOrEmpty(templateName))
{
return false;
}
var viewEngineResult = this.viewResolver.FindPartialView(viewContext, $"DisplayTemplates/{templateName}");
if (viewEngineResult == null)
{
return false;
}
return viewEngineResult.View != null;
}
#endregion
}</code></pre>2016-01-13T21:08:43.0000000ZBlog postMake PropertyFor() more consistent<p>Coming from WebForms development I was a bit annoyed with the inconsistent behavior of the <code>PropertyFor()</code> Html Helper. In WebForms properties are always wrapped with an element, but in MVC this is only true in edit mode. Please see <a href="http://joelabrahamsson.com/how-episervers-html-helper-propertyfor-works/">Joel’s excelent post about <code>PropertyFor()</code></a> and what gets actually rendered to the client.</p> <blockquote> <p><strong>Conclusion:</strong> Properties always gets wrapped with an element in edit mode, but never in view mode. However this is only true for non ContentArea properties, which are not really the problem here.</p> </blockquote> <p>Why is this a problem you might ask? Well this might actually break your design, especially in edit mode where the extra wrapping element might add styling that you don’t want. So how can we fix this?</p> <p>One solution is to not use <code>PropertyFor()</code> at all and instead use <code>DisplayFor()</code> or just <code>@Model.YourProperty</code>. But then you need to add the editing attributes manually to a parent element but then that parent will always get rendered in view mode, even though the property doesn’t have a value. You can fix that by adding an if-statement around the parent and the property and then check whether we are in edit mode and/or the property has a value (we always need to render the parent in edit mode). Not so nice, and a lot of unnecessary code and logic in the view:</p> <pre class="language-csharp"><code>@if (EPiServer.Editor.PageEditing.PageIsInEditMode || Model.CurrentPage.PageHeading != null)
{
<h2 @Html.EditAttributes(x => x.CurrentPage.PageHeading)>
@Html.DisplayFor(x => x.CurrentPage.PageHeading)
</h2>
}</code></pre>
<p>Replacing the <code>PropertyRenderer</code> was the easist way I found to fix this behavior. Please let me know in the comment section if you have a better way of solving this! It was actually really easy:</p>
<pre class="language-csharp"><code>
public class SitePropertyRenderer : PropertyRenderer
{
protected override MvcHtmlString GetHtmlForDefaultMode<TModel, TValue>(string propertyName, string templateName, string elementName, string elementCssClass, Func<string, MvcHtmlString> displayForAction)
{
if (string.IsNullOrEmpty(elementName))
{
return displayForAction(templateName);
}
var html = displayForAction(templateName).ToHtmlString();
if (string.IsNullOrEmpty(html))
{
return MvcHtmlString.Empty;
}
var tag = new TagBuilder(elementName)
{
InnerHtml = html
};
if (string.IsNullOrEmpty(elementCssClass) == false)
{
tag.AddCssClass(elementCssClass);
}
return new MvcHtmlString(tag.ToString());
}
}</code></pre>
<p>We only have to override  how the property is rendered in view mode and always add the wrapping element. We also need to replace the default renderer in the container with our own, which can be done in an initializable module:</p>
<pre class="language-csharp"><code>[InitializableModule]
public class ContainerConfigurableModule : IConfigurableModule
{
public void ConfigureContainer(ServiceConfigurationContext context)
{
context.Container.Configure(container =>
container.For<PropertyRenderer>().Use<SitePropertyRenderer>());
}
}</code></pre>
<p>Now we can write like this in the view instead, and the wrapper gets always rendered, but only in view mode if the property has a value:</p>
<pre class="language-csharp"><code>@Html.PropertyFor(x => x.CurrentPage.PageHeading, new { CustomTag = "h2" })</code></pre>
<p>This will probably not be an issue in MVC 6, hopefully in a near future, where we can use <a href="https://github.com/aspnet/Mvc/tree/dev/src/Microsoft.AspNet.Mvc.TagHelpers">Tag Helpers</a> instead.</p>
<p>I have some more blog post in the pipeline on the same topic; keeping the views and output clean. So stay tuned!</p>2016-01-07T19:47:00.0000000ZBlog postGenerate a download link to a file<p>This is somewhat of a hidden feature in EPiServer. But there is actually a built-in feature to send a download dialog to the user instead of opening the file directly. Soon the download attribute, that you can set on anchors, will work in all browsers but in the meanwhile we can do:</p> <pre class="language-csharp"><code>public static string GetDownloadLink(this ContentReference contentReferenceToMediaFile)
{
var url = UrlResolver.Current.GetUrl(contentReferenceToMediaFile);
return url + "/download";
}</code></pre>
<p>The important part here is of course <code>/download</code>. For images you can add <code>/thumbnail</code> (or the name of another blob property) to get the thumbnail of the image.</p>2015-09-23T15:19:19.0000000ZBlog postHow to inject a script for just one block?<p>The answer is very simple, but first your template(s) must meet these <a href="/link/082e2f78d59d4dd1ad02358aac4b379c.aspx">client resource requirements</a>. The article mention how to register a script on a page level, and in this case it will be injected on ALL templates that meet the requirements, i.e. page type name is XFormPage.</p> <p>But let’s say you just want to inject a script if a specific block is used on the page. One solution is to use the method in the article and then iterate through all blocks in the page’s content areas and see if the block is used. Probably not the smartest and fastest solution.</p> <p>A more simple solution is to require the script in the block’s view:</p> <pre class="language-csharp"><code>var clientResources = ServiceLocator.Current.GetInstance<IRequiredClientResourceList>();
clientResources.RequireScript("/scripts/my-block-script.js", "MyScript", new[] { "MainScripts" }).AtFooter();</code></pre>
<p>If the script doesn't have any dependencies, you can pass <code>Enumerable.Empty<string>()</code> instead of <code>new[] { "MainScripts" }</code>.</p>2015-02-04T20:54:59.0000000ZBlog postHow to inject a script for just one block?<p>The answer is very simple, but first your template(s) must meet these <a href="/link/082e2f78d59d4dd1ad02358aac4b379c.aspx">client resource requirements</a>. The article mention how to register a script on a page level, and in this case it will be injected on ALL templates that meet the requirements, i.e. page type name is XFormPage.</p><p>But let’s say you just want to inject a script if a specific block is used on the page. One solution is to use the method in the article and then iterate through all blocks in the page’s content areas and see if the block is used. Probably not the smartest and fastest solution.</p><p>A more simple solution is to require the script in the block’s view or in your controller:</p><pre class="language-csharp"><code>var clientResources = ServiceLocator.Current.GetInstance<IRequiredClientResourceList>();
clientResources.RequireScript("/scripts/my-block-script.js", "MyScript", new[] { "MainScripts" }).AtFooter();</code></pre><p>If the script doesn't have any dependencies, you can pass <code>Enumerable.Empty<string>()</code> instead of <code>new[] { "MainScripts" }</code>.</p>2015-02-04T20:54:59.0000000ZBlog postToday’s gotcha: Make sure if you really want to retrieve content with a WorkID!<p>So, I was struggling with creating and updating content in different languages from code. I was able to create language versions of every content for all the languages, but they all ended up with the same content – the content of the first language version, i.e. the master language!</p> <p>Turned out I was calling <code>Get<T>(ContentReference contentLink, ILanguageSelector selector)</code> in <code>IContentLoader</code> with a <code>ContentReference</code> that had a <var>WorkID</var> to get the current data for updating it. That did of course override the <var>selector</var> parameter I was passing with another language. The content I got back was in the language of the content with that specific WorkID (in this case the master language). So my code just kept updating the master language version and not the language version I was trying to update.</p> <p>Bottom line; Call <code>Get()</code> with a <code>ContentReference</code> without a <var>WorkID</var>, unless you really want to get that specific version of the content. You can call the extension method <code>ToReferenceWithoutVersion()</code> to construct a <code>ContentReference</code> without a <var>WorkID</var>.</p>2015-01-09T07:10:41.0000000ZBlog postToday’s gotcha: Make sure if you really want to retrieve content with a WorkID!<p>So, I was struggling with creating and updating content in different languages from code. I was able to create language versions of every content for all the languages, but they all ended up with the same content – the content of the first language version, i.e. the master language!</p> <p>Turned out I was calling <code>Get<T>(ContentReference contentLink, ILanguageSelector selector)</code> in <code>IContentLoader</code> with a <code>ContentReference</code> that had a <var>WorkID</var> to get the current data for updating it. That did of course override the <var>selector</var> parameter I was passing with another language. The content I got back was in the language of the content with that specific WorkID (in this case the master language). So my code just kept updating the master language version and not the language version I was trying to update.</p> <p>Bottom line; Call <code>Get()</code> with a <code>ContentReference</code> without a <var>WorkID</var>, unless you really want to get that specific version of the content. You can call the extension method <code>ToReferenceWithoutVersion()</code> to construct a <code>ContentReference</code> without a <var>WorkID</var>.</p>2015-01-09T07:10:41.0000000ZBlog postToday’s gotcha: Make sure you really want to retrieve content with a WorkID!<p>So, I was struggling with creating and updating content in different languages from code. I was able to create language versions of every content for all the languages, but they all ended up with the same content – the content of the first language version, i.e. the master language!</p> <p>Turned out I was calling <code>Get<T>(ContentReference contentLink, ILanguageSelector selector)</code> in <code>IContentLoader</code> with a <code>ContentReference</code> that had a <var>WorkID</var> to get the current data for updating it. That did of course override the <var>selector</var> parameter I was passing with another language. The content I got back was in the language of the content with that specific WorkID (in this case the master language). So my code just kept updating the master language version and not the language version I was trying to update.</p> <p>Bottom line; Call <code>Get()</code> with a <code>ContentReference</code> without a <var>WorkID</var>, unless you really want to get that specific version of the content. You can call the extension method <code>ToReferenceWithoutVersion()</code> to construct a <code>ContentReference</code> without a <var>WorkID</var>.</p>2015-01-09T02:10:21.0000000ZBlog postAdd support for container pages by marking content types with an interface<p>First of all, <a href="http://tech-fellow.net/2014/01/31/add-support-container-pages-episerver-7-5/">this is not a new concept</a> but the API has changed since EPiServer 7.14. IUIDescriptorInitializer is now obsolete. So here’s my take on this.</p> <p>First we need an interface to “mark” the content types with: </p> <pre class="language-csharp"><code>namespace DV
{
/// <summary>
/// Interface to mark content types as container pages, i.e. changing the icon
/// in the page tree and defaulting to All Properties view.
/// </summary>
public interface IContainerPage
{
}
}</code></pre>
<p>Then we need a function to get all types that is marked with this interface, this is a <a href="http://tech-fellow.net/2014/01/31/add-support-container-pages-episerver-7-5/">straight copy of Valdis code</a> but I wanted to include it in my post as well to avoid a possible dead link in the future:</p>
<pre class="language-csharp"><code>namespace DV
{
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
/// <summary>
/// Helper functions for working with types.
/// </summary>
public static class TypeFunctions
{
/// <summary>
/// Get all types that implements or is a subclass of the specified type.
/// </summary>
/// <typeparam name="T">The type of the superclass.</typeparam>
/// <returns>Returns a list of types that implements or is a subclass of the specified type.</returns>
public static IEnumerable<Type> GetTypesChildOf<T>()
{
var types = new List<Type>();
foreach (var assembly in TypeFunctions.GetAssemblies())
{
types.AddRange(TypeFunctions.GetTypesChildOfInAssembly(typeof(T), assembly));
}
return types;
}
private static IEnumerable<Assembly> GetAssemblies()
{
return AppDomain.CurrentDomain.GetAssemblies();
}
private static IEnumerable<Type> GetTypesChildOfInAssembly(Type type, Assembly assembly)
{
try
{
return assembly.GetTypes().Where(t => type.IsAssignableFrom(t) && t.IsClass);
}
catch (Exception)
{
// there could be situations when type could not be loaded
// this may happen if we are visiting *all* loaded assemblies in application domain
return Enumerable.Empty<Type>();
}
}
}
}</code></pre>
<p>Then we only need an initializable module that iterates through all UI descriptors, finds the ones that are marked with the IContainerPage interface and then finally set the default view and icon class.</p>
<pre class="language-csharp"><code>namespace DV
{
using System;
using System.Linq;
using EPiServer.Framework;
using EPiServer.Framework.Initialization;
using EPiServer.Shell;
using EPiServer.ServiceLocation;
[InitializableModule]
[ModuleDependency(typeof(EPiServer.Web.InitializationModule))]
public class ContainerPageUIDescriptorInitialization : IInitializableModule
{
public void Initialize(InitializationEngine context)
{
var containerTypes = TypeFunctions.GetTypesChildOf<IContainerPage>();
var registry = ServiceLocator.Current.GetInstance<UIDescriptorRegistry>();
var containerDescriptors = registry.UIDescriptors.Where(d => containerTypes.Contains(d.ForType));
foreach (var descriptor in containerDescriptors)
{
descriptor.DefaultView = CmsViewNames.AllPropertiesView;
descriptor.IconClass = ContentTypeCssClassNames.Container;
}
}
public void Preload(string[] parameters) { }
public void Uninitialize(InitializationEngine context)
{
// Do nothing.
}
}
}</code></pre>2014-10-22T00:59:02.0000000ZBlog postHow to create an editable 404 page<p>Every website should have a friendly 404 page. It’s also nice to give your clients the possibility to edit the content of the 404 page and maybe add a contact form as well. But how do we do it?</p> <p>First we need a model for the 404 page:</p> <pre class="language-csharp"><code>namespace DV.Models
{
using EPiServer.Core;
using EPiServer.DataAbstraction;
using EPiServer.DataAnnotations;
[ContentType(
GUID = "7ae4e3c3-d873-4e0b-a4ca-be7435bfd124")]
[AvailableContentTypes(
Availability = Availability.None)]
public class NotFoundPage : PageData
{
public override void SetDefaultValues(ContentType contentType)
{
base.SetDefaultValues(contentType);
this.VisibleInMenu = false;
}
}
}</code></pre>
<p>Then we need a template for the page and more importantly, we need to set the status code to 404:</p>
<pre class="language-csharp"><code>namespace DV.Views
{
using EPiServer;
using EPiServer.Editor;
using log4net;
using System;
using DV.Models;
public partial class NotFound : TemplatePage<NotFoundPage>
{
private static readonly ILog Log = LogManager.GetLogger(typeof(NotFound));
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
// Only set status code on GET and in view mode
if (!PageEditing.PageIsInEditMode && Request.HttpMethod == "GET")
{
Log.InfoFormat("404 {0}", Request.QueryString["aspxerrorpath"] ?? Request.RawUrl);
this.Response.Status = "404 not found";
this.Response.StatusCode = 404;
}
}
}
}</code></pre>
<p>It’s also good practice to log all the requests that are not found, this way we can determine if we need to set up rewrite rules for some of the missing resources. You would probably do this with Google Analytics as well. Notice that <strong>Request.RawUrl</strong> will contain the actual requested url!</p>
<p>Now we need to tell the application to route all 404’s to this page. This can be done by redirecting to a hard-coded url, e.g. /page-not-found/ or /views/notfound.aspx. But that’s not that nice. A better way is to just execute the url to the 404 page and keep the requested url in the address bar. This is easily done with some configuration inside the system.webServer section of web.config:</p>
<pre class="language-csharp"><code><system.webServer>
<httpErrors errorMode="Custom">
<remove statusCode="404" />
<error statusCode="404" path="/Views/NotFound.aspx" responseMode="ExecuteURL" />
</httpErrors>
</system.webServer></code></pre>
<p>The important part here is the responseMode. You could set it to just Redirect, but it’s much more clean to just execute the 404 page and keep the requested url. Then we need to turn off EPiServer’s error handling:</p>
<pre class="language-csharp"><code><episerver>
<applicationSettings globalErrorHandling="Off" />
</episerver></code></pre>
<p>Best practice is to also to configure customErrors inside system.Web:</p>
<pre class="language-csharp"><code><system.web>
<customErrors defaultRedirect="/Views/NotFound.aspx" mode="Off" redirectMode="ResponseRewrite">
<error statusCode="404" redirect="/Views/NotFound.aspx" />
</customErrors>
</system.web></code></pre>
<p>We do not have ExecuteURL here, but ResponseRewrite is the equivalent. Now all the 404’s will execute our template instead. But wait a minute, the content is not loading! That’s because the url cannot be resolved to any content, hence the 404. So we need to tell which page to actually load. In this case we will add a property to the start page, so an editor can select the 404 page:</p>
<pre class="language-csharp"><code>[AllowedTypes(new[] { typeof(NotFoundPage) })]
public virtual PageReference NotFoundPage { get; set; }</code></pre>
<p>And in the code-behind of our 404 template we just load that page in the OnPreInit event:</p>
<pre class="language-csharp"><code>protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
var contentLoader = ServiceLocator.Current.GetInstance<IContentLoader>();
var startPage = contentLoader.Get<StartPage>(ContentReference.StartPage);
if (!PageEditing.PageIsInEditMode && !ContentReference.IsNullOrEmpty(startPage.NotFoundPage))
{
this.CurrentPageLink = startPage.NotFoundPage;
}
}</code></pre>
<p>Voila! Now we have a working 404 page, where an editor can change the content of the page. There’s only one caveat, what happens if the website is globalized and we have more than one language? We need to load the 404 page in the correct language of course. This is a bit trickier and this is the best solution I came up with. Please let me know if there is a better way of doing this. In the code-behind of the template we just override the InitializeCulture event:</p>
<pre class="language-csharp"><code>protected override void InitializeCulture()
{
if (!PageEditing.PageIsInEditMode)
{
// Try to find the language id from the actual requested url
var segments = Request.RawUrl.Split('/');
var languageSegment = segments.Length > 1 ? segments[1] : string.Empty;
if (!string.IsNullOrWhiteSpace(languageSegment))
{
var languageMatcher = ServiceLocator.Current.GetInstance<ILanguageSegmentMatcher>();
var languageId = string.Empty;
if (languageMatcher.TryGetLanguageId(languageSegment, out languageId))
{
var currentLanguage = ServiceLocator.Current.GetInstance<IUpdateCurrentLanguage>();
// Update the language, if language id was found
currentLanguage.UpdateLanguage(languageId);
}
}
}
base.InitializeCulture();
}</code></pre>
<p>We’re parsing out the first segment of the requested url, then we’re trying to match that segment with all available language versions of the page, including fallback settings. The correct language will be loaded automatically, if we have a domain for the language and not a segment in the url, but that’s not always the case.</p>2014-08-28T18:33:14.0000000ZBlog postWrap properties with extra markup<p>I’m still on my quest for clean markup and a nice editor experience. Please see my previous <a href="/post/how-to-handle-links-in-blocks">post how about to handle wrapping links</a>. In this post I will cover a way to add wrapper markup to properties, that is only rendered in edit mode or when the properties have values. Notice that this will work for multiple properties, since quite often we have markup that wraps more than one property. So why would we even bother about this, you might ask? Well, sometimes we have styling that will apply to the wrapping markup, that we don’t want to show if the properties doesn’t have a value.</p> <p>I don’t think there is much to say about the code, it’s very self-explanatory, so here it comes:</p> <pre class="language-csharp"><code>namespace DV.WebControls
{
using System;
using System.ComponentModel;
using System.Linq;
using System.Web.UI;
using System.Web.UI.WebControls;
using EPiServer.Editor;
using EPiServer.ServiceLocation;
using EPiServer.Web;
public enum EvaluationType
{
Any,
All
}
/// <summary>
/// A web control that always renders all child controls in edit mode. In view mode all specified
/// properties' value is evaluated. If the evalutation is successful according to the specified EvaluationType,
/// all child controls are rendered. Otherwise no child controls are rendered.
/// </summary>
[ParseChildren(false)]
[PersistChildren(true)]
public class PropertyPlaceHolder : Control
{
/// <summary>
/// Initializes a new instance of the <see cref="PropertyPlaceHolder" /> class.
/// </summary>
public PropertyPlaceHolder()
{
this.EvaluationType = EvaluationType.Any;
}
/// <summary>
/// Gets or sets the type of the evaluation.
/// </summary>
public EvaluationType EvaluationType { get; set; }
/// <summary>
/// Gets or sets the name of the property.
/// </summary>
[TypeConverter(typeof(StringArrayConverter))]
public string[] PropertyName { get; set; }
// ReSharper disable once UnusedAutoPropertyAccessor.Local
private Injected<ControlRenderContextBuilder> ContextBuilder { get; set; }
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (this.Visible && this.PropertyName != null)
{
if (this.EvaluationType == EvaluationType.Any)
{
this.Visible = this.PropertyName.Any(this.ShouldRenderControl);
}
if (this.EvaluationType == EvaluationType.All)
{
this.Visible = this.PropertyName.All(this.ShouldRenderControl);
}
}
}
private bool ShouldRenderControl(string propertyName)
{
var propertyContext = this.ContextBuilder.Service.BuildContext(this, propertyName);
if (PageEditing.PageIsInEditMode)
{
return propertyContext.IsEditable();
}
var property = propertyContext.PropertyContainer.Property[propertyName];
// In view mode, we only need to check if the property
// has a value or not.
return property != null && property.IsNull == false;
}
}
}</code></pre>
<h2>Here are some examples on how we can use the control</h2>
<p>In this first example we want to wrap a content area with teaser blocks:</p>
<pre class="language-csharp"><code><DV:PropertyPlaceHolder PropertyName="Teasers" runat="server">
<div class="teaser-listing">
<div class="wrapper">
<EPiServer:Property PropertyName="Teasers" CssClass="m-cols-2" runat="server">
<RenderSettings ChildrenCssClass="m-col" />
</EPiServer:Property>
</div>
</div>
</DV:PropertyPlaceHolder></code></pre>
<p>In this second example we want to create a definition list of a bunch of contact information properties, notice that the dl element will get rendered if any of the specified properties have a value:</p>
<pre class="language-csharp"><code><DV:PropertyPlaceHolder PropertyName="Department,Office,Email,Telephone" EvaluationType="Any" runat="server">
<dl>
<DV:PropertyPlaceHolder PropertyName="Department" runat="server">
<dt>Department</dt>
<EPiServer:Property PropertyName="Department" CustomTagName="dd" runat="server" />
</DV:PropertyPlaceHolder>
<DV:PropertyPlaceHolder PropertyName="Office" runat="server">
<dt>Office</dt>
<EPiServer:Property PropertyName="Office" CustomTagName="dd" runat="server" />
</DV:PropertyPlaceHolder>
<DV:PropertyPlaceHolder PropertyName="Email" runat="server">
<dt>Email</dt>
<EPiServer:Property PropertyName="Email" CustomTagName="dd" runat="server" />
</DV:PropertyPlaceHolder>
<DV:PropertyPlaceHolder PropertyName="Telephone" runat="server">
<dt>Telephone</dt>
<EPiServer:Property PropertyName="Telephone" CustomTagName="dd" runat="server" />
</DV:PropertyPlaceHolder>
</dl>
</DV:PropertyPlaceHolder></code></pre>2014-07-06T04:09:25.0000000ZBlog postTest 1this is a test2014-06-02T11:58:00.0000000ZBlog postHow to handle links in blocks and pages, that should wrap content<p>First off, there is a similar solution already in the Alloy templates. But this one is a bit more refined.</p> <p>So the problem. Lets say you have a block that represents a teaser, the teaser has a tagline, heading, image and link. When the editor has specified a link, the tagline and heading should be wrapped with the link, otherwise they should be wrapped with a div. Something like this:</p> <pre class="language-csharp"><code><div class="teaser">
<div class="image-wrapper">
<img src="/image.jpg" alt="" />
</div>
<a class="content-wrapper" href="/about-us/">
<p>Tagline</p>
<h2>Heading</h2>
</a>
</div></code></pre>
<p>And without a link:</p>
<pre class="language-csharp"><code><div class="teaser">
<div class="image-wrapper">
<img src="/image.jpg" alt="" />
</div>
<div class="content-wrapper">
<p>Tagline</p>
<h2>Heading</h2>
</div>
</div></code></pre>
<p>There is also the case when the teaser should be edited, the link can cause problems for the editors and it’s best to replace it then as well.</p>
<p>This can be solved with a lot of if-statements in the markup and check if the link is null and/or you’re in edit mode, maybe in a combination with placeholder controls with the markup that should be toggled. It will get messy though. Something like this:</p>
<pre class="language-csharp"><code><div class="teaser">
<div class="image-wrapper">
<EPiServer:Property runat="server" PropertyName="Image" />
</div>
<asp:PlaceHolder runat="server" Visible="<%# CurrentBlock.Link != null && PageEditing.PageIsInEditMode == false %>">
<a class="content-wrapper" href="<%= CurrentBlock.Link %>">
</asp:PlaceHolder>
<asp:PlaceHolder runat="server" Visible="<%# CurrentBlock.Link == null || PageEditing.PageIsInEditMode %>">
<div class="content-wrapper">
</asp:PlaceHolder>
<EPiServer:Property runat="server" PropertyName="Tagline" CustomTagName="p" />
<EPiServer:Property runat="server" PropertyName="Heading" CustomTagName="h2" />
<asp:PlaceHolder runat="server" Visible="<%# CurrentBlock.Link == null || PageEditing.PageIsInEditMode %>">
</div>
</asp:PlaceHolder>
<asp:PlaceHolder runat="server" Visible="<%# CurrentBlock.Link != null && PageEditing.PageIsInEditMode == false %>">
</a>
</asp:PlaceHolder>
</div></code></pre>
<p>Instead we can create a web control that handles this. We can then use this web control to wrap the content. If we have specified a tag name in <strong>CustomTagName</strong>, this tag will be rendered instead of the link if the link is null or we’re in edit mode, otherwise no tag will be rendered.</p>
<pre class="language-csharp"><code>namespace DV.Controls
{
using EPiServer;
using EPiServer.Editor;
using System;
using System.Web.UI;
using System.Web.UI.WebControls;
/// <summary>
/// A web control that renders a hyperlink when not in edit mode and the specified url is not null.
/// If in edit mode or the url is null, a tag of the type specified in CustomTageName is rendered instead.
/// If no tag is specified in CustomTageName, no tag is rendered at all.
/// </summary>
[ParseChildren(false)]
[PersistChildren(true)]
public class ToggleLink : WebControl
{
public Url Url { get; set; }
public string CustomTagName { get; set; }
private bool RenderCustomTag
{
get
{
return PageEditing.PageIsInEditMode || this.Url == null;
}
}
protected override HtmlTextWriterTag TagKey
{
get
{
if (this.RenderCustomTag)
{
if (string.IsNullOrEmpty(this.CustomTagName))
{
return HtmlTextWriterTag.Unknown;
}
else
{
return (HtmlTextWriterTag)Enum.Parse(
typeof(HtmlTextWriterTag),
this.CustomTagName,
true);
}
}
return HtmlTextWriterTag.A;
}
}
protected override void AddAttributesToRender(HtmlTextWriter writer)
{
base.AddAttributesToRender(writer);
if (this.TagKey == HtmlTextWriterTag.A)
{
writer.AddAttribute(HtmlTextWriterAttribute.Href, this.Url.ToString());
}
}
public override void RenderBeginTag(HtmlTextWriter writer)
{
if (this.RenderCustomTag &&
this.TagKey == HtmlTextWriterTag.Unknown)
{
return;
}
base.RenderBeginTag(writer);
}
public override void RenderEndTag(HtmlTextWriter writer)
{
if (this.RenderCustomTag &&
this.TagKey == HtmlTextWriterTag.Unknown)
{
return;
}
base.RenderEndTag(writer);
}
}
}</code></pre>
<p>Now we can write like this instead:</p>
<pre class="language-csharp"><code><div class="teaser">
<div class="image-wrapper">
<EPiServer:Property runat="server" PropertyName="Image" />
</div>
<DV:ToggleLink Url="<%# CurrentBlock.Link %>" CustomTagName="div" CssClass="content-wrapper" runat="server">
<EPiServer:Property runat="server" PropertyName="Tagline" CustomTagName="p" />
<EPiServer:Property runat="server" PropertyName="Heading" CustomTagName="h2" />
</DV:ToggleLink>
</div></code></pre>
<p>Much nicer code, if you ask me.</p>2014-02-27T06:25:12.0000000ZBlog post