Best practice to update/create a Content Item using the Content Manager I receive in DI when I have multiple nested BagPart

[MarGraz]

Hi Everyone,

We previously discussed a similar topic here.
I'm working on my API Controller for my Orchard Core microservice and need to implement the Update/Insert (Upsert) for a single PublisherManager. But it includes two nested BagPart components, and I'm encountering issues with this setup.

Here's how the Content Type structure is defined:

1. PublisherManager Content Type
   • Contains a BagPart of PublisherPublisherManagerRelation Content Type.
     • This PublisherPublisherManagerRelation includes a BagPart of PublishingDistributor.
       • The PublishingDistributor consists of a single field of MultiTextField.

To clarify the structure, here's the JSON representation of the PublisherManager type with all the nested bag parts that I retrieved from the DB Document table:

{
    "ContentItemId": "41p7rs7vdswcy6r84je6xjjb45",
    "ContentItemVersionId": "40qgvgs9veeybzncagmc7pdznz",
    "ContentType": "PublisherManager",
    "DisplayText": null,
    "Latest": true,
    "Published": true,
    "ModifiedUtc": "2024-05-08T17:38:36.353494Z",
    "PublishedUtc": "2024-05-08T17:38:48.3510301Z",
    "CreatedUtc": "2024-05-08T13:48:19.9678749Z",
    "Owner": "46ppk5a27b3081v2sgqe3bm8ms",
    "Author": "MarcoDev",
    "PublisherManager": {
        "PublisherManagerId": {
            "Text": "TestManager1234"
        },
        "UserId": {
            "Text": "TestUser1"
        }
    },
    "BagPart": {
        "ContentItems": [
            {
                "ContentItemId": "4qrg3a8jscerd1wvtfz8n0cgd5",
                "ContentItemVersionId": null,
                "ContentType": "PublisherPublisherManagerRelation",
                "DisplayText": "",
                "Latest": false,
                "Published": false,
                "ModifiedUtc": "2024-05-08T17:38:36.3742357Z",
                "PublishedUtc": null,
                "CreatedUtc": null,
                "Owner": "46ppk5a27b3081v2sgqe3bm8ms",
                "Author": "MarcoDev",
                "PublisherPublisherManagerRelation": {
                    "Publisher": {
                        "ContentItemIds": [
                            "4w7zb827439vk6gq7586jjjkmw"  // Content Picker Field
                        ]
                    },
                    "PublisherId": {
                        "Text": "TestPublisher1234"
                    },
                    "SalesManagerFullname": {
                        "Text": "Pippo Pluto"
                    },
                    "Email": {
                        "Text": "[email protected]"
                    },
                    "Phone": {
                        "Text": null
                    },
                    "WhatsApp": {
                        "Text": null
                    },
                    "Website": {
                        "Text": null
                    },
                    "Instagram": {
                        "Text": null
                    },
                    "Facebook": {
                        "Text": null
                    },
                    "Description": {
                        "Text": "Ciao, this is a descritption"
                    }
                },
                "BagPart": {
                    "ContentItems": [
                        {
                            "ContentItemId": "4w6x47q4vmt6432t330bxqj9dh",
                            "ContentItemVersionId": null,
                            "ContentType": "PublishingDistributor",
                            "DisplayText": null,
                            "Latest": false,
                            "Published": false,
                            "ModifiedUtc": "2024-05-08T17:38:36.4186638Z",
                            "PublishedUtc": null,
                            "CreatedUtc": null,
                            "Owner": "46ppk5a27b3081v2sgqe3bm8ms",
                            "Author": "MarcoDev",
                            "PublishingDistributor": {
                                "Distributors": { // Multi Text Fields
                                    "Values": [
                                        "1",
                                        "2"
                                    ]
                                }
                            }
                        }
                    ]
                }
            }
        ]
    }
}

When attempting to update, my PublisherManager and related BagPart such as PublisherPublisherManagerRelation and PublishingDistributor never update.

In this case with nested BagPart:

1. How can I successfully update the contained BagPart?
2. Can I use the Alter method to accomplish this?

If you have any suggestions, please feel free to reply.

