Kentico Xperience 13

https://docs.kentico.com/
Admin
Kentico Xperience 13 is a digital experience platform that enables developers to build websites,...
Tokens:4,683,999
Snippets:74,440
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Silent Installation Configuration Example

Source: https://docs.kentico.com/x/24Q8

A full configuration file example for performing a silent installation of Kentico, including database, IIS, and website settings.

```xml
<SilentInstall ShowProgress="CommandPrompt" Log="true" OnError="Stop" LogFile="{%programfiles%}\Kentico\8.0\setup.log" CheckRequirements="False" >
  <Setup NET="4.5" SetupFolder="{%programfiles%}\Kentico\8.0" Location="Local" InstallOnlyProgramFiles="False" OpenAfterInstall="true" DeleteExisting="False" DoNotOverwriteInstallation="True" RegisterCounters="False" InstallWinServices="False" RegisterApplicationToEventLog="False" WebProject="WebSite" KillRunningProcesses="False" />
  <IIS Website="Default Web Site" TargetFolder="C:\inetpub\wwwroot\Kentico8_{%fileversion%}" DeleteExisting="GetUnique" KillRunningProcesses="False" />
  <Sql InstallDatabase="true" Server="Artemis" Authentication="SQL" SqlName="login" SqlPswd="password" Database="Kentico8_{%fileversion%}" Operation="New" DeleteExisting="false" />
  <WebTemplates type="InstallAll">
  </WebTemplates>
  <UICultures type="InstallAll">
  </UICultures>
  <Modules type="InstallAll">
  </Modules>
  <Dictionaries type="InstallAll">
  </Dictionaries>
  <WebSites>
    <WebSite domain="localhost" displayname="Corporate site" webtemplatename="CorporateSite" />
  </WebSites>
  <Licenses>
    <License domain="localhost"><![CDATA[DOMAIN:localhost
PRODUCT:CF08
EXPIRATION:00000000
PACKAGES:
SERVERS:1
ODWrIUyRdEv3Ko+7kLCN2WD4jEsOl3l0+au1AJ3zU0Jw5b3Q1h1eBlWh1fNAWAe2NbSb6gm1qUhJHdUTI4rBPANDgmYvEBFZRqpYbDYVCYsXEeQy4H2ipwXfASGFMI5UuKvHRTJ5KBo9OE4k4ZJmPVratLjOcSvFVERhGubZl7MZghwCBSHQNNvN3RWN3mwi1+vgou+N/Z1XDWXtfprzDEwFFJHyl/4NOoKbNzvGhuV1Jmq1XbGiT8Od0Y2vufeqzcM4VdFRRAOlIoQHFwwfyEah2kSw1z9zUbqWj3nZqZUD6jXi8FokOWKWzZeybg9NQgZ1+vtd7jg1B1+bz/Te+w==]]></License>
  </Licenses>
</SilentInstall>
```

--------------------------------

### Execute Command Line Installation

Source: https://docs.kentico.com/x/WwmRBg

Run the Xperience installer executable with a specified XML configuration file to perform an automated installation.

```bash
Xperience_13_0.exe InstallationProfile.xml
```

--------------------------------

### Install the admin development boilerplate

Source: https://docs.kentico.com/documentation/developers-and-admins/customization/extend-the-administration-interface/prepare-your-environment-for-admin-development

Use the .NET CLI to install the Kentico Xperience admin sample template into your project directory.

```bash
dotnet new kentico-xperience-admin-sample -n <project_name>
```

--------------------------------

### Execute Kentico command line installation

Source: https://docs.kentico.com/x/0oQ8

Run the installer executable with the configuration XML file as a parameter to initiate the automated installation process.

```text
Kentico_8_0.exe KenticoInstallationProfile.xml
```

--------------------------------

### Install and build client dependencies

Source: https://docs.kentico.com/x/zgSiCQ

Prepares the client-side environment for development.

```cmd
cd ..\Acme.Web.Admin\Client
npm install
npm run build
```

--------------------------------

### Install Xperience project templates

Source: https://docs.kentico.com/guides/development/developer-kickstart/set-up-an-xperience-by-kentico-project

Use the .NET CLI to install the specific version of Xperience project templates. The --force parameter ensures the specified version is installed even if other versions are present.

```bash
dotnet new install kentico.xperience.templates::30.6.1 --force
```

--------------------------------

### Install and Build Client Dependencies

Source: https://docs.kentico.com/documentation/developers-and-admins/customization/extend-the-administration-interface/prepare-your-environment-for-admin-development

Prepares the client-side module for development.

```bash
# Switches to the directory containing boilerplate client module code
cd ..\Acme.Web.Admin\Client
npm install
npm run build
```

--------------------------------

### MCP Server Configuration Examples

Source: https://docs.kentico.com/x/mcp_server_xp

Configuration formats for connecting to the Xperience by Kentico MCP server, including direct HTTP and proxy-based setups.

```json
{
  "kentico-docs-mcp": {
    "type": "http",
    "url": "https://docs.kentico.com/mcp"
  }
}
```

```json
{
  "mcpServers": {
    "remote-example": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://docs.kentico.com/mcp"
      ]
    }
  }
}
```

--------------------------------

### Registering event handlers on application start

Source: https://docs.kentico.com/x/uo2-BQ

Example of calling the registration method within the Application_Start method in Global.asax.cs.

```csharp
protected void Application_Start()
{
    ...

    FormFieldMarkupInjection.RegisterEventHandlers();
}
```

--------------------------------

### Install project templates via .NET CLI

Source: https://docs.kentico.com/documentation/developers-and-admins/installation

Installs the latest version of the Xperience by Kentico project templates package.

```bash
dotnet new install kentico.xperience.templates
```

--------------------------------

### Start Webpack Dev Server

Source: https://docs.kentico.com/documentation/developers-and-admins/customization/extend-the-administration-interface/prepare-your-environment-for-admin-development

Starts the development server for Proxy mode.

```bash
npm run start
```

--------------------------------

### Direct model mapping examples

Source: https://docs.kentico.com/x/content_retriever_api_xp

Examples demonstrating direct mapping to custom classes and generated models without explicit registration.

