// get the element types for spot blocks (content and settings)

                            // build the individual parts of the block grid data from the raw data
                            var layoutItems = new List<BlockGridLayoutItem>();
                            var areaItems = new List<BlockGridAreaItem>();
                            var gridContentData = new List<BlockGridElementData>();
                            var gridSettingsData = new List<BlockGridElementData>();

                            //add layout to the grid first
                            foreach (GridExportRow row in contentPage.GridExportSections!.GridExportSection!.GridExportRows!.GridExportRow!) {
                                foreach (var area in row.GridExportItems!.GridExportItem!.GridExportAreas!.GridExportArea!) {
                                    // generate new UDIs for block content and settings
                                    var contentUdi = Udi.Create(Constants.UdiEntityType.Element, Guid.NewGuid());
                                    var settingsUdi = Udi.Create(Constants.UdiEntityType.Element, Guid.NewGuid());
                                    switch (area.Alias)
                                    {
                                        case "rte":

                                            // create new content data

                                            IContentType? blockRTEType = _contentTypeService.Get("blockGridRichtext");
                                            // create a new layout item
                                            layoutItems.Add(new BlockGridLayoutItem(contentUdi, int.Parse(area.Columns), 1, new(), settingsUdi));
                                            gridContentData.Add(new BlockGridElementData(blockRTEType!.Key, contentUdi, new Dictionary<string, object>
                                            {
                                                { "content", area!.Rte },
                                            }));

                                        break;

                                        case "media":
                                            // generate new UDIs for block content and settings
                                            IContentType? blockImageType = _contentTypeService.Get("blockGridImage");

                                            // create a new layout item
                                            layoutItems.Add(new BlockGridLayoutItem(contentUdi,int.Parse(area.Columns), 1, new(), settingsUdi));
                                            //upload the image if it hasn't already been uploaded so we don't have the same image uploaded multiple times.
                                            if (area.Media !=null && area.Media.Image != "")
                                            {
                                                var existingMediaItem = mediaFolder!.Descendants<Image>().Where(x => x.PreviousID == area.Media.Id.ToString().Trim());
                                                if (existingMediaItem != null && existingMediaItem.Any())
                                                {
                                                    Udi UDIMedia = Udi.Create(Constants.UdiEntityType.Media, existingMediaItem.FirstOrDefault()!.Key);
                                                    gridContentData.Add(new BlockGridElementData(blockImageType!.Key, contentUdi, new Dictionary<string, object>{
                                                        { "image", UDIMedia },
                                                    }));
                                                }
                                                else { 
                                                    try
                                                    {
                                                        string mainImage = "https://www.oldsitedomain.com/" + area.Media.Image;
                                                        int uploadedImageID = UploadMediaAsync(mainImage, 12345, area.Media.Id);
                                                        var primaryImage = _mediaService.GetById(uploadedImageID);
                                                        if (primaryImage != null)
                                                        {
                                                            var mediaUdi = Udi.Create(Constants.UdiEntityType.Media, primaryImage.Key);

                                                            gridContentData.Add(new BlockGridElementData(blockImageType!.Key, contentUdi, new Dictionary<string, object>
                                                            {
                                                            { "image", mediaUdi },

                                                            }));
                                                        }
                                                    }
                                                    catch
                                                    {
                                                        //logging removed
                                                    }
                                                }
                                            }
                                            // create new content data

                                            break;
                                        case "quote":
                                            // generate new UDIs for block content and settings
                                            IContentType? blockQuoteType = _contentTypeService.Get("blockGridQuote");

                                            // create a new layout item
                                            layoutItems.Add(new BlockGridLayoutItem(contentUdi, int.Parse(area.Columns), 1, new(), settingsUdi));
                                            //upload the image
                                            if (area.Quote!.Value != "")

                                                gridContentData.Add(new BlockGridElementData(blockQuoteType!.Key, contentUdi, new Dictionary<string, object>{
                                                    { "quote", area.Quote.Value },
                                                }));
                                            }
                                            // create new content data

                                            break;

                                    }
                                }
                            }

                            //setup areas
                            var areas = new List<BlockGridArea>();

                            foreach (var gridContent in layoutItems) {
                                var areaItemLoop = new BlockGridAreaItem();
                                var settingsUdi = Udi.Create(Constants.UdiEntityType.Element, Guid.NewGuid());
                                areaItemLoop.ContentUdi = gridContent.ContentUdi;
                                areaItemLoop.SettingsUdi = settingsUdi;
                                areaItemLoop.Areas = new();
                                areaItemLoop.ColumnSpan = gridContent.ColumnSpan;
                                areaItemLoop.RowSpan = gridContent.RowSpan;
                                areaItems.Add(areaItemLoop);
                            }


                            layoutItems.Clear();
                            //area for two col (left)
                            areas.Add(new BlockGridArea(Guid.Parse("GUIDFORLAYOUTAREA1"), new()));
                            //area for two col (right)
                            areas.Add(new BlockGridArea(Guid.Parse("GUIDFORLAYOUTAREA2"), new()));
                            //area for fullwidth col 
                            areas.Add(new BlockGridArea(Guid.Parse("GUIDFORLAYOUTAREA3"), areaItems));

                            //create layout area
                            var contentLayoutUdi = Udi.Create(Constants.UdiEntityType.Element, Guid.NewGuid());
                            IContentType? contentLayoutType = _contentTypeService.Get("blockGridContentLayout");

                            gridContentData.Add(new BlockGridElementData(contentLayoutType!.Key, contentLayoutUdi, new Dictionary<string, object>
                            {

                            }));
                            layoutItems.Add(new BlockGridLayoutItem(contentLayoutUdi, 12, 1, areas));
                            //new BlockGridArea(new Guid(), areaItems)

                            // construct the block grid data from layout, content and settings
                            var blockGridData = new BlockGridData(
                                new BlockGridLayout(layoutItems.ToArray()),
                                gridContentData.ToArray(),
                                gridSettingsData.ToArray());


                            // serialize the block grid data as JSON and save it to the "blockGrid" property on the content item
                            var propertyValue = JsonConvert.SerializeObject(blockGridData);
                            content!.SetValue("content", propertyValue);



                        }

                        if (!skipItem) { 
                            _contentService.SaveAndPublish(content!, "en-GB");

                        }
                        if (unpublishItem) {
                            _contentService.Unpublish(content!, "en-GB");
                        }

