Content Migration to Optimizely

Content migration to Optimizely is an essential process to ensure your existing data, assets, and user content are transitioned effectively. While automation is the backbone of this process, there might still be a need for manual cleanup at the end to ensure all content is accurate and ready for use.

This blog will guide you through best practices for content migration, including the order of migration, Optimizely’s Content Repository APIs, and handling internal links effectively.

Source Code

Why Automate Content Migration?

Automating migration ensures:

• Consistency: Uniformity in data structure and formatting.
• Efficiency: Large volumes of content can be transferred quickly.
• Reduced Downtime: Automating links and relationships reduces delays.

Migration Workflow

1. Audit Existing Content

   • Identify all content types, assets, and relationships in the source system.

2. Migrate Assets First

   • Assets (e.g., images, documents) must be migrated first to ensure they can be referenced correctly in content.

3. Map Content Types

   • Create a mapping between the source content and Optimizely content types.

4. Write Migration Scripts

   • Use Optimizely APIs to programmatically migrate data and assets.

5. Handle Links

   • Ensure that internal links are created and referenced correctly during migration.

6. Test Migration

   • Validate the migrated data in a staging environment.

7. Perform Manual Cleanup

   • Address edge cases, data inconsistencies, and any unmapped fields manually to ensure content accuracy.

8. Go Live

   • Perform the final migration during off-peak hours to minimize disruptions.

1. Migrating Assets First

Assets, such as images and documents, should be migrated first since they are often referenced in content.

Code Example: Upload an Image

private async Task<ContentReference> UploadImageFromUrlAsync(string imageUrl)
{
    using HttpClient client = new HttpClient();
    byte[] imageBytes = await client.GetByteArrayAsync(imageUrl);

    var mediaFolder = _contentRepository.GetDefault<ImageFile>(SiteDefinition.Current.GlobalAssetsRoot);
    mediaFolder.Name = Path.GetFileName(imageUrl);

    var blob = _blobFactory.CreateBlob(mediaFolder.BinaryDataContainer, ".jpg");
    using (var stream = new MemoryStream(imageBytes))
    {
        blob.Write(stream);
    }

    mediaFolder.BinaryData = blob;
    return _contentRepository.Save(mediaFolder, SaveAction.Publish, AccessLevel.NoAccess);
}

By uploading assets first, you ensure that references in content migration scripts (e.g., <img> tags) work seamlessly.

2. Programmatic Content Migration

Use Optimizely’s Content Repository APIs to create and publish content programmatically.

Code Example: Migrate Content

public void ImportContent(IEnumerable<ContentModel> sourceContent)
{
    var contentRepository = ServiceLocator.Current.GetInstance<IContentRepository>();
    foreach (var content in sourceContent)
    {
        var newPage = contentRepository.GetDefault<StandardPage>(ContentReference.StartPage);
        newPage.PageTitle = content.Title;
        newPage.MainBody = new XhtmlString(content.Body);
        newPage.Image = ImportAsset(content.ImageUrl); // Reference migrated assets

        contentRepository.Save(newPage, SaveAction.Publish);
    }
}

private ContentReference ImportAsset(string imageUrl)
{
    // Asset migration logic here
    return UploadImage(imageUrl, "ImageName");
}

3. Handling Internal and External Links

To avoid “Page Not Found” errors, ensure internal links are created in Optimizely before linking them in content.

Code Example: Update and Validate Links

public XhtmlString UpdateLinks(XhtmlString content)
{
    var document = new HtmlDocument();
    document.LoadHtml(content.ToString());

    foreach (var link in document.DocumentNode.SelectNodes("//a[@href]"))
    {
        var oldUrl = link.Attributes["href"].Value;
        var newUrl = MapToNewUrl(oldUrl);

        // Check if the new URL is an internal link
        if (IsInternalLink(newUrl))
        {
            var contentReference = GetContentReference(newUrl);
            if (contentReference != null)
            {
                link.Attributes["href"].Value = ContentUrlResolver.Instance.GetUrl(contentReference);
            }
            else
            {
                Console.WriteLine($"Internal link not found for {newUrl}");
            }
        }
        else
        {
            link.Attributes["href"].Value = newUrl;
        }
    }

    return new XhtmlString(document.DocumentNode.OuterHtml);
}

private bool IsInternalLink(string url)
{
    return url.StartsWith("/"); // Basic check for relative URLs
}

private ContentReference GetContentReference(string url)
{
    var contentRepository = ServiceLocator.Current.GetInstance<IContentRepository>();
    return contentRepository.GetReferencesToContentByUrl(url).FirstOrDefault();
}

4. Manual Cleanup

Even with automation, some scenarios require manual attention:

• Content Formatting: Adjust text or layouts that didn’t migrate properly.
• Unmapped Fields: Fill in data for custom fields that were overlooked in the scripts.
• Link Validation: Check broken links and missing references.

Pro Tip: Use Optimizely’s Content Manager to visually review and edit content.

5. Test Migration

Validate the structure, links, and content in a staging environment. Create a checklist to ensure:

• All pages load correctly.
• Links and images work.
• Content formatting matches the original.

Content Repository API Overview

Here are commonly used methods from Optimizely’s IContentRepository:

Get Content

var content = contentRepository.Get<StandardPage>(ContentReference.StartPage);

Create New Content

var newPage = contentRepository.GetDefault<StandardPage>(ContentReference.StartPage);
newPage.PageTitle = "New Page";
contentRepository.Save(newPage, SaveAction.Publish);

Update Content

var page = contentRepository.Get<StandardPage>(contentReference);
page.PageTitle = "Updated Title";
contentRepository.Save(page, SaveAction.Publish);

Delete Content

contentRepository.Delete(contentReference, true);

6. Going Live

Plan your final migration during non-peak hours. Inform stakeholders about the downtime, if any, and perform a final test after the live migration.

Conclusion

Content migration to Optimizely involves a mix of automation and manual processes. By following a structured workflow, starting with assets, ensuring proper link updates, and performing manual cleanup, you can deliver a smooth and error-free migration. Optimizely’s Content Repository APIs make it easier to script these processes efficiently.

If you have any specific questions or need more examples, feel free to ask!