```csharp
// Custom model class without content type registration
public class SimpleArticle
{
    public string Title { get; set; }
    public string Summary { get; set; }
    public DateTime PublishedDate { get; set; }
}

var contentTypes = new[] { ArticlePage.CONTENT_TYPE_NAME, BlogPage.CONTENT_TYPE_NAME };

// Direct mapping to custom model 'SimpleArticle' that does not need to be registered
var articles = await contentRetriever.RetrievePagesOfContentTypes<SimpleArticle>(contentTypes);
```

```csharp
// 'ArticleGenerated' is a model class generated by Xperience
// Works the same way as before - uses registered mapping if available
var articles = await contentRetriever.RetrievePages<ArticleGenerated>();
```

--------------------------------

### Install SharePoint Client Components via Batch File

Source: https://docs.kentico.com/x/-QSOAw

Use this command in a startup.cmd batch file to silently install the SharePoint Server 2013 Client Components SDK on an Azure instance.

```batch
msiexec /i sharepointclientcomponents_VERSION.msi /q /log sharepointclientcomponentinstall.log
```

--------------------------------

### Configure the Starter Kit in Program.cs

Source: https://docs.kentico.com/guides/development/email-marketing/use-email-builder-starter-kit

Sets up the Starter Kit options including stylesheet paths and allowed content types for widgets.

```C#
...
using Kentico.Xperience.Mjml.StarterKit.Rcl;
using Kentico.Xperience.Mjml.StarterKit.Rcl.Sections;
...
builder.Services.AddKenticoMjmlStarterKit(options =>
{
    options.StyleSheetPath = "EmailBuilder.css";
    // The Asset content type, which we mapped to the Image widget earlier
    options.AllowedImageContentTypes = [Asset.CONTENT_TYPE_NAME];
    // The Service page content type, which we mapped to the Product widget earlier.
    options.AllowedProductContentTypes = [ServicePage.CONTENT_TYPE_NAME];
});
...
```

--------------------------------

### Call AddTrainingGuidesOptions in Program.cs

Source: https://docs.kentico.com/guides/development/email-marketing/create-an-email-widget-for-articles

Invoke the registration method in the application startup file after service initialization.

```csharp
...
builder.Services.AddTrainingGuidesServices();
builder.Services.AddTrainingGuidesOptions();
...
```

--------------------------------

### GET /<object type>/<id or guid>

Source: https://docs.kentico.com/x/GYJsAw

Retrieves a specific object by its ID or GUID.

```APIDOC
## GET /<object type>/<id or guid>

### Description
Retrieves the object of the given type with the specified identifier (ID or GUID value). Ignores site bindings.

### Method
GET

### Endpoint
/<object type>/<id or guid>
```

--------------------------------

### Install the web development plugin

Source: https://docs.kentico.com/guides/development/kenticopilot

Commands to add the Kentico marketplace and install the web development plugin within Claude Code.

```text
/plugin marketplace add Kentico/xperience-by-kentico-kenticopilot
/plugin install kentico-web-development@xperience-by-kentico-kenticopilot
```

--------------------------------

### GET /getdoc/<page GUID>/<page name><extension>

Source: https://docs.kentico.com/x/qwKOAw

Retrieves a permanent link to a page using its GUID.

```APIDOC
## GET /getdoc/<page GUID>/<page name><extension>

### Description
Creates a permanent link to a page. The link remains valid even if the page is moved.

### Method
GET

### Endpoint
/getdoc/<page GUID>/<page name><extension>

### Parameters
#### Path Parameters
- **page GUID** (string) - Required - The globally unique identifier of the page.
- **page name** (string) - Required - A descriptive name for the URL, used for SEO purposes.
- **extension** (string) - Required - The file extension (e.g., .aspx).
```

--------------------------------

### Sample project-structure instruction file

Source: https://docs.kentico.com/guides/upgrade-to-xbyk/assisted-upgrades/kenticopilot-code-migration-best-practices

An example of how to define the desired folder layout and feature organization for the agent to follow.

```text
src/
├── DemoProject.Entities/   # Interfaces and generated content type classes
├── DemoProject.Core/       # Domain models and business logic, no infrastructure
├── DemoProject.Web/        # ASP.NET Core app: UI + infrastructure
└── DemoProject.Admin/      # Admin customizations

Web/Features/Blog/
├── BlogPostPageController.cs   # Thin: injects a service, returns a view
├── Repositories/               # Data access, returns domain models
├── Services/                   # Orchestrates repositories + domain logic
├── ViewModels/
└── Views/
```

--------------------------------

### Set administrator password in installation script

Source: https://docs.kentico.com/x/0ADyAQ

Example of setting the administrator password variable within the installation command file.

```batch
SET _adminPassword=QyCZ5HDj
```

--------------------------------

### Set application identifier in installation script

Source: https://docs.kentico.com/x/0ADyAQ

Example of setting the application identifier variable within the installation command file.

```batch
SET _applicationIdentifier=My Web Site/Kentico8
```

--------------------------------

### Add Starter Kit to Solution via .NET CLI

Source: https://docs.kentico.com/guides/development/email-marketing/use-email-builder-starter-kit

Use the .NET CLI to register the Starter Kit project file within your existing solution.

```cmd
dotnet sln TrainingGuides.sln add Kentico.Xperience.Mjml.StarterKit.Rcl\Kentico.Xperience.Mjml.StarterKit.Rcl.csproj
```

--------------------------------

### GET /{object type}/global/{object code name or guid}

Source: https://docs.kentico.com/x/3wSOAw

Retrieves a global object of the specified type using its code name or GUID.

```APIDOC
## GET /{object type}/global/{object code name or guid}

### Description
Retrieves a global object of the specified type using its code name or GUID.

### Method
GET

### Endpoint
/{object type}/global/{object code name or guid}
```

--------------------------------

### GET /getdoc/<document GUID>/<document name><extension>

Source: https://docs.kentico.com/x/AQVb

Creates a permanent link to a document using its GUID. The document name is optional for the system but useful for SEO.

```APIDOC
## GET /getdoc/<document GUID>/<document name><extension>

### Description
Retrieves a document using its globally unique identifier (GUID). This link remains valid even if the document is moved.

### Parameters
#### Path Parameters
- **document GUID** (string) - Required - The globally unique identifier of the document.
- **document name** (string) - Required - A descriptive name for the URL.
- **extension** (string) - Required - The file extension.
```

--------------------------------

### Install the Health monitoring service via command line

Source: https://docs.kentico.com/x/QCF6Aw

Use the .NET Framework InstallUtil.exe tool to register the service, specifying the web path and the path to the service executable.