The above is very much cut down, and specifically the grid to block grid importing. Hopefully it might give you something to start off with. Our process now is: generate XML from the existing v7 site. On the new v11 site, get that xml, map it to models and create or update content items. The above section deals specfically with the block grid import. It's heavily stripped down. We have a bunch of additional DTGE mappings and other grid fields that are also migrated and inserted appropriately. We then have Hangfire running on the v11 site so we we can re run the imports as the code is amended. It's working pretty well at this point.

I don't see some of these classes. Maybe they were renamed?

• BlockGridElementData
• BlockGridAreaItem

This bit seems to be helping me:

    [Route("[action]")]
    public object ViewTypes()
    {

        return new
        {

            contentTypes = ContentTypeService.GetAll().Select(ct =>
            new
            {
                ct.Key,
                ct.Name,
                ct.Alias,
                ct.Id,
                propertyTypes = ct.PropertyTypes.Select(pt => new
                {
                    pt.Key,
                    pt.Name,
                    pt.Alias,
                    pt.Id,
                    pt.DataTypeId
                })
            }),
            dataTypes = DataTypeService.GetAll().Select(dt => new
            {
                dt.Name,
                dt.Key,
                dt.Configuration,
                dt.EditorAlias
            })
        };
    }

I figured it out! Pays to read the spec...

The key for the areas should be the same as the key in the config. I was creating a new one. Whoops.

Hi

Trying to get the key as well I am not quite sure what you mean the same as in the config what config are you referring to

Thanks for any help

Any chance you ever figured this out?

I'm attempting to do the same thing and everything looks correct. For the "area" key however, I'm just generating a new Guid which sounds like it may be wrong.

Any help would be hugely appreciated!

And in typical fashion, as soon as I asked his question the answer popped into my head. For anyone else looking to do similar:

They key value has to match the guid of the area in your block grid data type i.e., the guid of the area shown in the example below:

I'm not sure if there's an easier way to get the guid but I created a unique name for this area e.g., migrated_area_0 and searched for this in the database table dbo.umbracoDataType. The JSON stored will have the key in it (606689e1-2a06-4a8c-9656-2fd2fe61d063 in the below example`).

...
{
    "columnSpanOptions": [],
    "rowMinSpan": 1,
    "rowMaxSpan": 1,
    "allowAtRoot": true,
    "allowInAreas": false,
    "areas": [
        {
        "key": "606689e1-2a06-4a8c-9656-2fd2fe61d063",
        "alias": "migrated_area_0",
        "columnSpan": 12,
        "rowSpan": 1,
        "minAllowed": 0,
        "specifiedAllowance": []
        }
    ],
    "contentElementTypeKey": "dd98da8b-871e-4bb7-b914-068121d18f16",
    "settingsElementTypeKey": "fa4d35cf-b5c6-4c23-bc70-b06a166498d7",
    "label": "One Column",
    "editorSize": "medium",
    "inlineEditing": false,
    "forceHideContentEditorInOverlay": false,
    "groupKey": "e5f4e94c-df91-3895-92f2-129cdbfde75b"
    }
...

Hope that's clear, took me a while to figure this out!

Thanks for this not sure now long it would have taken to figure out this was the exact thing I needed