Here's the code that is not working:

public async Task<ApiResult<PublisherManagerApiModel>> UpsertPublisherManagerAsync(PublisherManagerApiModel model)
{
    // Validate the model
    // [...] omitted

    bool isUpdate = !string.IsNullOrEmpty(model.ContentItemId);
    ContentItem contentItem = isUpdate ? await _contentManager.GetAsync(model.ContentItemId, VersionOptions.Published)
                                        : await _contentManager.NewAsync(nameof(PublisherManager));

    if (contentItem == null)
    {
        return new ApiResult<PublisherManagerApiModel>(HttpStatusCode.NotFound, "PublisherManager not found.");
    }

    // Manage the PublisherManager part
    PublisherManager publisherManagerPart = contentItem.As<PublisherManager>() ?? new PublisherManager();
    publisherManagerPart.PublisherManagerId.Text = model.PublisherManagerId;
    publisherManagerPart.UserId.Text = model.UserId;

    // Manage the BagPart
    BagPart bagPart = contentItem.GetOrCreate<BagPart>();

    if (isUpdate)
    {
        bagPart.ContentItems.Clear();  // Clear existing items if updating
    }

    // Handle relations as child content items
    foreach (PublisherPublisherRelation relation in model.Publishers)
    {
        ContentItem childContentItem = await _contentManager.NewAsync("PublisherPublisherManagerRelation");

        childContentItem.Alter<PublisherPublisherManagerRelation>(nameof(PublisherPublisherManagerRelation), childPart =>
        {
            childPart.SalesManagerFullname.Text = relation.SalesManagerFullname;
            childPart.Email.Text = relation.Email;
            childPart.Phone.Text = relation.Phone;
            childPart.Whatsapp.Text = relation.Whatsapp;
            childPart.Website.Text = relation.Website;
            childPart.Instagram.Text = relation.Instagram;
            childPart.Facebook.Text = relation.Facebook;
            childPart.Description.Text = relation.Description;

            // Populate Publishers
            childPart.Publishers.Clear();
            
            foreach (string publisherId in relation.RelatedPublishers.ContentItemIds)
            {
                childPart.Publishers.Add(new TextField { Text = publisherId });
            }

            // Populate DistributorValues
            childPart.DistributorValues.Clear();
            
            foreach (int distributor in relation.DistributorValues)
            {
                PublishingDistributor newDistributorPart = new PublishingDistributor
                {
                    Distributors = new MultiTextField
                    {
                        Values = new[] { distributor.ToString() }
                    }
                };
                childPart.DistributorValues.Add(newDistributorPart);
            }
        });

        bagPart.ContentItems.Add(childContentItem);
    }

    // Persist changes
    if (isUpdate)
    {
        await _contentManager.UpdateAsync(contentItem);
    }
    else
    {
        await _contentManager.CreateAsync(contentItem, VersionOptions.Published);
    }
    await _contentManager.PublishAsync(contentItem);

    return new ApiResult<PublisherManagerApiModel>(HttpStatusCode.OK, model);
}

This is my PublisherManagerApiModel:

public class PublisherManagerApiModel
{
   public string ContentItemId { get; set; } // Additional property compared to the BO        
   public string UserId { get; set; }
   public string PublisherManagerId { get; set; }        
   public List<PublisherPublisherRelation> Publishers { get; set; }		
}

public class PublisherPublisherRelation
{
   public RelatedPublishers RelatedPublishers { get; set; }
   public string SalesManagerFullname { get; set; }
   public string Email { get; set; }
   public string Phone { get; set; }
   public string? Whatsapp { get; set; }
   public string? Website { get; set; }
   public string? Instagram { get; set; }
   public string? Facebook { get; set; }
   public string? Description { get; set; }
   public List<int> DistributorValues { get; set; }
}

public class RelatedPublishers
{
   public List<string> ContentItemIds { get; set; }
}

This is how I have represented the PublisherManager model:

using OrchardCore.ContentFields.Fields;
using OrchardCore.ContentManagement;