```bash
InstallUtil /webpath="C:\inetpub\wwwroot\Kentico\CMS" "c:\inetpub\wwwroot\Kentico\CMS\bin\HealthMonitoringService.exe" /LogToConsole=true /i
```

--------------------------------

### Retrieve user data via REST GET request

Source: https://docs.kentico.com/x/3wSOAw

Example of a GET request to fetch administrator user data, including basic authentication and character encoding headers.

```http
GET http://localhost/Kentico/rest/cms.user/administrator HTTP/1.1
Authorization: Basic UmVzdENsaWVudDpNeVBhc3N3b3Jk
Accept-Charset: utf-8
Content-Type: text\xml
```

--------------------------------

### Application startup output

Source: https://docs.kentico.com/guides/development/developer-kickstart/set-up-an-xperience-by-kentico-project

Example terminal output showing the local URL where the application is hosted.

```text
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:33328
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: <path_to_project_directory>
```

--------------------------------

### GET /{object type}/site/{site name}/{object code name or guid}

Source: https://docs.kentico.com/x/3wSOAw

Retrieves an object of the specified type assigned to a specific site using its code name or GUID.

```APIDOC
## GET /{object type}/site/{site name}/{object code name or guid}

### Description
Retrieves an object of the specified type assigned to a specific site using its code name or GUID.

### Method
GET

### Endpoint
/{object type}/site/{site name}/{object code name or guid}
```

--------------------------------

### RetrieveContentByGuids

Source: https://docs.kentico.com/x/8ASiCQ

Example of retrieving content data based on the GUIDs selected via the content selector.

```APIDOC
## [IContentRetriever.RetrieveContentByGuids<T>]

### Description
Retrieves the data of selected content items using their GUIDs obtained from the selector.

### Method
Async Task

### Parameters
- **guids** (IEnumerable<Guid>) - Required - The list of content item identifiers.
- **parameters** (RetrieveContentParameters) - Required - Configuration for retrieval, such as LinkedItemsMaxLevel.

### Example
```csharp
var coffeeGuids = model?.Properties?.SelectedProducts.Select(i => i.Identifier).ToList();

IEnumerable<Coffee> result = await contentRetriever.RetrieveContentByGuids<Coffee>(coffeeGuids,
    new RetrieveContentParameters
    {
        LinkedItemsMaxLevel = 1
    });
```
```

--------------------------------

### Implement Options Setup Class

Source: https://docs.kentico.com/guides/development/customizations-and-integrations/access-custom-global-configurations

Implement IConfigureOptions to populate the options model by querying global settings keys via the IInfoProvider.

```C#
using CMS.DataEngine;
using Microsoft.Extensions.Options;
using TrainingGuides.ProjectSettings;

namespace TrainingGuides.Web.Features.EmailNotifications;

public class EmailNotificationOptionsSetup : IConfigureOptions<EmailNotificationOptions>
{
    // Settings key code names of the two email notification settings.
    private const string FROM_ADDRESS_SETTINGS_KEY = "EmailNotificationFromAddress";
    private const string TO_ADDRESSES_SETTINGS_KEY = "EmailNotificationToAddresses";

    // Provide access to the objects of GlobalSettingsKeyInfo class using the generic IInfo provider and dependency injection.
    private readonly IInfoProvider<GlobalSettingsKeyInfo> globalSettingsKeyInfoProvider;

    public EmailNotificationOptionsSetup(IInfoProvider<GlobalSettingsKeyInfo> globalSettingsKeyInfoProvider)
    {
        this.globalSettingsKeyInfoProvider = globalSettingsKeyInfoProvider;
    }

    // Implement the Configure method of the IConfigureOptions interface.
    public void Configure(EmailNotificationOptions options)
    {
        // Retrieve GlobalSettingsKeyInfo objects
        // with a 'EmailNotificationFromAddress' or 'EmailNotificationToAddresses' code name
        // using ObjectQuery API.
        var emailSettings = globalSettingsKeyInfoProvider.Get()
            .WhereEquals(nameof(GlobalSettingsKeyInfo.GlobalSettingsKeyName), FROM_ADDRESS_SETTINGS_KEY)
            .Or()
            .WhereEquals(nameof(GlobalSettingsKeyInfo.GlobalSettingsKeyName), TO_ADDRESSES_SETTINGS_KEY)
            .GetEnumerableTypedResult();

        // Filter out sender address and recipient addresses and store them in variables respectively.
        var fromAddress = emailSettings.FirstOrDefault(s => s.GlobalSettingsKeyName == FROM_ADDRESS_SETTINGS_KEY);
        var toAddresses = emailSettings.FirstOrDefault(s => s.GlobalSettingsKeyName == TO_ADDRESSES_SETTINGS_KEY);

        // Populate the EmailNotificationOptions model.
        options.SenderAddress = fromAddress?.GlobalSettingsKeyValue ?? string.Empty;
        options.RecipientAddresses = toAddresses?.GlobalSettingsKeyValue ?? string.Empty;
    }
}
```

--------------------------------

### Making a Web API Call

Source: https://docs.kentico.com/x/_YO-BQ

Example of an HTTP GET request to the custom registered route.

```javascript
$http.get("http://myserver/customapi/CustomWebAPI", { id: 1})
    .success(function (data) {
        alert(data);
    })
    .error(function(error) {
        // Handle the error
    });
```

--------------------------------

### Install the Scheduler Windows service via command line

Source: https://docs.kentico.com/x/54JsAw

Use the .NET InstallUtil.exe tool to register the service, specifying the web path and the path to the service executable.

```bash
InstallUtil.exe /webpath="C:\inetpub\wwwroot\Kentico\CMS" "c:\inetpub\wwwroot\Kentico\CMS\bin\SchedulerService.exe" /LogToConsole=true /i
```

--------------------------------

### Launch local application

Source: https://docs.kentico.com/guides/development/developer-kickstart/set-up-an-xperience-by-kentico-project

Starts the application using the Kestrel web server from the project directory.

```bash
dotnet run
```

--------------------------------

### Implement SetupControl Method

Source: https://docs.kentico.com/x/VIRsAw

Logic to assign the text property and apply width styles to the control during initialization.

```csharp
/// <summary>
/// Initializes the control properties.
/// </summary>
protected void SetupControl()
{
     if (StopProcessing)
     {
         // Do not process.
     }
     else
     {
         // Loads and assigns the button caption.
         txtElem.Text = Text;

         // Sets up width resizing.
         string width = WebPartWidth;
         if (!String.IsNullOrEmpty(width))
         {
             txtElem.Style += String.Format("width: {0};", width);
         }
```

