Best way to change nested content doctype content to a new element type during migration

[ProNotion]

I have an issue in a legacy site I am migrating whereby we have a doctype that is used within a nested content property editor that is also used for content nodes. This is causing issues in the migrated v12 site because content outside of the nested content is now using a doctype that has been converted to an element type (hopefully that makes sense?) but it should be IPublishedContent.

As such, I am creating a duplicate of the original doctype and making that an element type and changing the original doctype back to normal. I now need to migrate any nodes within nested content using the original doctype so that it now uses the new element type.

Explaining it sounds more complicated than the issue is but I hope it makes sense.

[ProNotion]

Here is my migration plan

 public class SlideShowSlideMigrationPlan : ISyncMigrationPlan
{
    private readonly SyncMigrationHandlerCollection _migrationHandlers;

    public SlideShowSlideMigrationPlan(SyncMigrationHandlerCollection migrationHandlers)
    {
        _migrationHandlers = migrationHandlers;
    }
    
    public int Order => 100;
    public string Name => "Convert NestedContent SlideShowSlide to SlideshowContentBlockSlide";
    public string Icon => "icon-brick color-green";
    public string Description => "Converts any slides within NestedContent property editors to SlideshowContentBlockSlide.";
    public MigrationOptions Options => new MigrationOptions
    {
        SourceVersion = 8,
        PreferredMigrators = new Dictionary<string, string>()
        {
            { Constants.PropertyEditors.Aliases.NestedContent, nameof(NestedContentSlideShowSlideMigrator) }
        },
    };   
}

...and here is my migrator

[SyncMigrator(Constants.PropertyEditors.Aliases.NestedContent)]
[SyncMigratorVersion(8)]
public class NestedContentSlideShowSlideMigrator : SyncPropertyMigratorBase
{
private readonly ILogger<NestedContentSlideShowSlideMigrator> _logger;
private const string oldDoctypeAlias = "slideshowslide";
private const string newDoctypeAlias = "slideshowcontentblockslide";

public override string GetEditorAlias(SyncMigrationDataTypeProperty dataTypeProperty, SyncMigrationContext context)
	=> Constants.PropertyEditors.Aliases.NestedContent;

public NestedContentSlideShowSlideMigrator(ILogger<NestedContentSlideShowSlideMigrator> logger)
{
	_logger = logger;
}

public override string? GetContentValue(SyncMigrationContentProperty contentProperty, SyncMigrationContext context)
{
	if (string.IsNullOrWhiteSpace(contentProperty.Value)) return string.Empty;
	var rowValues = JsonConvert.DeserializeObject<IList<NestedContentRowValue>>(contentProperty.Value);

	if (rowValues == null) return string.Empty;
	
	if(rowValues.All(x => x.ContentTypeAlias.ToLowerInvariant() == oldDoctypeAlias))
	{
		_logger.LogDebug("NestedContentSlideShowSlideMigrator: No rows containing {ContentType} nodes", oldDoctypeAlias);
		return contentProperty.Value;
	}

	var blockValue = new BlockValue();
	var contentData = new List<BlockItemData>();
	var blockListLayout = new List<BlockListLayoutItem>();

	foreach (var row in rowValues)
	{
		if(row.ContentTypeAlias.ToLowerInvariant() != oldDoctypeAlias)
		{
			_logger.LogDebug("NestedContentSlideShowSlideMigrator: {ContentType} {key} - Not a slideshowslide", row.ContentTypeAlias, row.Id);
			continue;
		}
		
		if (row.Id == Guid.Empty)
			row.Id = $"{contentProperty.EditorAlias}{contentProperty.ContentTypeAlias}{row.ContentTypeAlias}{row.Name}".ToGuid();

		var contentTypeKey = context.ContentTypes.GetKeyByAlias(newDoctypeAlias);
		var blockUdi = Udi.Create(Constants.UdiEntityType.Element, row.Id);

		var block = new BlockItemData
		{
			ContentTypeKey = contentTypeKey,
			Udi = blockUdi
		};

		blockListLayout.Add(new BlockListLayoutItem
		{
			ContentUdi = blockUdi,
		});

		foreach (var property in row.RawPropertyValues)
		{
			_logger.LogDebug("NestedContentSlideShowSlideMigrator: {ContentType} {key}", row.ContentTypeAlias, property.Key);

			var migrator = context.Migrators.TryGetMigrator(Constants.PropertyEditors.Aliases.NestedContent);
			if (migrator != null)
			{
				_logger.LogDebug("NestedContentSlideShowSlideMigrator: Found Migrator: {migrator}", migrator.GetType().Name);
				
				block.RawPropertyValues[property.Key] = migrator.GetContentValue(
					new SyncMigrationContentProperty(
						newDoctypeAlias,
						property.Key,
						newDoctypeAlias, property.Value?.ToString() ?? string.Empty), context);
			}
			else
			{
				_logger.LogDebug("NestedContentSlideShowSlideMigrator: No Migrator found");
				block.RawPropertyValues[property.Key] = property.Value;
			}
		}

		contentData.Add(block);
	}

	blockValue.ContentData = contentData;
	blockValue.Layout = new Dictionary<string, JToken>()
	{
		{ "Umbraco.BlockList", JToken.FromObject(blockListLayout) }
	};

	return JsonConvert.SerializeObject(blockValue, Formatting.Indented);
}

In the migrator I have a breakpoint at the start of the GetContentValue method which never gets called and I am not sure why?

[KevinJump]

Hi,

Just ran a check of this for you locally, and for me the breakpoint does get hit 🤔

so here is what i have just done.

1 . I copied your NestedContentSlideShowSlideMigrator from above,

• I have made NestedContentRowValue public in side the migrations code so this can be done outside of the core project. (not sure if you have just copied this for ease)

2. I created a new migration plan (think you pasted the wrong bit above). but my migration plan is super simple

using uSync.Migrations.Configuration.Models;

namespace MyMigrations.CustomMigration;
internal class NestedSlideShowPlan : ISyncMigrationPlan
{
    public int Order => 100;