public class PublisherManager : ContentPart
{
    public TextField PublisherManagerId { get; set; } = new();
    public TextField UserId { get; set; } = new();
    public List<PublisherPublisherManagerRelation> PublisherRelations { get; set; } = new();
}

public class PublisherPublisherManagerRelation : ContentPart
{
    // Publisher picker
    public List<TextField> Publishers { get; set; } = new();

    // Other properties
    public TextField PublisherId { get; set; } = new();
    public TextField SalesManagerFullname { get; set; } = new();
    public TextField Email { get; set; } = new();
    public TextField Phone { get; set; } = new();
    public TextField Whatsapp { get; set; } = new();
    public TextField Website { get; set; } = new();
    public TextField Instagram { get; set; } = new();
    public TextField Facebook { get; set; } = new();
    public TextField Description { get; set; } = new();

    // Distributors select
    public List<PublishingDistributor> DistributorValues { get; set; } = new();
}

public class PublishingDistributor : ContentPart
{
    public MultiTextField Distributors { get; set; } = new();
}

Thank you

[MarGraz]

I think there could be a binding problem because how I represented the PublisherPublisherManagerRelation model, which is not similar to the JSON. I will continue debugging 🤯

[Piedone]

I'd really need a summary here that you can tell with a single breath :). I appreciate you putting so much effort into making your questions/comments detailed, but looking at the pages of text here it's intimidating to even start to grasp what the topic is about.

[MarGraz]

@Piedone yes, I understand 😅 I prefer to provide code snippets to give readers an overview of what I'm discussing.

Summary

I have a Content Type PublisherManager which has two nested BagPart:

• The PublisherManager contains the PublisherPublisherManagerRelation bag part;
• The PublisherPublisherManagerRelation contains another bag part of type PublishingDistributor.

Note: in the first message there's the full JSON that shows what I have described.

I implemented the UpsertPublisherManagerAsync method in my handler to perform the create/update operation on the PublisherManager (refer to the updated code in the last message). But, I never get the PublisherManager updated, and I don't receive any exception 🙃🤯

I don't understand what I'm doing wrong. I'm using the ContentManager and the Alter methods to handle the types, but there's probably something that I'm missing.

Thank you

[Piedone]