--------------------------------

### GET /getattachment/<file GUID>/<filename><extension>

Source: https://docs.kentico.com/x/GINsAw

Creates a permanent link to a file uploaded as a page attachment.

```APIDOC
## GET /getattachment/<file GUID>/<filename><extension>

### Description
Retrieves a file attachment using its unique file GUID.

### Parameters
#### Path Parameters
- **file GUID** (string) - Required - The GUID of the file in the CMS_Attachment database table.
- **filename** (string) - Required - The name of the file.
- **extension** (string) - Required - The file extension.
```

--------------------------------

### GET /getattachment/<file GUID>/<filename><extension>

Source: https://docs.kentico.com/x/AQVb

Creates a permanent link to a file uploaded as a document attachment.

```APIDOC
## GET /getattachment/<file GUID>/<filename><extension>

### Description
Retrieves a file attachment using its unique file GUID from the CMS_Attachment table.

### Parameters
#### Path Parameters
- **file GUID** (string) - Required - The GUID of the file in the CMS_Attachment database table.
- **filename** (string) - Required - The name of the file.
- **extension** (string) - Required - The file extension.
```

--------------------------------

### Configure Kentico Xperience services in Startup.cs

Source: https://docs.kentico.com/x/SAaRBg

Add the required using statements and configure Kentico features within the ConfigureServices method of the Startup class.

```csharp
using Kentico.Web.Mvc;
using Kentico.Content.Web.Mvc;
using Kentico.Content.Web.Mvc.Routing;
using Kentico.PageBuilder.Web.Mvc;

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
...

public void ConfigureServices(IServiceCollection services)
{
    // Enable desired Kentico Xperience features
    var kenticoServiceCollection = services.AddKentico(features =>
    {
        features.UsePageBuilder();
        // features.UseActivityTracking();
        // features.UseABTesting();
        // features.UseWebAnalytics();
        // features.UseEmailTracking();
        // features.UseCampaignLogger();
        // features.UseScheduler();
        features.UsePageRouting();
    });

    if (Environment.IsDevelopment())
    {
        // By default, Xperience sends cookies using SameSite=Lax. If the administration and live site applications
        // are hosted on separate domains, this ensures cookies are set with SameSite=None and Secure. The configuration
        // only applies when communicating with the Xperience administration via preview links. Both applications also need
        // to use a secure connection (HTTPS) to ensure cookies are not rejected by the client.
        kenticoServiceCollection.SetAdminCookiesSameSiteNone();

        // By default, Xperience requires a secure connection (HTTPS) if administration and live site applications
        // are hosted on separate domains. This configuration simplifies the initial setup of the development
        // or evaluation environment without the need for secure connection. The system ignores authentication
        // cookies and this information is taken from the URL.
        kenticoServiceCollection.DisableVirtualContextSecurityForLocalhost();
    }

    services.AddAuthentication();
    services.AddControllersWithViews();
}
```

--------------------------------

### Implement Filter Initialization Methods

Source: https://docs.kentico.com/x/gwNy

Methods to handle control setup, populate ordering options, and bind product departments from the database.

```C#
/// <summary>
/// Sets up the inner child controls.
/// </summary>
private void SetupControl()
{
    // Hides the filter if StopProcessing is enabled
    if (this.StopProcessing)
    {
        this.Visible = false;
    }

    // Initializes only if the current request is NOT a postback
    else if (!RequestHelper.IsPostBack())
    {
        // Loads product departments as filtering options
        InitializeDepartments();

        // Initializes the Order by drop-down list
        IntializeOrder();
    }
}

/// <summary>
/// Loads the ordering options into the Order by drop-down list.
/// </summary>
private void IntializeOrder()
{
    // Initializes the ordering options
    this.drpOrder.Items.Add(new ListItem("Price - Ascending", "priceAsc"));
    this.drpOrder.Items.Add(new ListItem("Price - Descending", "priceDesc"));
    this.drpOrder.Items.Add(new ListItem("Product name", "name"));
}

/// <summary>
/// Loads all existing product departments as filtering options into the department drop-down list.
/// </summary>
private void InitializeDepartments()
{
    // Gets all product departments from the system's database
    DataSet departments = DepartmentInfoProvider.GetDepartments("", "DepartmentDisplayName", 0, "DepartmentID, DepartmentDisplayName");

    // Checks that at least one product department exists
    if (!DataHelper.DataSourceIsEmpty(departments))
    {
        // Binds the departments to the drop-down list
        this.drpDepartment.DataSource = departments;
        this.drpDepartment.DataTextField = "DepartmentDisplayName";
        this.drpDepartment.DataValueField = "DepartmentID";

        this.drpDepartment.DataBind();

        // Adds the default '(all)' option
        this.drpDepartment.Items.Insert(0, new ListItem("(all)", "##ALL##"));
    }
}
```

--------------------------------

### GET /content/{site_context}/{culture}/all/{alias path}

Source: https://docs.kentico.com/x/3wSOAw

Retrieves all pages starting with the specified alias path.

```APIDOC
## GET /content/{site_context}/{culture}/all/{alias path}

### Description
Retrieves all pages starting with the specified alias path for the current site or a specific site.

### Method
GET

### Endpoint
/content/currentsite/{culture}/all/{alias path} or /content/site/{site name}/{culture}/all/{alias path}

### Parameters
#### Path Parameters
- **culture** (string) - Required - The culture code or constant.
- **alias path** (string) - Required - The starting alias path.
```

--------------------------------

### Create project database

Source: https://docs.kentico.com/guides/development/developer-kickstart/set-up-an-xperience-by-kentico-project

Initializes the Xperience database using the dbmanager tool. Ensure the license file path is correct and replace the SQL server placeholder.

```bash
dotnet kentico-xperience-dbmanager -- -s "<sql_server_name>" -a "kickstart" -d "Xperience.Kickstart" --license-file "..\License\license.txt"
```

--------------------------------

### GET /content/currentsite/{culture}/all/{alias path}

Source: https://docs.kentico.com/x/GYJsAw

Retrieves all pages starting with the specified alias path on the current site.

