In Umbraco 9, managing granular permissions directly within the backoffice to allow an editor to update only a single property on a document type while restricting access to others isn't supported out of the box. Umbraco's permissions system primarily focuses on node-level permissions rather than property-level permissions.

However, you can achieve this requirement through a couple of alternative approaches:

1. Custom Section and Dashboard

One common workaround is to create a custom section or dashboard within the Umbraco backoffice that provides a specialized interface for editing specific properties. This approach involves some development but can be very effective for controlling exactly which properties a user can interact with.

Steps to create a custom dashboard:

1. Define a new dashboard: You'll need to create a new dashboard or use an existing one and restrict it based on user groups.

2. Create a custom view or controller: In this view, you can load only the specific properties you want the user to edit.

3. Save changes through APIs: Use Umbraco's Content Service in your custom controller to update only the specific properties and save the changes.

Example of a simple controller method in C# that updates a specific property:

public IActionResult UpdateProperty(int nodeId, string propertyAlias, string value)
{
    var contentService = Services.ContentService;
    var content = contentService.GetById(nodeId);
    if (content != null)
    {
        content.SetValue(propertyAlias, value);
        contentService.Save(content);
        return Ok("Property updated successfully.");
    }
    return NotFound("Content not found.");
}

2. Event Handling

Another method is to use event handling to control what gets saved when a content item is being saved. This method doesn't prevent the user from seeing or modifying other properties in the backoffice, but you can programmatically enforce which properties get saved based on the user's permissions.

Using Content Saving Event:

You can subscribe to the ContentService.Saving event and check the properties being saved. If the user does not have permission to modify certain properties, you can revert them to their original values.

Example event handler:

  public void Initialize(){
    ContentService.Saving += OnContentSaving;
}

private void OnContentSaving(IContentService sender, ContentSavingEventArgs e)
{
    foreach (var content in e.SavedEntities)
    {
        // Check user permissions here
        if (!UserHasPropertyPermission(User.Identity.Name, "propertyAlias"))
        {
            // Revert the value to the original
            var originalValue = content.GetValue("propertyAlias");
            content.SetValue("propertyAlias", originalValue);
        }
    }
}

public bool UserHasPropertyPermission(string username, string propertyAlias)
{
    // Implement your logic to determine if the user has permission to edit the property
    return false; // Default to no permission
}
`

Important Considerations - User Interface: Both methods require modifications to the user interface in the Umbraco backoffice. You might need to provide custom views or editors. - Security: Ensure that any custom solutions properly authenticate and authorize users to prevent unauthorized access or changes. - Maintainability: Custom solutions may need to be updated with future Umbraco upgrades, as they could be affected by changes in the core system.

These approaches require some development effort and familiarity with Umbraco's backoffice UI customization, APIs, and event handling. If you are not comfortable implementing these solutions, consider involving a developer who has experience extending Umbraco.

I hope this helps you navigate your issue! If you have any more questions or need further assistance, feel free to reach out. Good luck with your Umbraco project, and happy coding!

Best regards,

UCP

is working on a reply...