Defining page template properties

For properties to have an effect on a template’s appearance or functionality, you need to retrieve the property values and adjust the template’s output code or logic correspondingly. The required steps depend on the development approach used to create the template (see Developing page templates for more information).

Basic page templates

For templates without a custom controller class, handle the property values in the template’s view.

The view must use the generic ComponentViewModel<TPropertyModel> class as its model, with the appropriate property model class as the generic type parameter. The system’s default controller ensures that the property values configured for the currently processed template are passed to the view. Retrieve the property values from the model’s Properties member, which returns an object of the specified property model class.

Page templates with a custom controller

To work with the properties in your page template controllers, the controller class must inherit from the generic PageTemplateController<TPropertyModel> base class, with the appropriate property model class as the generic type parameter.

public class LandingPageTemplateController : PageTemplateController<LandingPageProperties>

Retrieve the properties as a strongly typed object via the IPageTemplatePropertiesRetriever service (Kentico.PageBuilder.Web.Mvc namespace) and its Retrieve<TPropertiesType> method. The method returns an object of the specified property model class. The object’s property values are loaded from the current configuration of the processed section.

// Contains an instance of the IPageTemplatePropertiesRetriever service. For example, obtained via dependency injection.
private readonly IPageTemplatePropertiesRetriever pageTemplatePropertiesRetriever;

// Gets the value of a page template's property (e.g. within the Index action of the template's controller)
LandingPageProperties properties = pageTemplatePropertiesRetriever.Retrieve<LandingPageProperties>();
bool propertyValue = templateProperties.ShowTitle;

You can then adjust the code of your controller based on the values of individual page template properties, or pass them to the page template’s view using an appropriate view model.

Accessing template properties in POST actions

Page template properties cannot be by default retrieved during POST requests. Such requests lack the context of the current page and template instance.

To retrieve template properties in POST actions, you first need to include the properties into the data submitted by the corresponding HTML form in the template’s output. Call the Html.Kentico().ComponentPropertiesData extension method within the given form tag in your template’s view.

using System.Web.Mvc.Ajax
using Kentico.Web.Mvc
using Kentico.PageBuilder.Web.Mvc

...

@using (Ajax.BeginForm("PostAction", "LandingPageTemplate", null, new AjaxOptions
{
    HttpMethod = "POST",
    UpdateTargetId = "templateForm"
}, new { id = "templateForm" }))
{
    @Html.Kentico().AntiForgeryToken()
    @Html.Kentico().ComponentPropertiesData()
    ...
    <input type="submit" value="Submit" />
}

The method renders a hidden field that persists the template’s properties and makes them available in controller actions via the IPageTemplatePropertiesRetriever service.

The following scenario will guide you through a step-by-step process of developing a simple page template with a configurable property.

When finished, the template can be selected when creating a new landing page of the appropriate page type. The template contains two editable areas with default sections differentiated by a background color (the bottom section has a gray background) and displays a page title by default. Visibility of the page title can be adjusted in the administration interface using a check box in the property configuration dialog.

Property model

Create a property model LandingPageProperties.cs in the ~/Models/PageTemplates/LandingPage folder:

using Kentico.Forms.Web.Mvc;
using Kentico.PageBuilder.Web.Mvc.PageTemplates;

namespace LearningKit.Models.PageTemplates.LandingPage
{
    public class LandingPageProperties : IPageTemplateProperties
    {
       // Defines a property and sets its default value
       // Assigns the default Xperience checkbox component, which saves a boolean value 
       // depending on the state of the checkbox in the page template's configuration dialog
       [EditingComponent(CheckBoxComponent.IDENTIFIER, Order = 0, Label = "Show title")]
       public bool ShowTitle { get; set; } = true;
    }
}

View

Start by creating a _PageTemplateLayout.cshtml layout for page template views in the ~/Views/Shared folder. The layout calls extension methods that provide links to scripts and stylesheet files required for page builder editable areas:

@using Kentico.Activities.Web.Mvc
@using Kentico.OnlineMarketing.Web.Mvc
@using Kentico.PageBuilder.Web.Mvc
@using Kentico.Web.Mvc

@{
    Layout = null;
}
<!DOCTYPE html>

<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <meta charset="UTF-8" />
    <title>@ViewBag.Title - Learning Kit</title>
    @Html.Kentico().PageBuilderStyles()

    @* Registers scripts that ensure logging of campaign page visits and page-related activities *@
    @Html.Kentico().ActivityLoggingScript()

    @* Registers scripts that ensure logging of analytics data for A/B tests *@
    @Html.Kentico().ABTestLoggerScript()

    @* Registers scripts that provide logging of web analytics data *@
    @Html.Kentico().WebAnayticsLoggingScript()
</head>
<body>
    @RenderBody()
    @Html.Kentico().PageBuilderScripts()        
</body>
</html>

Create a view _LandingPageTemplate.cshtml in the ~/Views/Shared/PageTemplates folder:

@using Kentico.PageBuilder.Web.Mvc
@using Kentico.Web.Mvc

@using LearningKit.Models.PageTemplates.LandingPage

@model ComponentViewModel<LandingPageProperties>

@{
    Layout = "~/Views/Shared/_PageTemplateLayout.cshtml";
}

@{
    // Sets the page title to the name of the current page
    ViewBag.Title = Model.Page.DocumentName;
}

@if (Model.Properties.ShowTitle)
{
    <h1>@Model.Page.DocumentName</h1>
}

<div>
    <div>
        @Html.Kentico().EditableArea("top")
    </div>
    <div style="background-color: #eeeeee">
        @Html.Kentico().EditableArea("bottom")
    </div>
</div>

Template registration

Register the template into the system using the RegisterPageTemplate assembly attribute. We recommend adding a dedicated code file to your project’s ~/App_Start folder for the purposes of component registration, for example named PageBuilderComponentRegister.cs.

using LearningKit.Models.PageTemplates.LandingPage;

using Kentico.PageBuilder.Web.Mvc.PageTemplates;

[assembly: RegisterPageTemplate("LearningKit.LandingPageTemplate",
                               "Default Landing page template",
                               typeof(LandingPageProperties),
                               customViewName: "PageTemplates/_LandingPageTemplate",
                               IconClass = "icon-l-rows-2")]