```APIDOC
## GET /content/currentsite/{culture}/all/{alias path}

### Description
Retrieves all pages starting with the specified alias path on the current site.

### Method
GET

### Endpoint
/content/currentsite/{culture}/all/{alias path}

### Parameters
#### Path Parameters
- **culture** (string) - Required - The culture code or constant (defaultculture, allcultures).
- **alias path** (string) - Required - The alias path prefix.
```

--------------------------------

### Create a new cloud-ready project

Source: https://docs.kentico.com/guides/configuration/saas/saas-walkthrough/saas-install-configure-project

Initializes a new project using the Dancing Goat sample template with the --cloud parameter to include SaaS-specific configurations.

```bash
dotnet new kentico-xperience-sample-mvc --cloud -n DancingGoat.Web
```

--------------------------------

### Vulnerable GET Action

Source: https://docs.kentico.com/x/0geRBg

An example of a Web Forms code-behind that performs a sensitive action based on a query string parameter.

```csharp
using CMS.Membership;
using CMS.Helpers;

...

if (MembershipContext.AuthenticatedUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.GlobalAdmin))
{
    int userID = QueryHelper.GetInteger("UserID", 0);
    if (userID != 0)
    {
        Response.Write("I just deleted a user with id: " + userID);
    }
}
else
{
    Response.Write("You don't have sufficient permissions to delete the user");
}
```

--------------------------------

### Retrieve Attachment URL in Controller

Source: https://docs.kentico.com/x/Qg2RBg

Use IPageAttachmentUrlRetriever to get the relative path of an attachment based on the GUID retrieved from the component properties.

```csharp
private readonly IComponentPropertiesRetriever propertiesRetriever;
private readonly ISiteService siteService;
private readonly IPageAttachmentUrlRetriever attachmentUrlRetriever;

public AttachmentSelectorExample(IComponentPropertiesRetriever propertiesRetriever,
                                 ISiteService siteService,
                                 IPageAttachmentUrlRetriever attachmentUrlRetriever)
{
    this.propertiesRetriever = propertiesRetriever;
    this.siteService = siteService;
    this.attachmentUrlRetriever = attachmentUrlRetriever;
}

public ActionResult Index()
{
    // Retrieves the GUID of the first selected attachment from the 'Attachments' property
    Guid guid = propertiesRetriever.Retrieve<CustomWidgetProperties>().Attachments.FirstOrDefault()?.FileGuid ?? Guid.Empty;
    // Retrieves the DocumentAttachment object that corresponds to the selected attachment GUID
    DocumentAttachment attachment = DocumentHelper.GetAttachment(guid, siteService.CurrentSite.SiteID);

    string url = String.Empty;
    if (attachment != null)
    {
        // Retrieves the relative URL of the selected attachment
        url = attachmentUrlRetriever.Retrieve(attachment).RelativePath;
    }

    // Custom logic...

    return View();
}
```

--------------------------------

### Create a new Xperience by Kentico project

Source: https://docs.kentico.com/guides/development/developer-kickstart/set-up-an-xperience-by-kentico-project

Initializes a new MVC project using the boilerplate template.

```bash
dotnet new kentico-xperience-mvc -n Kickstart.Web
```

--------------------------------

### Smart Folder Filter JSON Structure

Source: https://docs.kentico.com/guides/upgrade-to-xbyk/upgrade-deep-dives/migrate-widget-collection-relationships

Example JSON structure for the SmartFolderFilter property used to filter content items by class GUID.

```JSON
{"classGUID":["8a4c740c-e8d1-4452-af02-8db2b41e1930"],"tags":[],"lastPublishedAbsolute":null,"lastPublishedRelative":null,"selectedLastPublishedTimeFrame":"absolute"}
```

--------------------------------

### GET /content/site/{site name}/{culture}/all/{alias path}

Source: https://docs.kentico.com/x/GYJsAw

Retrieves all pages starting with the specified alias path on a specified site.

```APIDOC
## GET /content/site/{site name}/{culture}/all/{alias path}

### Description
Retrieves all pages starting with the specified alias path on the specified site.

### Method
GET

### Endpoint
/content/site/{site name}/{culture}/all/{alias path}

### Parameters
#### Path Parameters
- **site name** (string) - Required - The name of the site.
- **culture** (string) - Required - The culture code or constant (defaultculture, allcultures).
- **alias path** (string) - Required - The alias path prefix.
```

--------------------------------

### Example repository structure

Source: https://docs.kentico.com/guides/upgrade-to-xbyk/upgrade-deep-dives/navigate-the-upgrade-development

Recommended directory layout for managing source, target, and migration tool repositories within a single parent project.

```text
Your-Upgrade-Reporitory/
├── kx13-source/              # 1. Source KX13 instance
│   └── (existing KX13 code - largely unchanged)
├── xbyk-target/              # 2. Target XbyK instance
│   └── (new XbyK code - evolves iteratively)
└── migration-tool-custom/    # 3. Kentico Migration Tool (+ customizations)
    ├── Migration.Tool.CLI/
    │   └── appsettings.json
    ├── Migration.Tool.Extensions/
    │   ├── ClassMappings/
    │   ├── CommunityMigrations/
    │   └── WidgetMigrations/
    └── docs/
        ├── decisions.md
        └── scenarios.md
```

--------------------------------

### GET /getdoc/<document GUID>/<document name>/<culture code><extension>

Source: https://docs.kentico.com/x/AQVb

Creates a permanent link to a specific language version of a document.

```APIDOC
## GET /getdoc/<document GUID>/<document name>/<culture code><extension>

### Description
Retrieves a specific language version of a document based on the culture code.

### Parameters
#### Path Parameters
- **document GUID** (string) - Required - The globally unique identifier of the document.
- **document name** (string) - Required - A descriptive name for the URL.
- **culture code** (string) - Required - The culture code (e.g., fr-fr).
- **extension** (string) - Required - The file extension.
```

--------------------------------

### Create a project from a template

Source: https://docs.kentico.com/documentation/developers-and-admins/installation

Initializes a new project using the specified template short name and cloud configuration.

```bash
dotnet new <short_name> --cloud -n AcmeWeb
```

--------------------------------

### Create project database

Source: https://docs.kentico.com/documentation/developers-and-admins/installation

Executes the database manager to initialize the SQL server database with the specified credentials and license file.

```bash
dotnet kentico-xperience-dbmanager -- -s "<sql_server_name>" -d "<database_name>" -a "<admin_password>" --hash-string-salt "<hash_string_salt>" --license-file "<license_file_path>"
```

