DataEditor_Via_Hosted_Controller.cs

using Azure;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.ContentEditing;
using Umbraco.Cms.Core.Models.Editors;
using Umbraco.Cms.Core.PropertyEditors;
using Umbraco.Cms.Core.Serialization;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Strings;
using Umbraco.Cms.Tests.Common.Builders;
using Umbraco.Cms.Tests.Common.Builders.Extensions;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.TestServerTest;
using Umbraco.Cms.Web.BackOffice.Controllers;
using Umbraco.Cms.Web.Common.Formatters;
using Umbraco.Extensions;

namespace Our.Umbraco.Test.Examples.DataEditors;

[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerFixture)]
public class DataEditor_Via_Hosted_Controller : UmbracoTestServerTestBase
{
    private IContentType? contentType;

    [Test]
    public async Task Creates_Json_Model_For_New_Document()
    {
        var url = PrepareApiControllerUrl<ContentController>(x => x.GetEmpty("myDoctype", -1));

        var response = await Client.GetAsync(url);

        var json = await response.Content.ReadAsStringAsync();
        json = json.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);
        var model = JObject.Parse(json);

        var property = model.SelectToken("variants[0].tabs[0].properties[0]")!;

        await VerifyJson(property.ToString(Formatting.Indented));
    }

    [Test]
    public async Task Saves_Property_Value_To_Content()
    {
        var url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null!));

        var content = new ContentBuilder()
            .WithId(0)
            .WithName("My content")
            .WithContentType(contentType)
            .AddPropertyData()
            .WithKeyValue("myProperty",
                """
                {
                    "dataForBackoffice": "Some data we don't want to store",
                    "dataValue": "Data from user"
                }
                """
            )
            .Done()
            .Build();

        var model = new ContentItemSaveBuilder()
            .WithContent(content)
            .WithParentId(-1)
            .WithAction(ContentSaveAction.PublishNew)
            .Build();

        var payload = JObject.FromObject(model);

        var response = await Client.PostAsync(url, new MultipartFormDataContent { { new StringContent(payload.ToString()), "contentItem" } });

        var json = await response.Content.ReadAsStringAsync();
        json = json.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);
        var responseModel = JObject.Parse(json);

        var id = responseModel.Value<int>("id");
        var createdContent = GetRequiredService<IContentService>().GetById(id)!;
        var propValue = createdContent.GetValue("myProperty");

        await Verify(propValue);
    }

    [SetUp]
    public void SetupSchema()
    {
        if (contentType != null) return;

        var dataType = new DataTypeBuilder()
            .WithoutIdentity()
            .WithKey(new Guid("87c4db0b-4cee-4c49-9668-7607bf93fdb2"))
            .WithDatabaseType(ValueStorageType.Ntext)
            .WithName("My editor")
            .AddEditor()
                .WithAlias("my.editor")
                .AddExplicitValueEditorBuilder()
                    .WithValueType(ValueTypes.Json)
                    .Done()
                .Done()
            .Build();

        GetRequiredService<IDataTypeService>().Save(dataType);

        contentType = new ContentTypeBuilder()
            .WithoutIdentity()
            .WithName("My doctype")
            .WithAlias("myDoctype")
            .AddPropertyType()
                .WithAlias("myProperty")
                .WithName("My property")
                .WithPropertyEditorAlias("my.editor")
                .WithDataTypeId(dataType.Id)
                .Done()
            .Build();

        GetRequiredService<IContentTypeService>().Save(contentType);
    }
}

public class MyEditor : IDataEditor
{
    public const string PreviewPath = "/App_Plugins/MyEditor/editor.html";

    private readonly ILocalizedTextService localizedTextService;
    private readonly IShortStringHelper shortStringHelper;
    private readonly IJsonSerializer jsonSerializer;

    public MyEditor(
        ILocalizedTextService localizedTextService,
        IShortStringHelper shortStringHelper,
        IJsonSerializer jsonSerializer
        )
    {
        this.localizedTextService = localizedTextService;
        this.shortStringHelper = shortStringHelper;
        this.jsonSerializer = jsonSerializer;
    }

    public IDataValueEditor GetValueEditor()
    {
        return GetValueEditor(null);
    }

    public IDataValueEditor GetValueEditor(object? configuration)
    {
        return new MyDataValueEditor(
            localizedTextService,
            shortStringHelper,
            jsonSerializer
        )
        {
            ValueType = ValueTypes.Json,
            View = PreviewPath
        };
    }

    public IConfigurationEditor GetConfigurationEditor()
    {
        return new ConfigurationEditor();
    }

    public string Alias => "my.editor";
    public string Name => "My editor";
    public EditorType Type => EditorType.PropertyValue;
    public string Icon => "icon-user";
    public string Group => Constants.PropertyEditors.Groups.Common;
    public bool IsDeprecated => false;
    public IDictionary<string, object>? DefaultConfiguration => new Dictionary<string, object>();
    public IPropertyIndexValueFactory PropertyIndexValueFactory => new DefaultPropertyIndexValueFactory();

}

public class MyDataValueEditor : DataValueEditor
{
    public MyDataValueEditor(ILocalizedTextService localizedTextService, IShortStringHelper shortStringHelper, IJsonSerializer jsonSerializer)
        : base(localizedTextService, shortStringHelper, jsonSerializer)
    {
    }

    public override object? ToEditor(IProperty property, string? culture = null, string? segment = null)
    {
        var value = property.GetValue(culture, segment) as string;
        var jObj = JObject.Parse(value ?? "{}");
        if (!jObj.ContainsKey("dataForBackoffice"))
        {
            jObj["dataForBackoffice"] = "Some extra data for the view";
        }

        return jObj;
    }

    public override object? FromEditor(ContentPropertyData editorValue, object? currentValue)
    {
        var value = editorValue.Value as string;
        var jObj = JObject.Parse(value ?? "{}");
        if (jObj.ContainsKey("dataForBackoffice"))
        {
            jObj.Remove("dataForBackoffice");
        }

        return jObj.ToString();
    }
}