    public string Name => "Slideshow Migration plan";

    public string Icon => "icon-show";

    public string Description => "Run the slideshow nested content merge";

    public MigrationOptions Options => new MigrationOptions
    {
        SourceVersion = 8,
        PreferredMigrators = new Dictionary<string, string>()
        {
            { Umbraco.Cms.Core.Constants.PropertyEditors.Aliases.NestedContent, nameof(NestedContentSlideShowSlideMigrator) }
        },
    };
}

Ran a conversion of the site (which has some nested content in it). and the breakpoint gets hit

migration looks like this :

only thing is i am running this against the very latest code branch currently just merging the vorto-context-lookup branch - but none of the basic look up stuff should have changed since the last version 🤷

[ProNotion]

Prior to making the changes you advised above I did do a full export of content and media from uSync to ensure there were Content and Media in the v9 directory although I understood from our previous conversation on Discord that it shouldn't be necessary for this example and because I was coming from v7.

That said, I made the changes you detailed above and I am running it again now in the hope that I see the same success that you did 🤞

Thanks for your input on this - much appreciated! I will give feedback on my results soon.

[KevinJump]

yes that depends on where the source is - so in my example i was converting the current site. if you wanted to convert directly from the v7 files you can do it, but then it becomes a v7 migration not a v8(+) one.

another thing though - if you are coming from Umbraco seven you might want to add. support for "Our.Umbraco.NestedContent"

e.g have the following attributes.

[SyncMigrator(UmbConstants.PropertyEditors.Aliases.NestedContent)]
[SyncMigrator("Our.Umbraco.NestedContent")]
[SyncMigratorVersion(7,8)]

depending on what version of v7 you have the alias might be this old one.

[ProNotion]

I could be getting confused somewhere along the line but I ran the v7 migration plan first so don't consider this stage to be a v7 migration now? The migrator also detects a v8 version for the new plan.

I am executing both plans in a v10 site because of issues I had going straight to v12.

So my steps have been as follows:

1. Use the packager to export what is needed from v7 and upload to a clean v10 site
2. Run a conversion using UpgradeUmbracoSevenPlan and Import Everything
3. Run a conversion using SlideShowSlideMigrationPlan and Import

The site I am currently executing this on is using the property editor with the alias Umbraco.NestedContent and not Our.Umbraco.NestedContent.

I am still not hitting my break point.

Is inheriting from SyncPropertyMigratorBase enough for it to be discovered? It looks like it should be fine and should be found via the attributes.

[KevinJump]

Yes -

That method is fine, but i think you 'v8' conversion should point at your uSync/v9 folder

1. using your migration from v7 - your v10 wil have everything it in,
2. in normal uSync run a 'clean export' this will put the newly migrated values into uSync/v9
3. create a new 'conversion' migration running against this uSync/v9 folder and things should migrate

When doing this way I think step 2 is the key here.

You could in theory do it all in one step, but i can see why doing it in a few makes a bit more sense and gives you more control

[ProNotion]

Awesome! We are back in business and now hitting my breakpoint. Thanks Kevin, I can finally start making some progress again.

[ProNotion]

@KevinJump Can I have more than one NestedContent migrator execute in a single migration plan? I have a lot of work to do in regards to nested content and it would great not to have to end up with lots of separate steps and additional wait time to execute them.

[KevinJump]

ermm... yes i think you can...

you can override the migrators per 'property'