--------------------------------

### Define an NUnit test class for Kentico

Source: https://docs.kentico.com/x/CZr5Aw

Example of a test class inheriting from UnitTests, utilizing NUnit attributes for setup and test execution.

```csharp
using CMS.Tests;
using NUnit.Framework;

namespace UnitTestExample
{
    [TestFixture]
    public class MyTests : UnitTests
    {
        [SetUp]
        public void MyTestSetUp()
        {
            // Setup executed before each test in this test class
        }

        [Test]
        public void MyTest()
        {
            // Test execution
        }
    }
}
```

--------------------------------

### Implement RobotsOptionsSetup Class

Source: https://docs.kentico.com/guides/development/customizations-and-integrations/access-custom-channel-specific-configurations

Use IWebsiteChannelContext and IInfoProvider to populate the options class with data specific to the current channel.

```csharp
using CMS.DataEngine;
using CMS.Websites.Routing;
using Microsoft.Extensions.Options;
using TrainingGuides.ProjectSettings;

namespace TrainingGuides.Web.Features.SEO;
public class RobotsOptionsSetup : IConfigureOptions<RobotsOptions>
{
    private readonly IInfoProvider<SeoSettingsInfo> seoSettingsInfoProvider;
    private readonly IWebsiteChannelContext websiteChannelContext;
    private readonly IInfoProvider<WebChannelSettingsInfo> webChannelSettingsInfoProvider;

    public RobotsOptionsSetup(IInfoProvider<SeoSettingsInfo> seoSettingsInfoProvider, IWebsiteChannelContext websiteChannelContext, IInfoProvider<WebChannelSettingsInfo> webChannelSettingsInfoProvider)
    {
        this.seoSettingsInfoProvider = seoSettingsInfoProvider;
        this.websiteChannelContext = websiteChannelContext;
        this.webChannelSettingsInfoProvider = webChannelSettingsInfoProvider;
    }

    public void Configure(RobotsOptions options)
    {
        int currentChannelID = websiteChannelContext.WebsiteChannelID;

        var channelSettings = webChannelSettingsInfoProvider
            .Get()
            .WhereEquals(nameof(WebChannelSettingsInfo.WebChannelSettingsChannelID), currentChannelID)
            .FirstOrDefault();

        var seoSettings = seoSettingsInfoProvider.Get()
            .WhereEquals(nameof(SeoSettingsInfo.SeoSettingsWebChannelSettingID), channelSettings?.WebChannelSettingsID ?? 0)
            .FirstOrDefault();

        options.RobotsText = seoSettings?.SeoSettingsRobots ?? string.Empty;
    }
}
```

--------------------------------

### View Allowed Content Item Type Identifiers

Source: https://docs.kentico.com/modules/advanced-content/execute-conversion-and-cleanup

Example of the XML structure used in the CMS_Class table to store allowed content type GUIDs.

```XML
...
<AllowedContentItemTypeIdentifiers>["17a2abf5-c412-4cee-8b6b-e5209bcd3e8c","8afff782-a445-4e6b-a237-821fca0db4fb","da713409-64bd-4bdd-bf21-3ec8294ab1b6"]</AllowedContentItemTypeIdentifiers>
...
```

--------------------------------

### Initialize Ecommerce Services

Source: https://docs.kentico.com/x/PR2zAw

Sets up the required services and repositories for shopping cart operations, ideally via dependency injection.

```csharp
private readonly IShoppingService shoppingService;
private readonly IPricingService pricingService;
private readonly IPaymentMethodRepository paymentRepository;
private readonly ICustomerAddressRepository addressRepository;
private readonly IShippingOptionRepository shippingOptionRepository;

/// <summary>
/// Constructor.
/// You can use a dependency injection container to initialize the services and repositories.
/// </summary>
public CheckoutController()
{
    shoppingService = new ShoppingService();
    pricingService = new PricingService();
    paymentRepository = new KenticoPaymentMethodRepository();
    addressRepository = new KenticoCustomerAddressRepository();
    shippingOptionRepository = new KenticoShippingOptionRepository();
}
```

--------------------------------

### Kentico Improvement Program JSON Data Payloads

Source: https://docs.kentico.com/x/zI2-BQ

These JSON objects represent telemetry data sent from various data sources. The Identity field uses a randomly generated GUID to group related data points without tracking the origin.

```json
{
    "DateTime": "2018-10-03T11:06:48.2368242Z",
    "Identity": "ba11814e-f55a-4681-949b-d070ff786f13",
    "DataSourceName": "CMS.Staging",
    "ProductVersion": "12.0",
    "DataCollectionTime": 0,
    "Items": [
      {
        "Key": "StagingEnabled",
        "Value": true,
        "Type": "Boolean"
      }
    ]
},

{
    "DateTime": "2018-10-03T11:06:48.2368242Z",
    "Identity": "ba11814e-f55a-4681-949b-d070ff786f13",
    "DataSourceName": "CMS.LicenseProvider",
    "ProductVersion": "12.0",
    "DataCollectionTime": 0,
    "Items": [
      {
        "Key": "HighestLicenseEdition",
        "Value": "EnterpriseMarketingSolution",
        "Type": "String"
      }
    ]
},

{
    "DateTime": "2018-10-03T11:06:48.2368242Z",
    "Identity": "ba11814e-f55a-4681-949b-d070ff786f13",
    "DataSourceName": "CMS.ObjectCount",
    "ProductVersion": "12.0",
    "DataCollectionTime": 9,
    "Items": [
      {
        "Key": "cms_user",
        "Value": 9,
        "Type": "Long"
      },
      {
        "Key": "cms_site",
        "Value": 5,
        "Type": "Long"
      },
      {
        "Key": "cms_webpart",
        "Value": 371,
        "Type": "Long"
      },
      {
        "Key": "ecommerce_customer",
        "Value": 0,
        "Type": "Long"
      },
      {
        "Key": "ecommerce_order",
        "Value": 0,
        "Type": "Long"
      },
      {
        "Key": "cms_document",
        "Value": 853,
        "Type": "Long"
      },
      {
        "Key": "cms_deviceprofile",
        "Value": 3,
        "Type": "Long"
      },
      {
        "Key": "reporting_report",
        "Value": 396,
        "Type": "Long"
      },
      {
        "Key": "chat_room",
        "Value": 2,
        "Type": "Long"
      }
    ]
}
```

