Best practice to update/create a Content Item using the Content Manager I receive in DI

[MarGraz]

Hi Everyone,

I'm working on my API Controller for my Orchard Core microservice, and I have already implemented the GetById, GetAll (paginated, thanks to YesSql) endpoints for my Publisher Content Item. Now, I need to implement the Update/Insert (Upsert) for a single Publisher.

What's the best practice to do it? 🤔

I have looked into some useful resources, like the ContentExtensions methods class here, which helps with model mapping, updates, creation, etc. Also the ContentManager offers many methods here.

What I have done so far:

1. I created my Publisher model, implementing the ContentPart class, to align it with the one in the Orchard Core database;
2. I tried using both the ContentExtensions and ContentManager to make the mapping part easier and more robust;
3. It didn't work. Perhaps I'm misusing the implementation of ContentPart (Maybe mine is not a ContentPart? But looking at the inherited classes I believe it is).

Here is the Publisher Content Type I created in the OC backoffice:

Here is the model I used:

using OrchardCore.ContentFields.Fields;
using OrchardCore.ContentManagement;
using OrchardCore.Media.Fields; 
    
    public class Publisher : ContentPart
    {
        public TextField PublisherId { get; set; } = new();
        public TextField Name { get; set; } = new();
        public BooleanField IsActive { get; set; } = new();
        public MediaField Logo { get; set; } = new();
    }

    public class PublisherApiModel
    {
        public string ContentItemId { get; set; }
        [Required(ErrorMessage = $"{nameof(PublisherId)} is required.")]
        public string PublisherId { get; set; }
        [Required(ErrorMessage = $"{nameof(Name)} is required.")]
        public string Name { get; set; }
        public bool IsActive { get; set; }
        public string Logo { get; set; }
    }

Here is the code of my method in a handler class, called by the API Controller:

public async Task<ApiResult<PublisherApiModel>> UpsertPublisherAsync(PublisherApiModel model)
{
    ContentItem contentItem;
    bool isUpdate = true;

    if (string.IsNullOrEmpty(model.ContentItemId))
    {
        isUpdate = false;
        contentItem = await _contentManager.NewAsync("Publisher");
        _logger.LogInformation("Creating new Publisher content item.");
    }
    else
    {
        contentItem = await _contentManager.GetAsync(model.ContentItemId, VersionOptions.DraftRequired);
        if (contentItem == null)
        {
            _logger.LogError($"No Publisher found with ID: {model.ContentItemId}");
            return new ApiResult<PublisherApiModel>(HttpStatusCode.NotFound, "Publisher not found.");
        }
        _logger.LogInformation($"Updating existing Publisher content item with ID: {model.ContentItemId}");
    }

    // Retrieve or create the Publisher part
    var publisherPart = contentItem.As<Publisher>();
    if (publisherPart == null)
    {
        publisherPart = new Publisher();
        contentItem.Apply(nameof(Publisher), publisherPart);
    }

    contentItem.Alter<Publisher>(nameof(Publisher), part =>
    {
        part.PublisherId.Text = model.PublisherId;
        part.Name.Text = model.Name;
        part.IsActive.Value = model.IsActive;
        part.Logo.Paths = new[] { model.Logo };
    });

    // Validate the content item
    var validationResult = await _contentManager.ValidateAsync(contentItem);
    if (!validationResult.Succeeded)
    {
        string allErrors = string.Join("; ", validationResult.Errors.Select(e => e.ErrorMessage));
        _logger.LogError("Validation failed for Publisher content item: " + allErrors);
        return new ApiResult<PublisherApiModel>(HttpStatusCode.BadRequest, allErrors);
    }

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

    _logger.LogInformation($"{(isUpdate ? "Updated" : "Created")} Publisher content item with ID: {contentItem.ContentItemId}");

    return new ApiResult<PublisherApiModel>(HttpStatusCode.OK, new PublisherApiModel
    {
        ContentItemId = contentItem.ContentItemId,
        PublisherId = model.PublisherId,
        IsActive = model.IsActive,
        Name = model.Name,
        Logo = model.Logo
    });
}

Can someone provide some guidance? 🤓

Thank you so much

[MarGraz]

Maybe @Piedone @hishamco you have the answer 🙃
I'm in the same situation for the permanent deletion here.

Thank you 🙏

[hishamco]

I didn't understand what's the issue exactly!! you can use the content manager APIs as already used in many places in the code-base

[MarGraz]

Thank you for your reply.

The code above doesn't work, no Publisher is created. It may be because I am doing something wrong when trying to use the contentItem.Alter<Publisher>.

So the questions are:

1. Is it correct to use the ContentPart as I have done in the code above?
2. What are the best practices for managing the update/create processes from my handler class?

Thank you

[hishamco]

It seems Zoltan referred you to a demo app, please check it and if you have any further question feel free to ask

[Piedone]

Have you checked out https://github.com/Lombiq/Orchard-Training-Demo-Module/blob/dev/Lombiq.TrainingDemo/Controllers/PersonListController.cs too?

[MarGraz]

@Piedone following the demo you linked I was able to update or create my Content Item, here the new code I have implemented:

public async Task<ApiResult<PublisherApiModel>> UpsertPublisherAsync(PublisherApiModel model)
{
    // Validate the model
    var validationResults = new List<ValidationResult>();
    var validationContext = new ValidationContext(model, serviceProvider: null, items: null);
    if (!Validator.TryValidateObject(model, validationContext, validationResults, true))
    {
        _logger.LogError($"Validation failed: Model state is invalid.");
        return new ApiResult<PublisherApiModel>(
            HttpStatusCode.BadRequest,
            string.Join("; ", validationResults.Select(e => e.ErrorMessage))
        );
    }

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

    ContentItem contentItem = isUpdate ? await _contentManager.GetAsync(model.ContentItemId, VersionOptions.Published)
                           : await _contentManager.NewAsync(nameof(Publisher));

    if (contentItem == null)
    {
        _logger.LogError($"No Publisher found with ID: {model.ContentItemId}");
        return new ApiResult<PublisherApiModel>(HttpStatusCode.NotFound, "Publisher not found.");
    }

    // Ensure the part exists and alter it
    Publisher publisherPart = contentItem.As<Publisher>() ?? new Publisher();

    contentItem.Alter<Publisher>(nameof(Publisher), part =>
    {
        part.PublisherId.Text = model.PublisherId;
        part.Name.Text = model.Name;
        part.IsActive.Value = model.IsActive;
        part.Logo.Paths = new[] { model.Logo };
        part.Logo.MediaTexts = new string[] { };
    });

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

    await _contentManager.PublishAsync(contentItem);

    _logger.LogInformation($"{(isUpdate ? "Updated" : "Created")} Publisher with ID: {contentItem.ContentItemId}");

    model.ContentItemId = contentItem.ContentItemId;
    return new ApiResult<PublisherApiModel>(HttpStatusCode.OK, model);
}

Thank you

[Piedone]

Great!