How to Migrate Content from Kentico CMS Portal Engine to Xperience by Kentico

{
"DocumentID": {% DocumentID %}, 
"NodeAlias": "{% NodeAlias %}",
"Title": "{% Replace(RegexReplace(Title, @"\t|\n|\r", ""), "\"", "\\\"") %}",
"Date": "{% Date %}",
"Text": "{% Replace(RegexReplace(Text, @"\t|\n|\r", ""), "\"", "\\\"") %}",
}{% DataItemCount - DataItemIndex == 1 ? "" : ", " %}

public class NewsItemDto
{
    public int DocumentID { get; set; }
    public string NodeAlias { get; set; }
    public string Title { get; set; }
    public string Date { get; set; }
    public string Text { get; set; }
}

using System.Text.Json;
using CMS.ContentEngine;
using CMS.Helpers;
using CMS.Membership;
using CMS.Websites;
using CMS.Websites.Routing;
using Kentico.Content.Web.Mvc.Routing;
using Microsoft.AspNetCore.Mvc;
using Project.Helpers;

namespace Project.Controllers;

public class NewsMigrationController : Controller
{
    private readonly IWebPageManager webPageManager;
    private readonly IContentQueryExecutor contentQueryExecutor;
    private readonly MigrationHelper migrationHelper;
    private readonly IContentItemManager contentItemManager;
    private readonly IPreferredLanguageRetriever currentLanguageRetriever;

    public NewsMigrationController(
        IContentQueryExecutor contentQueryExecutor,
        IWebPageManagerFactory webPageManagerFactory,
        IUserInfoProvider userInfoProvider,
        IWebsiteChannelContext websiteChannelContext,
        MigrationHelper migrationHelper,
        IContentItemManagerFactory contentItemManagerFactory,
        IPreferredLanguageRetriever currentLanguageRetriever
    )
    {
        UserInfo user = userInfoProvider.Get("Administrator");
        webPageManager = webPageManagerFactory.Create(websiteChannelContext.WebsiteChannelID, user.UserID);
        this.contentQueryExecutor = contentQueryExecutor;
        this.migrationHelper = migrationHelper;
        contentItemManager = contentItemManagerFactory.Create(user.UserID);
        this.currentLanguageRetriever = currentLanguageRetriever;
    }

    /// <summary>
    /// Handles the HTTP POST request for news migration.
    /// </summary>
    /// <returns>The result of the migration.</returns>
    [HttpPost("migration/news")]
    public async Task<IActionResult> Index()
    {
        // Request the URL where our JSON data resides and deserialize it into a list of News, based on a Data Transfer Object model
        var response = await migrationHelper.GetMigrationData("https://www.project.com/Export/News-export");

        if (!response.IsSuccessStatusCode)
        {
            return StatusCode((int)response.StatusCode);
        }

        var responseStream = await response.Content.ReadAsStreamAsync();
        var data = await JsonSerializer.DeserializeAsync<List<NewsItemDto>>(responseStream);

        int newsPageId = 324;

        // Iterate through the list and for each item
        foreach (var item in data)
        {
            // Generate unique code name identifiers for the page and reusable content item
            string pageName = $"MigratedNewsItem{item.DocumentID}";
            string contentItemName = $"MigratedContentItemNewsItem{item.DocumentID}";

            // If items with such names already exist (when we repeat the migration), delete them
            await migrationHelper.DeletePageIfExists(NewsItemPage.CONTENT_TYPE_NAME, pageName);
            await migrationHelper.DeleteContentItemIfExists(NewsItemReusableContent.CONTENT_TYPE_NAME, contentItemName);

            // Parse incoming data into appropriate data types.
            DateTime date;
            DateTime.TryParse(item.Date, out date);

            string pageDisplayName = item.Title.Truncate(100);
            var languageName = currentLanguageRetriever.Get();

            // Create a reusable content item
            CreateContentItemParameters createParams = new CreateContentItemParameters(
                NewsItemReusableContent.CONTENT_TYPE_NAME,
                contentItemName,
                pageDisplayName,
                languageName
            );

            var contentItemData = new ContentItemData(new Dictionary<string, object>{
                { "Title", item.Title },
                { "Date", date },
                { "Text", item.Text }
            });

            var id = await contentItemManager.Create(createParams, contentItemData);
            await contentItemManager.TryPublish(id, languageName);
            var builder = new ContentItemQueryBuilder();
            builder.ForContentType(NewsItemReusableContent.CONTENT_TYPE_NAME, subqueryConfiguration =>
            {
                subqueryConfiguration
                .TopN(1)
                .Where(where => where.WhereEquals("ContentItemID", id));
            });

            // Obtain a reference to the reusable content type
            NewsItemReusableContent contentItem =
                (await contentQueryExecutor.GetMappedResult<NewsItemReusableContent>(builder)).FirstOrDefault();

            IEnumerable<ContentItemReference> itemList =
            [
                new ContentItemReference
                {
                    Identifier = contentItem.SystemFields.ContentItemGUID
                },
            ];

            // Create a page using the reference, attach the page to the parent News page by its Page ID, and assign it a URL slug.
            var itemData = new ContentItemData(new Dictionary<string, object>{
                {"Item", itemList }
            });

            var contentItemParameters = new ContentItemParameters(NewsItemPage.CONTENT_TYPE_NAME, itemData);
            var createPageParameters = new CreateWebPageParameters(pageName, pageDisplayName, languageName, contentItemParameters)
            {
                ParentWebPageItemID = newsPageId,
                UrlSlug = item.NodeAlias
            };

            int webPageItemId = await webPageManager.Create(createPageParameters);
            await webPageManager.TryPublish(webPageItemId, languageName);
        }
        return Ok();
    }
}