--------------------------------

### Consume Custom API via HTTP

Source: https://docs.kentico.com/x/BAKIAw

Example of making a GET request to the registered custom API route using AngularJS $http service.

```javascript
$http.get("http://myserver/customapi/MyWebAPI", { id: 1})
    .success(function (data) {
        alert(data);
    })
    .error(function(error) {
        // handle the error
    });
```

--------------------------------

### Get Media File URL for Feed

Source: https://docs.kentico.com/x/3iF6Aw

Generates a URL for a media file using its GUID and file name, including the feed query string parameter.

```ASP.NET
<%# GetMediaFileUrlForFeed(Eval(“FileGUID”), Eval(“FileName”)) %>
```

--------------------------------

### Registering and initializing a custom module

Source: https://docs.kentico.com/x/CYRsAw

Demonstrates how to define a module class, register it with an assembly attribute, and hook into system events during the OnInit lifecycle method.

```csharp
using CMS;
using CMS.DataEngine;
using CMS.EventLog;

[assembly: RegisterModule(typeof(CompanyOverviewModule))]

public class CompanyOverviewModule : Module
{
    // Module class constructor
    public CompanyOverviewModule() : base("CompanyOverview")
    {
    }

    /// <summary>
    /// Initializes the module. Called when the application starts.
    /// </summary>
    protected override void OnInit()
    {
        base.OnInit();

        // Assigns a handler to the Insert.After event for OfficeInfo objects
        CompanyOverview.OfficeInfo.TYPEINFO.Events.Insert.After += Office_InsertAfter;
    }

    private void Office_InsertAfter(object sender, ObjectEventArgs e)
    {
        // Logs an information entry into the system's event log whenever a new office is created
        string message = "New office '" + e.Object.GetStringValue("OfficeDisplayName", "") + "' was created in the custom Company overview module.";
        EventLogProvider.LogInformation("Company overview module", "NEW OFFICE", message);
    }
}
```

--------------------------------

### Create a new Xperience by Kentico MVC project

Source: https://docs.kentico.com/guides/development/get-started/install-a-specific-version-of-xperience-by-kentico

Initializes a new project structure in the current directory using the Kentico MVC template.

```bash
dotnet new kentico-xperience-mvc -n TrainingGuides.Web
```

--------------------------------

### Asynchronous document processing implementation example

Source: https://docs.kentico.com/x/IYUkAQ

Example implementation of the ProcessInternalTaskAsync method for documents.

```csharp
public override IntegrationProcessResultEnum ProcessInternalTaskAsync(TreeNode node, TranslationHelper translations, TaskTypeEnum taskType, TaskDataTypeEnum dataType, string siteName, out string errorMessage)
{

    // Convert the TreeNode to an external document object

    // Optional: Translate foreign key values

    // Send the data to the target application

    // Method result for successful processing
    errorMessage = null;
    return IntegrationProcessResultEnum.OK;
}
```

--------------------------------

### Install Xperience by Kentico MVC project template

Source: https://docs.kentico.com/guides/upgrade-to-xbyk/upgrade-walkthrough/setup-your-environment

Use the .NET CLI to create a new Xperience by Kentico MVC project named DancingGoat.Web.

```CMD
dotnet new kentico-xperience-mvc -n DancingGoat.Web
```

--------------------------------

### GetSharePointImageUrl Usage Examples

Source: https://docs.kentico.com/x/AQWOAw

Examples of calling GetSharePointImageUrl in transformations with varying parameter configurations.

```aspnet
<%# GetSharePointImageUrl() %>
```

```aspnet
<%# GetSharePointImageUrl("NameOfColumnContainingPathToFile") %>
```

```aspnet
<%# GetSharePointImageUrl("NameOfColumnContainingPathToFile", null, 200) %>
```

```aspnet
<%# GetSharePointImageUrl("NameOfColumnContainingPathToFile", null, null, 300) %>
```

--------------------------------

### Implement ProductViewModel

Source: https://docs.kentico.com/x/lZHlAw

Create a view model to map Kentico SKUTreeNode and ProductPrice data to a displayable format for the product detail view.

```csharp
public readonly ProductPrice PriceDetail;
public readonly string Name;
public readonly string Description;
public readonly string ShortDescription;
public readonly int SKUID;
public readonly string ImagePath;
public readonly int ProductPageID;
public readonly string ProductPageAlias;
public readonly bool IsInStock;

/// <summary>
/// Creates a new product model.
/// </summary>
/// <param name="productPage">Product's page.</param>
/// <param name="priceDetail">Price of the product.</param>
public ProductViewModel(SKUTreeNode productPage, ProductPrice priceDetail)
{
    // Fills the page information
    Name = productPage.DocumentName;
    Description = productPage.DocumentSKUDescription;
    ShortDescription = productPage.DocumentSKUShortDescription;
    ProductPageID = productPage.NodeID;
    ProductPageAlias = productPage.NodeAlias;

    // Fills the SKU information
    SKUInfo sku = productPage.SKU;
    SKUID = sku.SKUID;
    ImagePath = sku.SKUImagePath;
    IsInStock = sku.SKUTrackInventory == TrackInventoryTypeEnum.Disabled ||
                sku.SKUAvailableItems > 0;

    PriceDetail = priceDetail;
}
```

--------------------------------

### GetSharePointFileUrl Usage Examples

Source: https://docs.kentico.com/x/AQWOAw

Examples of calling GetSharePointFileUrl in transformations with varying parameter configurations.

```aspnet
<%# GetSharePointFileUrl() %>
```

```aspnet
<%# GetSharePointFileUrl("NameOfColumnContainingPathToFile") %>
```

```aspnet
<%# GetSharePointFileUrl("NameOfColumnContainingPathToFile", 5, 1024) %>
```

--------------------------------

### Configure Headless API via Program.cs

Source: https://docs.kentico.com/documentation/developers-and-admins/configuration/headless-channel-management

Example of mapping configuration using the HeadlessOptions class in the project startup file.

```csharp
using Kentico.Xperience.Headless;

builder.Services.AddKentico(...);

builder.Services.Configure<HeadlessOptions>(options =>
{
    // Enables introspection in the Development environment
    options.AllowIntrospection = builder.Environment.IsDevelopment();
    // Changes the endpoint slug to 'api'
    options.GraphQlEndpointPath = "/api";
    // Changes the maximum expiration of a cache entry to 6 hours
    options.Caching.AbsoluteExpiration = TimeSpan.FromHours(6);
});
```