Nesting Bag Parts may be an issue (shouldn't be though). Did you try with something simple like updating Title Part first, and see if that works?

[MarGraz]

@Piedone in the end, I was able to make it work 🥳 but I think we need more deep and accurate documentation on this, because it's something about the behavior Orchard Core framework expects.

The problem was how I was doing the Alter on the BagPart, and how I was doing the add of the BagPart to my content item. In fact, there's a strict way to do it, as fortunately @deanmarcussen explained some years ago here, and it is like:

1. First, Alter the BagPart content item (always get/create the BagPart through the ContentManager in DI);
2. Add the BagPart to your main contentItem;
3. Persist the changes in the DB (CreateAsync or UpdateAsync, etc.);

Note: never do all these operations all together in a single expression, it will never work, and no exception will be returned 🤯

So the example is the same as the discussion I linked before (here with comments):

// 1. "Create" or "Get" the "BagPart" content item (called "activity" here) via Content Manager in DI
var activity = await _contentManager.NewAsync("ActivityDateItem");

// 2. "Alter" the obtained "BagPart" content item ("activity")
activity.Alter<ActivityDateItem>(x => 
{
    x.Alter<TextField>("Description", d => d.Text = "SomeValue");
    ...
};

// 3. "Add" the obtained "BagPart" ("activity") to the main "contentItem" with another "Alter" expression
contentItem.Alter<BagPart>(x =>
{
   x.ContentItems.Add(activity);
}

// 4. Save "contentItem" changes on the DB
await _contentManager.UpdateAsync(contentItem);
await _contentManager.PublishAsync(contentItem);

I hope this will be useful for other OC users 😊
Here it is my UpsertPublisherManagerAsync updated.

public async Task<ApiResult<PublisherManagerApiModel>> UpsertPublisherManagerAsync(PublisherManagerApiModel model)
{
    // Validate the model
    // [...]

    ContentItem contentItem;
    bool isUpdate = !string.IsNullOrEmpty(model.ContentItemId);

    if (isUpdate)
    {
        // Try to get the existing content item
        contentItem = await _contentManager.GetAsync(model.ContentItemId, VersionOptions.Published);

        if (contentItem == null)
        {
            return new ApiResult<PublisherManagerApiModel>(HttpStatusCode.NotFound, $"PublisherManager {model.ContentItemId} not found.");
        }
    }
    else
    {
        // Create a new content item
        contentItem = await _contentManager.NewAsync(nameof(PublisherManager));
    }

    // Update/Insert the main properties
    contentItem.Alter<PublisherManager>(x =>
    {
        x.UserId.Text = model.UserId;
        x.PublisherManagerId.Text = model.PublisherManagerId;
    });

    // Create or update PublisherPublisherManagerRelation content items
    List<ContentItem> updatedRelations = new List<ContentItem>();

    foreach (PublisherPublisherRelation publisher in model.Publishers)
    {
        ContentItem publisherRelationItem;

        // Check if the PublisherPublisherManagerRelation already exists
        ContentItem? existingRelationItemBagPart = contentItem.Get<BagPart>(nameof(BagPart)).ContentItems
            .FirstOrDefault(c => c.As<PublisherPublisherManagerRelation>().Publisher.ContentItemIds.SequenceEqual(publisher.RelatedPublishers.ContentItemIds));

        if (existingRelationItemBagPart != null)
        {
            publisherRelationItem = existingRelationItemBagPart;
        }
        else
        {
            // Create a new PublisherPublisherManagerRelation
            publisherRelationItem = await _contentManager.NewAsync(nameof(PublisherPublisherManagerRelation));
        }

        // Update or set the PublisherPublisherManagerRelation properties
        publisherRelationItem.Alter<PublisherPublisherManagerRelation>(x =>
        {
            x.SalesManagerFullname.Text = publisher.SalesManagerFullname;
            x.Email.Text = publisher.Email;
            x.Phone.Text = publisher.Phone;
            x.Whatsapp.Text = publisher.Whatsapp;
            x.Website.Text = publisher.Website;
            x.Instagram.Text = publisher.Instagram;
            x.Facebook.Text = publisher.Facebook;
            x.Description.Text = publisher.Description;
            x.Publisher.ContentItemIds = publisher.RelatedPublishers.ContentItemIds.ToArray();
        });

        // Handle Distributors using the BagPart within publisherRelationItem
        BagPart distributorBagPart = publisherRelationItem.Get<BagPart>(nameof(BagPart));

        // Clear existing distributor items to overwrite what already present
        distributorBagPart.ContentItems.Clear();

        foreach (int distributorValue in publisher.DistributorValues)
        {
            // Create new distributor item
            ContentItem newDistributorItem = await _contentManager.NewAsync(nameof(PublishingDistributor));

            newDistributorItem.Alter<PublishingDistributor>(d =>
            {
                d.Distributors.Values = new[] { distributorValue.ToString() };
            });

            distributorBagPart.ContentItems.Add(newDistributorItem);
        }

        // Ensure the Distributor BagPart is assigned to the PublisherPublisherManagerRelation
        publisherRelationItem.Alter<BagPart>(nameof(BagPart), d =>
        {
            d.ContentItems = distributorBagPart.ContentItems;
        });

        updatedRelations.Add(publisherRelationItem);
    }

    // Alter the BagPart in the main content item
    contentItem.Alter<BagPart>(x =>
    {
        // Clear existing items to overwrite what already present
        x.ContentItems.Clear();

        foreach (var relation in updatedRelations)
        {
            x.ContentItems.Add(relation);
        }
    });

    // Save and publish the content item
    if (isUpdate)
    {
        await _contentManager.UpdateAsync(contentItem);
    }
    else
    {
        await _contentManager.CreateAsync(contentItem, VersionOptions.Published);
    }

    await _contentManager.PublishAsync(contentItem);

    // Return the updated model
    model.ContentItemId = contentItem.ContentItemId;
    return new ApiResult<PublisherManagerApiModel>(HttpStatusCode.OK, model);
}

Thank you