        PropertyMigrators = new Dictionary<string, string>
        {
            {
                "MyNestedContentPropertyAlias", "MyCustomNestedContentMigrator"
            }
        }

you can also do it per property on a content type.

so MyDocumentTypeAlias_MyPropertyAlias should also work

[ProNotion]

In the case above - what happens about cleaning up the nested content datatype config to remove or replace the old content type references?

[KevinJump]

I think the config should also map, (so the content type mapping lookup will also happen when the config is being migrated).

[KevinJump]

In terms of your property mappings, thats probibly harder

if think at the moment the problem might be that the NestedContentMigrator will not migrate a property if it can't find it in the new ContentType.

but that could be changed here : https://github.com/Jumoo/uSyncMigrations/blob/main/uSync.Migrations.Migrators/Core/NestedContentMigrator.cs#L58

if when the editorAlias is null (because we haven't been able to find it in the new content type). we could perhaps do a replacement alias lookkup ,(so look for the old propertyAlias, replace it with the new one?)

infact i am fairly confident a replacement alias lookup before the lookup might work?

e.g if we replace the top of the lookup in nested content with

              var contentTypeAlias = context.ContentTypes.GetReplacementAlias(row.ContentTypeAlias);
              var propertyAlias = context.ContentTypes.GetReplacementAlias(property.Key);
              var editorAlias = context.ContentTypes.GetEditorAliasByTypeAndProperty(contentTypeAlias, propertyAlias);
              if (editorAlias == null) continue;

then we would lookup the new content alias, but we would also lookup the new property name from the replacements.
(in the replacements in the migration plan)

{ "OldContentType", "NewContentType" }
{ "OldNestedPropertyAlias", "NewMappedNestedPropertyAlias" }

the issue might then be that the properties are not of the same type ??

you could put a custom migrator in for the new property alias. (in the property migrators in the migration plan)

{"NewMappedNestedPropertyAlias", "MyCustomFromAtoBMigrator" }

• this is all theoretical !!

[ProNotion]

This all sounds great and I will try and explore it further. Going back to another issue I was trying to address previously - I am assuming I still need my own Nested Content migrator in order to add any new content types first using the method you describe in the GetConfigValues method?

Thanks again for taking the time to help fill in the gaps in my knowledge here.

[KevinJump]

yeah - i think the migrator makes the most sense as that's the place you have the file.

[ProNotion]

i think there is a way to map and old content type to a new one, but not sure how it works inside the nested migrator (i mean it should, in theory everything asks for the content type alias from the context. and the context can map old to new content types.

So you could configure that in the migration plan,

        ReplacementAliases = new Dictionary<string, string>
        {
            {  "MyOldContentTypeAlias", "MyNewContentTypeAlias" }
        }

I just tried this and it didn't seem to have any effect on my nested content as looking at the migrated files I still see the old content type aliases in the nested content after.

This is what my options look like in the migration plan:

    public MigrationOptions Options => new()
    {
        Target = $"{uSyncMigrations.MigrationFolder}/v7_migrated_{DateTime.Now:yyyyMMdd_HHmmss}",
        Handlers = _migrationHandlers.SelectGroup(8, string.Empty),
        SourceVersion = 8,
        ReplacementAliases = new Dictionary<string, string>
        {
            {
                VideoContentBlock.ModelTypeAlias, FeatureBlockSection.ModelTypeAlias
            },
            {
                CampaignBlockSection.ModelTypeAlias, FeatureBlockSection.ModelTypeAlias
            },
        }
    };

[ProNotion]

Looks like it may perform this action when I add this to the migration plan:

        PreferredMigrators = new Dictionary<string, string>
        {
            { Constants.PropertyEditors.Aliases.NestedContent, "NestedToBlockListMigrator" },
        },

However, it seems to be changing the alias of the content types and not migrating the content that was using the content type so I think I will need to fall back to how I was doing it previously. In my example above what I appear to end up with is 2 content types with the same alias when in fact I wanted to migrate all content from of the same content type as the first alias to the content type with the second alias.