--------------------------------

### List installed .NET templates

Source: https://docs.kentico.com/guides/development/get-started/install-a-specific-version-of-xperience-by-kentico

Displays all currently installed NuGet template packages on the machine.

```bash
dotnet new uninstall
```

--------------------------------

### Install Azure CLI

Source: https://docs.kentico.com/guides/development/deployment/deploy-to-private-cloud

Use the Windows Package Manager to install the Azure CLI tool.

```bash
winget install -e --id Microsoft.AzureCLI
```

--------------------------------

### Publish the application with .NET CLI

Source: https://docs.kentico.com/guides/development/deployment/deploy-to-private-cloud

Use this command to build the project in Release configuration for deployment.

```bash
dotnet publish --configuration Release
```

--------------------------------

### Macro Parameter Examples

Source: https://docs.kentico.com/x/a4S-BQ

Examples of various parameters used to modify macro resolution.

```Kentico Macro
{% CurrentUser.UserDateOfBirth|(default)N\|A %}
```

```Kentico Macro
{% ArticleSummary|(encode)true %}
```

```Kentico Macro
{% ArticleText|`(encode)true`|(recursive)true %}
```

```Kentico Macro
{% DocumentPublishFrom|(culture)en-us %}
```

```Kentico Macro
{% Contains(“term”, ArticleText)|(casesensitive)true %}
```

```XML
<add key="CMSMacrosCaseSensitiveComparison" value="true">
```

```Kentico Macro
{% GetDocumentUrl()|(timeout)2000 %}
```

```Kentico Macro
{% QueryString.Param|(handlesqlinjection)true %}
```

```Kentico Macro
{% Documents[“/News”].Children.WithAllData|(debug)true %}
```

--------------------------------

### Identity provider URL examples

Source: https://docs.kentico.com/x/CiF6Aw

Examples of WS-Federation passive endpoint URLs for identity providers.

```text
- *https://adfs.net/adfs/ls*- *https://accesscontrolnamespace.accesscontrol.windows.net/v2/wsfederation*
```

--------------------------------

### Build the project

Source: https://docs.kentico.com/documentation/developers-and-admins/deployment/deploy-to-the-saas-environment

Command to build the project from the root directory.

```CMD
dotnet build
```

--------------------------------

### Parse Metafile GUID from Path

Source: https://docs.kentico.com/guides/upgrade-to-xbyk/upgrade-deep-dives/migrate-page-sku-data

Extracts the GUID from a legacy KX13 metafile URL format.

```csharp
// Parses a metafile GUID from a KX13 metafile URL path (e.g. ~/getmetafile/{guid}/filename).
private static Guid? GetMetaFileGuidFromPath(string kx13SkuMetaFilePath)
{
    // In Dancing Goat, SKUImagePath uses meta file URLs with the format
    // ~/getmetafile/01a4223b-fc43-4635-8658-878a7539b8c5/cup-personalized-small
    var urlParts = kx13SkuMetaFilePath.Trim().Split('/');
    string guidSegment = urlParts[^2];

    if (Guid.TryParse(guidSegment, out Guid metaFileGuid))
    {
        return metaFileGuid;
    }

    return null;
}
```

--------------------------------

### Configure Startup Options via Configuration Files

Source: https://docs.kentico.com/documentation/developers-and-admins/development/website-development-basics/configure-new-projects

Externalize options like SmtpOptions into configuration files to allow runtime adjustments without code changes.

```C#
// Separates the SmtpOptions to a configuration file section
builder.Services.AddXperienceSmtp();
builder.Services.Configure<SmtpOptions>(builder.Configuration.GetSection("SmtpOptions"));
```

```JSON
{
  "SmtpOptions": {
    "Server" : {
      "Host":"smtp.server.com",
      "Port": 587
    }
  }
  ...
}
```

--------------------------------

### Initialize product controller services

Source: https://docs.kentico.com/x/Z4a-BQ

Constructor for a product controller that resolves shopping and price calculation services.

```csharp
/// <summary>
/// Constructor for the ProductController class.
/// </summary>
public ProductController()
{
    // Initializes instances of services required to manage product price calculation and the shopping cart
    // For real-world projects, we recommend using a dependency injection container to initialize service instances
    shoppingService = Service.Resolve<IShoppingService>();
    calculatorFactory = Service.Resolve<ICatalogPriceCalculatorFactory>();
}
```

--------------------------------

### Example XSS Attack Payload

Source: https://docs.kentico.com/x/3gobB

A basic example of an XSS payload injected via a URL parameter.

```text
blahblah.tld?input=<script>alert('I am going to steal your money');</script>
```

--------------------------------

### Analyze Kentico 8 projects

Source: https://docs.kentico.com/x/8oNsAw

Run the upgrade tool from the command line by providing the path to the project's solution file.

```bash
CodeUpgrade.exe C:\inetpub\wwwroot\Kentico8\WebSite.sln
```

--------------------------------

### Retrieve Articles by GUID

Source: https://docs.kentico.com/guides/development/kenticopilot/implement-widgets-kenticopilot

Retrieves a specific article page by its GUID using the content retriever with caching.

```csharp
private async Task<ArticlePage> GetArticleByGuid(Guid contentItemGuid, CancellationToken cancellationToken)
        {
            var articles = await contentRetriever.RetrievePages<ArticlePage>(
                new RetrievePagesParameters
                {
                    IncludeUrlPath = true,
                    LinkedItemsMaxLevel = 1
                },
                query => query
                    .Where(where => where.WhereEquals(nameof(IContentQueryDataContainer.ContentItemGUID), contentItemGuid))
                    .Columns(
                        nameof(ArticlePage.ArticleTitle),
                        nameof(ArticlePage.ArticlePageTeaser),
                        nameof(ArticlePage.ArticlePagePublishDate),
                        nameof(ArticlePage.ArticlePageSummary))
                    .UrlPathColumns(),
                new RetrievalCacheSettings($"WhereEquals_{nameof(IContentQueryDataContainer.ContentItemGUID)}_{contentItemGuid}"),
                cancellationToken
            );

            return articles.FirstOrDefault();
        }
```

--------------------------------

### Display AD Import Utility Help

Source: https://docs.kentico.com/x/-YBsAw

View command-line usage instructions and available parameters for the utility.

```bash
ADImport -h
```
Tokens:
Raw