using CMS.ContentEngine;
using CMS.MediaLibrary;
using CMS.Membership;
using CMS.Websites;
using CMS.Websites.Routing;
using Kentico.Content.Web.Mvc;
using CMS.DataEngine;
using Kentico.Content.Web.Mvc.Routing;

namespace Project.Helpers;

/// <summary>
/// Represents a helper class for migration operations.
/// </summary>
public class MigrationHelper
{
    private readonly IContentQueryExecutor contentQueryExecutor;
    private readonly IWebPageManager webPageManager;
    private readonly IContentItemManager contentItemManager;
    private readonly IHttpClientFactory clientFactory;
    private readonly IPreferredLanguageRetriever currentLanguageRetriever;
    private readonly IWebsiteChannelContext websiteChannelContext;

    public MigrationHelper(
        IContentQueryExecutor contentQueryExecutor,
        IWebPageManagerFactory webPageManagerFactory,
        IWebsiteChannelContext websiteChannelContext,
        IUserInfoProvider userInfoProvider,
        IContentItemManagerFactory contentItemManagerFactory,
        IHttpClientFactory clientFactory,
        IPreferredLanguageRetriever currentLanguageRetriever
    )
    {
        UserInfo user = userInfoProvider.Get("Administrator");
        webPageManager = webPageManagerFactory.Create(websiteChannelContext.WebsiteChannelID, user.UserID);
        contentItemManager = contentItemManagerFactory.Create(user.UserID);
        this.contentQueryExecutor = contentQueryExecutor;
        this.clientFactory = clientFactory;
        this.currentLanguageRetriever = currentLanguageRetriever;
        this.websiteChannelContext = websiteChannelContext;
    }

    /// <summary>
    /// Gets the migration data from the specified endpoint.
    /// </summary>
    /// <param name="endpoint">The endpoint URL.</param>
    /// <returns>The HTTP response message.</returns>
    public async Task<HttpResponseMessage> GetMigrationData(string endpoint)
    {
        var request = new HttpRequestMessage(HttpMethod.Get, endpoint);
        var client = clientFactory.CreateClient();
        var response = await client.SendAsync(request);
        return response;
    }

    /// <summary>
    /// Deletes a page if it exists.
    /// </summary>
    /// <param name="contentType">The content type of the page.</param>
    /// <param name="codename">The codename of the page.</param>
    public async Task DeletePageIfExists(string contentType, string codename)
    {
        var languageName = currentLanguageRetriever.Get();
        var builder = new ContentItemQueryBuilder()
            .ForContentType(contentType, config =>
            {
                config
                    .TopN(1)
                    .ForWebsite(websiteChannelContext.WebsiteChannelName)
                    .Where(where => where.WhereEquals(nameof(IWebPageContentQueryDataContainer.WebPageItemName), codename));
            })
            .InLanguage(languageName);

        var pageId = await contentQueryExecutor
            .GetWebPageResult(builder: builder, resultSelector: rowData =>
            {
                var pageRowId = rowData.WebPageItemID;
                return pageRowId;
            });

        if (pageId.Any())
        {
            await webPageManager.Delete(pageId.First(), languageName);
        }
    }

    /// <summary>
    /// Deletes a content item if it exists.
    /// </summary>
    /// <param name="contentType">The content type of the item.</param>
    /// <param name="codename">The codename of the item.</param>
    public async Task DeleteContentItemIfExists(string contentType, string codename)
    {
        var languageName = currentLanguageRetriever.Get();
        var builder = new ContentItemQueryBuilder()
            .ForContentType(contentType, config =>
            {
                config
                    .TopN(1)
                    .Where(where => where.WhereEquals(nameof(IContentItemFieldsSource.SystemFields.ContentItemName), codename));
            })
            .InLanguage(languageName);

        var contentItemId = await contentQueryExecutor
            .GetResult(builder: builder, resultSelector: rowData =>
            {
                var contentItemId = rowData.ContentItemID;
                return contentItemId;
            });

        if (contentItemId.Any())
        {
            await contentItemManager.Delete(contentItemId.First(), languageName);
        }
    }
}