Model fixes

src/Squidex.Core/Contents/ContentData.cs

@@ -8,7 +8,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
 using Newtonsoft.Json.Linq;
 using Squidex.Core.Schemas;
@@ -16,39 +15,67 @@ using Squidex.Infrastructure;
 
 namespace Squidex.Core.Contents
 {
-    public sealed class ContentData
+    public sealed class ContentData : Dictionary<string, ContentFieldData>
     {
-        private readonly ImmutableDictionary<string, ContentFieldData> fields;
+        public ContentData()
-
+            : base(StringComparer.OrdinalIgnoreCase)
-        public static readonly ContentData Empty = new ContentData(ImmutableDictionary<string, ContentFieldData>.Empty.WithComparers (StringComparer.OrdinalIgnoreCase));
-
-        public ImmutableDictionary<string, ContentFieldData> Fields
         {
-            get { return fields; }
         }
 
-        public ContentData(ImmutableDictionary<string, ContentFieldData> fields)
+        public ContentData AddField(string fieldName, ContentFieldData data)
         {
-            Guard.NotNull(fields, nameof(fields));
+            Guard.ValidPropertyName(fieldName, nameof(fieldName));
 
-            this.fields = fields;
+            this[fieldName] = data;
+
+            return this;
         }
 
-        public ContentData AddField(string fieldName, ContentFieldData data)
+        public ContentData ToNameModel(Schema schema)
         {
-            Guard.ValidPropertyName(fieldName, nameof(fieldName));
+            Guard.NotNull(schema, nameof(schema));
+
+            var result = new ContentData();
+
+            foreach (var fieldValue in this)
+            {
+                var fieldId = 0L;
+
+                Field field;
+
+                if (!long.TryParse(fieldValue.Key, out fieldId) || !schema.Fields.TryGetValue(fieldId, out field))
+                {
+                    continue;
+                }
+
+                result[field.Name] = fieldValue.Value;
+            }
 
-            return new ContentData(Fields.Add(fieldName, data));
+            return result;
         }
 
-        public static ContentData FromApiRequest(Dictionary<string, Dictionary<string, JToken>> request)
+        public ContentData ToIdModel(Schema schema)
         {
-            Guard.NotNull(request, nameof(request));
+            Guard.NotNull(schema, nameof(schema));
+
+            var result = new ContentData();
+
+            foreach (var fieldValue in this)
+            {
+                Field field;
+
+                if (!schema.FieldsByName.TryGetValue(fieldValue.Key, out field))
+                {
+                    continue;
+                }
+
+                result[field.Id.ToString()] = fieldValue.Value;
+            }
 
-            return new ContentData(request.ToImmutableDictionary(x => x.Key, x => new ContentFieldData(x.Value.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase)), StringComparer.OrdinalIgnoreCase));
+            return result;
         }
 
-        public Dictionary<string, Dictionary<string, JToken>> ToApiResponse(Schema schema, IReadOnlyCollection<Language> languages, Language masterLanguage, bool excludeHidden = true)
+        public ContentData ToApiModel(Schema schema, IReadOnlyCollection<Language> languages, Language masterLanguage, bool excludeHidden = true)
         {
             Guard.NotNull(schema, nameof(schema));
             Guard.NotNull(languages, nameof(languages));
@@ -56,9 +83,9 @@ namespace Squidex.Core.Contents
 
             var invariantCode = Language.Invariant.Iso2Code;
 
-            var result = new Dictionary<string, Dictionary<string, JToken>>();
+            var result = new ContentData();
 
-            foreach (var fieldValue in fields)
+            foreach (var fieldValue in this)
             {
                 Field field;
                 
@@ -67,8 +94,8 @@ namespace Squidex.Core.Contents
                     continue;
                 }
 
-                var fieldResult = new Dictionary<string, JToken>();
+                var fieldResult = new ContentFieldData();
-                var fieldValues = fieldValue.Value.ValueByLanguage;
+                var fieldValues = fieldValue.Value;
 
                 if (field.RawProperties.IsLocalizable)
                 {

src/Squidex.Core/Contents/ContentFieldData.cs

@@ -7,40 +7,33 @@
 // ==========================================================================
 
 using System;
-using System.Collections.Immutable;
+using System.Collections.Generic;
 using Newtonsoft.Json.Linq;
 using Squidex.Infrastructure;
 
 namespace Squidex.Core.Contents
 {
-    public sealed class ContentFieldData
+    public sealed class ContentFieldData : Dictionary<string, JToken>
     {
-        private readonly ImmutableDictionary<string, JToken> valueByLanguage;
+        public ContentFieldData()
-
+            : base(StringComparer.OrdinalIgnoreCase)
-        public static readonly ContentFieldData Empty = new ContentFieldData(ImmutableDictionary<string, JToken>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase));
-
-        public ImmutableDictionary<string, JToken> ValueByLanguage
         {
-            get { return valueByLanguage; }
         }
 
-        public ContentFieldData(ImmutableDictionary<string, JToken> valueByLanguage)
+        public ContentFieldData SetValue(JToken value)
         {
-            Guard.NotNull(valueByLanguage, nameof(valueByLanguage));
+            this["iv"] = value;
-
-            this.valueByLanguage = valueByLanguage;
-        }
 
-        public ContentFieldData AddValue(JToken value)
+            return this;
-        {
-            return new ContentFieldData(valueByLanguage.Add("iv", value));
         }
 
         public ContentFieldData AddValue(string language, JToken value)
         {
             Guard.NotNullOrEmpty(language, nameof(language));
 
-            return new ContentFieldData(valueByLanguage.Add(language, value));
+            this[language] = value;
+
+            return this;
         }
     }
 }

src/Squidex.Core/Schemas/Schema.cs

@@ -15,8 +15,8 @@ using Newtonsoft.Json.Linq;
 using NJsonSchema;
 using Squidex.Core.Contents;
 using Squidex.Infrastructure;
-// ReSharper disable ConvertIfStatementToConditionalTernaryExpression
 
+// ReSharper disable ConvertIfStatementToConditionalTernaryExpression
 // ReSharper disable InvertIf
 
 namespace Squidex.Core.Schemas
@@ -194,7 +194,7 @@ namespace Squidex.Core.Schemas
             Guard.NotNull(errors, nameof(errors));
             Guard.NotEmpty(languages, nameof(languages));
 
-            foreach (var fieldValue in data.Fields)
+            foreach (var fieldValue in data)
             {
                 if (!fieldsByName.ContainsKey(fieldValue.Key))
                 {
@@ -206,11 +206,11 @@ namespace Squidex.Core.Schemas
             {
                 var fieldErrors = new List<string>();
 
-                var fieldData = data.Fields.GetOrDefault(field.Name) ?? ContentFieldData.Empty;
+                var fieldData = data.GetOrDefault(field.Name) ?? new ContentFieldData();
                 
                 if (field.RawProperties.IsLocalizable)
                 {
-                    foreach (var valueLanguage in fieldData.ValueByLanguage.Keys)
+                    foreach (var valueLanguage in fieldData.Keys)
                     {
                         Language language;
 
@@ -226,19 +226,19 @@ namespace Squidex.Core.Schemas
 
                     foreach (var language in languages)
                     {
-                        var value = fieldData.ValueByLanguage.GetValueOrDefault(language.Iso2Code, JValue.CreateNull());
+                        var value = fieldData.GetOrCreate(language.Iso2Code, k => JValue.CreateNull());
 
                         await field.ValidateAsync(value, fieldErrors, language);
                     }
                 }
                 else
                 {
-                    if (fieldData.ValueByLanguage.Keys.Any(x => x != "iv"))
+                    if (fieldData.Keys.Any(x => x != "iv"))
                     {
                         fieldErrors.Add($"{field.Name} can only contain a single entry for invariant language (iv)");
                     }
 
-                    var value = fieldData.ValueByLanguage.GetValueOrDefault("iv", JValue.CreateNull());
+                    var value = fieldData.GetOrCreate("iv", k => JValue.CreateNull());
 
                     await field.ValidateAsync(value, fieldErrors);
                 }

src/Squidex.Store.MongoDb/Contents/MongoContentEntity.cs

@@ -14,16 +14,18 @@ using MongoDB.Bson.Serialization.Attributes;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Squidex.Core.Contents;
+using Squidex.Core.Schemas;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.MongoDb;
 using Squidex.Read.Contents;
+
+// ReSharper disable ConvertIfStatementToConditionalTernaryExpression
 // ReSharper disable InvertIf
 
 namespace Squidex.Store.MongoDb.Contents
 {
     public sealed class MongoContentEntity : MongoEntity, IContentEntity
     {
-        private BsonDocument data;
         private ContentData contentData;
 
         [BsonRequired]
@@ -52,40 +54,37 @@ namespace Squidex.Store.MongoDb.Contents
 
         [BsonRequired]
         [BsonElement]
-        public BsonDocument Data
+        public BsonDocument Data { get; set; }
-        {
-            get { return data; }
-            set
-            {
-                data = value;
-
-                contentData = null;
-            }
-        }
 
         ContentData IContentEntity.Data
         {
             get
             {
-                if (contentData == null)
-                {
-                    if (data != null)
-                    {
-                        contentData = JsonConvert.DeserializeObject<ContentData>(data.ToJson());
-                    }
-                }
-
                 return contentData;
             }
         }
 
-        public void SetData(ContentData newContentData)
+        public void ParseData(Schema schema)
         {
-            data = null;
+            if (Data != null)
+            {
+                contentData = JsonConvert.DeserializeObject<ContentData>(Data.ToJson()).ToNameModel(schema);
+            }
+            else
+            {
+                contentData = null;
+            }
+        }
 
+        public void SetData(Schema schema, ContentData newContentData)
+        {
             if (newContentData != null)
             {
-                data = BsonDocument.Parse(JsonConvert.SerializeObject(newContentData));
+                Data = BsonDocument.Parse(JsonConvert.SerializeObject(newContentData.ToIdModel(schema)));
+            }
+            else
+            {
+                Data = null;
             }
 
             Text = ExtractText(newContentData);
@@ -99,7 +98,7 @@ namespace Squidex.Store.MongoDb.Contents
             }
             var stringBuilder = new StringBuilder();
 
-            foreach (var text in data.Fields.Values.SelectMany(x => x.ValueByLanguage.Values).Where(x => x != null).OfType<JValue>())
+            foreach (var text in data.Values.SelectMany(x => x.Values).Where(x => x != null).OfType<JValue>())
             {
                 if (text.Type == JTokenType.String)
                 {

src/Squidex.Store.MongoDb/Contents/MongoContentRepository.cs

@@ -10,7 +10,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using MongoDB.Bson;
 using MongoDB.Driver;
+using Squidex.Core.Schemas;
 using Squidex.Events;
 using Squidex.Events.Contents;
 using Squidex.Events.Schemas;
@@ -22,6 +24,7 @@ using Squidex.Infrastructure.Dispatching;
 using Squidex.Infrastructure.Reflection;
 using Squidex.Read.Contents;
 using Squidex.Read.Contents.Repositories;
+using Squidex.Read.Schemas.Services;
 using Squidex.Store.MongoDb.Utils;
 
 namespace Squidex.Store.MongoDb.Contents
@@ -30,6 +33,7 @@ namespace Squidex.Store.MongoDb.Contents
     {
         private const string Prefix = "Projections_Content_";
         private readonly IMongoDatabase database;
+        private readonly ISchemaProvider schemaProvider;
 
         protected ProjectionDefinitionBuilder<MongoContentEntity> Projection
         {
@@ -71,11 +75,14 @@ namespace Squidex.Store.MongoDb.Contents
             }
         }
 
-        public MongoContentRepository(IMongoDatabase database)
+        public MongoContentRepository(IMongoDatabase database, ISchemaProvider schemaProvider)
         {
             Guard.NotNull(database, nameof(database));
+            Guard.NotNull(schemaProvider, nameof(schemaProvider));
 
             this.database = database;
+
+            this.schemaProvider = schemaProvider;
         }
 
         public async Task ClearAsync()
@@ -113,8 +120,19 @@ namespace Squidex.Store.MongoDb.Contents
 
             cursor.SortByDescending(x => x.LastModified);
 
-            var entities = 
+            var schemaEntity = await schemaProvider.FindSchemaByIdAsync(schemaId);
-                await cursor.ToListAsync();
+
+            if (schemaEntity == null)
+            {
+                return new List<IContentEntity>();
+            }
+
+            var entities = await cursor.ToListAsync();
+
+            foreach (var entity in entities)
+            {
+                entity.ParseData(schemaEntity.Schema);
+            }
 
             return entities.OfType<IContentEntity>().ToList();
         }
@@ -154,64 +172,89 @@ namespace Squidex.Store.MongoDb.Contents
         {
             var collection = GetCollection(schemaId);
 
-            var entity = 
+            var entity = await collection.Find(x => x.Id == id).FirstOrDefaultAsync();
-                await collection.Find(x => x.Id == id).FirstOrDefaultAsync();
+
+            if (entity == null)
+            {
+                return null;
+            }
+
+            var schemaEntity = await schemaProvider.FindSchemaByIdAsync(schemaId);
+
+            if (schemaEntity == null)
+            {
+                return null;
+            }
+
+            entity.ParseData(schemaEntity.Schema);
 
             return entity;
         }
 
         protected Task On(ContentCreated @event, EnvelopeHeaders headers)
         {
-            var collection = GetCollection(headers.SchemaId());
+            return ForSchemaAsync(headers, (collection, schema) =>
-
-            return collection.CreateAsync(headers, x =>
             {
-                SimpleMapper.Map(@event, x);
+                return collection.CreateAsync(headers, x =>
+                {
+                    SimpleMapper.Map(@event, x);
 
-                x.SetData(@event.Data);
+                    x.SetData(schema, @event.Data);
+                });
             });
         }
 
         protected Task On(ContentUpdated @event, EnvelopeHeaders headers)
         {
-            var collection = GetCollection(headers.SchemaId());
+            return ForSchemaAsync(headers, (collection, schema) =>
-
-            return collection.UpdateAsync(headers, x =>
             {
-                x.SetData(@event.Data);
+                return collection.UpdateAsync(headers, x =>
+                {
+                    x.SetData(schema, @event.Data);
+                });
             });
         }
 
         protected Task On(ContentPublished @event, EnvelopeHeaders headers)
         {
-            var collection = GetCollection(headers.SchemaId());
+            return ForSchemaAsync(headers, collection =>
-
-            return collection.UpdateAsync(headers, x =>
             {
-                x.IsPublished = true;
+                return collection.UpdateAsync(headers, x =>
+                {
+                    x.IsPublished = true;
+                });
             });
         }
 
         protected Task On(ContentUnpublished @event, EnvelopeHeaders headers)
         {
-            var collection = GetCollection(headers.SchemaId());
+            return ForSchemaAsync(headers, collection =>
-
-            return collection.UpdateAsync(headers, x =>
             {
-                x.IsPublished = false;
+                return collection.UpdateAsync(headers, x =>
+                {
+                    x.IsPublished = false;
+                });
             });
         }
 
         protected Task On(ContentDeleted @event, EnvelopeHeaders headers)
         {
-            var collection = GetCollection(headers.SchemaId());
+            return ForSchemaAsync(headers, collection =>
-
-            return collection.UpdateAsync(headers, x =>
             {
-                x.IsDeleted = true;
+                return collection.UpdateAsync(headers, x =>
+                {
+                    x.IsDeleted = true;
+                });
             });
         }
 
+        protected Task On(FieldDeleted @event, EnvelopeHeaders headers)
+        {
+            var collection = GetCollection(headers.SchemaId());
+
+            return collection.UpdateManyAsync(new BsonDocument(), Update.Unset(new StringFieldDefinition<MongoContentEntity>($"Data.{@event.FieldId}")));
+        }
+
         protected Task On(SchemaCreated @event, EnvelopeHeaders headers)
         {
             var collection = GetCollection(headers.AggregateId());
@@ -224,6 +267,27 @@ namespace Squidex.Store.MongoDb.Contents
             return this.DispatchActionAsync(@event.Payload, @event.Headers);
         }
 
+        private async Task ForSchemaAsync(EnvelopeHeaders headers, Func<IMongoCollection<MongoContentEntity>, Schema, Task> action)
+        {
+            var collection = GetCollection(headers.SchemaId());
+
+            var schemaEntity = await schemaProvider.FindSchemaByIdAsync(headers.SchemaId());
+
+            if (schemaEntity == null)
+            {
+                return;
+            }
+
+            await action(collection, schemaEntity.Schema);
+        }
+
+        private async Task ForSchemaAsync(EnvelopeHeaders headers, Func<IMongoCollection<MongoContentEntity>, Task> action)
+        {
+            var collection = GetCollection(headers.SchemaId());
+
+            await action(collection);
+        }
+
         private IMongoCollection<MongoContentEntity> GetCollection(Guid schemaId)
         {
             var name = $"{Prefix}{schemaId}";

src/Squidex/Controllers/ContentApi/ContentsController.cs

@@ -65,7 +65,7 @@ namespace Squidex.Controllers.ContentApi
 
                     if (x.Data != null)
                     {
-                        itemModel.Data = x.Data.ToApiResponse(schemaEntity.Schema, App.Languages, App.MasterLanguage);
+                        itemModel.Data = x.Data.ToApiModel(schemaEntity.Schema, App.Languages, App.MasterLanguage);
                     }
 
                     return itemModel;
@@ -97,7 +97,7 @@ namespace Squidex.Controllers.ContentApi
 
             if (content.Data != null)
             {
-                model.Data = content.Data.ToApiResponse(schemaEntity.Schema, App.Languages, App.MasterLanguage, hidden);
+                model.Data = content.Data.ToApiModel(schemaEntity.Schema, App.Languages, App.MasterLanguage, hidden);
             }
 
             return Ok(model);
@@ -105,9 +105,9 @@ namespace Squidex.Controllers.ContentApi
 
         [HttpPost]
         [Route("content/{app}/{name}/")]
-        public async Task<IActionResult> PostContent([FromBody] Dictionary<string, Dictionary<string, JToken>> request)
+        public async Task<IActionResult> PostContent([FromBody] ContentData request)
         {
-            var command = new CreateContent { Data = ContentData.FromApiRequest(request), AggregateId = Guid.NewGuid() };
+            var command = new CreateContent { Data = request, AggregateId = Guid.NewGuid() };
 
             var context = await CommandBus.PublishAsync(command);
             var result = context.Result<Guid>();
@@ -117,9 +117,9 @@ namespace Squidex.Controllers.ContentApi
 
         [HttpPut]
         [Route("content/{app}/{name}/{id}")]
-        public async Task<IActionResult> PutContent(Guid id, [FromBody] Dictionary<string, Dictionary<string, JToken>> request)
+        public async Task<IActionResult> PutContent(Guid id, [FromBody] ContentData request)
         {
-            var command = new UpdateContent { AggregateId = id, Data = ContentData.FromApiRequest(request) };
+            var command = new UpdateContent { AggregateId = id, Data = request };
 
             await CommandBus.PublishAsync(command);
 

src/Squidex/Controllers/ContentApi/Models/ContentDto.cs

@@ -7,9 +7,8 @@
 // ==========================================================================
 
 using System;
-using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
-using Newtonsoft.Json.Linq;
+using Squidex.Core.Contents;
 using Squidex.Infrastructure;
 
 namespace Squidex.Controllers.ContentApi.Models
@@ -37,7 +36,7 @@ namespace Squidex.Controllers.ContentApi.Models
         /// The data of the content item.
         /// </summary>
         [Required]
-        public Dictionary<string, Dictionary<string, JToken>> Data { get; set; }
+        public ContentData Data { get; set; }
 
         /// <summary>
         /// The date and time when the content element has been created.

tests/Squidex.Core.Tests/Contents/ContentDataTests.cs

@@ -30,38 +30,59 @@ namespace Squidex.Core.Contents
         private readonly Language masterLanguage = Language.GetLanguage("en");
 
         [Fact]
-        public void Should_convert_from_dictionary()
+        public void Should_convert_to_id_model()
         {
             var input =
-                new Dictionary<string, Dictionary<string, JToken>>
+               new ContentData()
-                {
+                    .AddField("field1",
-                    ["field1"] = new Dictionary<string, JToken>
+                        new ContentFieldData()
-                    {
+                            .AddValue("en", "en_string")
-                        ["en"] = "en_string",
+                            .AddValue("de", "de_string"))
-                        ["de"] = "de_string"
+                    .AddField("field2",
-                    },
+                        new ContentFieldData()
-                    ["field2"] = new Dictionary<string, JToken>
+                            .AddValue("iv", 3));
-                    {
-                        ["iv"] = 3
-                    }
-                };
 
-            var actual = ContentData.FromApiRequest(input);
+            var actual = input.ToIdModel(schema);
 
             var expected =
-                ContentData.Empty
+                new ContentData()
+                    .AddField("1",
+                        new ContentFieldData()
+                            .AddValue("en", "en_string")
+                            .AddValue("de", "de_string"))
+                    .AddField("2",
+                        new ContentFieldData()
+                            .AddValue("iv", 3));
+            
+            actual.ShouldBeEquivalentTo(expected);
+        }
+
+        [Fact]
+        public void Should_convert_to_from_id_model()
+        {
+            var input =
+               new ContentData()
+                    .AddField("1",
+                        new ContentFieldData()
+                            .AddValue("en", "en_string")
+                            .AddValue("de", "de_string"))
+                    .AddField("2",
+                        new ContentFieldData()
+                            .AddValue("iv", 3));
+
+            var actual = input.ToNameModel(schema);
+
+            var expected =
+                new ContentData()
                     .AddField("field1",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("en", "en_string")
                             .AddValue("de", "de_string"))
                     .AddField("field2",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("iv", 3));
 
-            var output = actual.ToApiResponse(schema, languages, masterLanguage);
-
             actual.ShouldBeEquivalentTo(expected);
-            output.ShouldBeEquivalentTo(input);
         }
 
         [Fact]
@@ -78,16 +99,16 @@ namespace Squidex.Core.Contents
                 };
 
             var input =
-                ContentData.Empty
+                new ContentData()
                     .AddField("field0",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("en", "en_string"))
                     .AddField("field1",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("en", "en_string")
                             .AddValue("de", "de_string"));
 
-            var output = input.ToApiResponse(schema, languages, masterLanguage);
+            var output = input.ToApiModel(schema, languages, masterLanguage);
 
             output.ShouldBeEquivalentTo(expected);
         }
@@ -106,14 +127,14 @@ namespace Squidex.Core.Contents
                 };
 
             var input =
-                ContentData.Empty
+                new ContentData()
                     .AddField("field1",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("en", "en_string")
                             .AddValue("de", "de_string")
                             .AddValue("it", "it_string"));
 
-            var output = input.ToApiResponse(schema, languages, masterLanguage);
+            var output = input.ToApiModel(schema, languages, masterLanguage);
 
             output.ShouldBeEquivalentTo(expected);
         }
@@ -131,13 +152,13 @@ namespace Squidex.Core.Contents
                 };
 
             var input =
-                ContentData.Empty
+                new ContentData()
                     .AddField("field2",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("de", 2)
                             .AddValue("en", 3));
 
-            var output = input.ToApiResponse(schema, languages, masterLanguage);
+            var output = input.ToApiModel(schema, languages, masterLanguage);
 
             output.ShouldBeEquivalentTo(expected);
         }
@@ -155,13 +176,13 @@ namespace Squidex.Core.Contents
                 };
 
             var input =
-                ContentData.Empty
+                new ContentData()
                     .AddField("field2",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("de", 2)
                             .AddValue("it", 3));
 
-            var output = input.ToApiResponse(schema, languages, masterLanguage);
+            var output = input.ToApiModel(schema, languages, masterLanguage);
 
             output.ShouldBeEquivalentTo(expected);
         }
@@ -179,15 +200,15 @@ namespace Squidex.Core.Contents
                 };
 
             var input =
-                ContentData.Empty
+                new ContentData()
                     .AddField("field2",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("iv", 2))
                     .AddField("field3",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("iv", 2));
 
-            var output = input.ToApiResponse(schema, languages, masterLanguage);
+            var output = input.ToApiModel(schema, languages, masterLanguage);
 
             output.ShouldBeEquivalentTo(expected);
         }

tests/Squidex.Core.Tests/Schemas/SchemaValidationTests.cs

@@ -25,9 +25,9 @@ namespace Squidex.Core.Schemas
         public async Task Should_add_error_if_validating_data_with_unknown_field()
         {
             var data =
-                ContentData.Empty
+                new ContentData()
                     .AddField("unknown",
-                        ContentFieldData.Empty);
+                        new ContentFieldData());
 
             await sut.ValidateAsync(data, errors, languages);
 
@@ -44,10 +44,10 @@ namespace Squidex.Core.Schemas
             sut = sut.AddOrUpdateField(new NumberField(1, "my-field", new NumberFieldProperties { MaxValue = 100 }));
 
             var data =
-                ContentData.Empty
+                new ContentData()
                     .AddField("my-field",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
-                            .AddValue(1000));
+                            .SetValue(1000));
 
             await sut.ValidateAsync(data, errors, languages);
 
@@ -64,9 +64,9 @@ namespace Squidex.Core.Schemas
             sut = sut.AddOrUpdateField(new NumberField(1, "my-field", new NumberFieldProperties()));
 
             var data =
-                ContentData.Empty
+                new ContentData()
                     .AddField("my-field",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("es", 1)
                             .AddValue("it", 1));
 
@@ -85,7 +85,7 @@ namespace Squidex.Core.Schemas
             sut = sut.AddOrUpdateField(new NumberField(1, "my-field", new NumberFieldProperties { IsRequired = true, IsLocalizable = true }));
 
             var data =
-                ContentData.Empty;
+                new ContentData();
 
             await sut.ValidateAsync(data, errors, languages);
 
@@ -103,7 +103,7 @@ namespace Squidex.Core.Schemas
             sut = sut.AddOrUpdateField(new NumberField(1, "my-field", new NumberFieldProperties { IsRequired = true }));
 
             var data =
-                ContentData.Empty;
+                new ContentData();
 
             await sut.ValidateAsync(data, errors, languages);
 
@@ -120,9 +120,9 @@ namespace Squidex.Core.Schemas
             sut = sut.AddOrUpdateField(new NumberField(1, "my-field", new NumberFieldProperties { IsLocalizable = true }));
 
             var data =
-                ContentData.Empty
+                new ContentData()
                     .AddField("my-field",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("de", 1)
                             .AddValue("xx", 1));
 
@@ -141,9 +141,9 @@ namespace Squidex.Core.Schemas
             sut = sut.AddOrUpdateField(new NumberField(1, "my-field", new NumberFieldProperties { IsLocalizable = true }));
 
             var data =
-                ContentData.Empty
+                new ContentData()
                     .AddField("my-field",
-                        ContentFieldData.Empty
+                        new ContentFieldData()
                             .AddValue("es", 1)
                             .AddValue("it", 1));
 

tests/Squidex.Write.Tests/Contents/ContentCommandHandlerTests.cs

@@ -35,7 +35,7 @@ namespace Squidex.Write.Contents
         private readonly Mock<IAppEntity> appEntity = new Mock<IAppEntity>();
         private readonly Guid schemaId = Guid.NewGuid();
         private readonly Guid appId = Guid.NewGuid();
-        private readonly ContentData data = ContentData.Empty.AddField("my-field", ContentFieldData.Empty.AddValue(1));
+        private readonly ContentData data = new ContentData().AddField("my-field", new ContentFieldData().SetValue(1));
 
         public ContentCommandHandlerTests()
         {
@@ -58,7 +58,7 @@ namespace Squidex.Write.Contents
         [Fact]
         public async Task Create_should_throw_exception_if_data_is_not_valid()
         {
-            var command = new CreateContent { AggregateId = Id, AppId = appId, SchemaId = schemaId, Data = ContentData.Empty };
+            var command = new CreateContent { AggregateId = Id, AppId = appId, SchemaId = schemaId, Data = new ContentData() };
             var context = new CommandContext(command);
 
             await TestCreate(content, async _ =>
@@ -86,7 +86,7 @@ namespace Squidex.Write.Contents
         {
             CreateContent();
 
-            var command = new UpdateContent { AggregateId = Id, AppId = appId, SchemaId = schemaId, Data = ContentData.Empty };
+            var command = new UpdateContent { AggregateId = Id, AppId = appId, SchemaId = schemaId, Data = new ContentData() };
             var context = new CommandContext(command);
 
             await TestUpdate(content, async _ =>

tests/Squidex.Write.Tests/Contents/ContentDomainObjectTests.cs

@@ -26,7 +26,7 @@ namespace Squidex.Write.Contents
     {
         private readonly Guid appId = Guid.NewGuid();
         private readonly ContentDomainObject sut;
-        private readonly ContentData data = ContentData.Empty;
+        private readonly ContentData data = new ContentData();
 
         public ContentDomainObjectTests()
         {