Naming improved.

backend/src/Squidex.Domain.Apps.Entities/Assets/AssetCommandMiddleware.cs

@@ -58,7 +58,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
 
                         try
                         {
-                            var ctx = contextProvider.Context.Clone().WithNoAssetEnrichment();
+                            var ctx = contextProvider.Context.Clone().WithoutAssetEnrichment();
 
                             var existings = await assetQuery.QueryByHashAsync(ctx, createAsset.AppId.Id, createAsset.FileHash);
 

backend/src/Squidex.Domain.Apps.Entities/Assets/AssetExtensions.cs

@@ -11,12 +11,12 @@ namespace Squidex.Domain.Apps.Entities.Assets
     {
         private const string HeaderNoEnrichment = "X-NoAssetEnrichment";
 
-        public static bool IsNoAssetEnrichment(this Context context)
+        public static bool ShouldEnrichAsset(this Context context)
         {
-            return context.Headers.ContainsKey(HeaderNoEnrichment);
+            return !context.Headers.ContainsKey(HeaderNoEnrichment);
         }
 
-        public static Context WithNoAssetEnrichment(this Context context, bool value = true)
+        public static Context WithoutAssetEnrichment(this Context context, bool value = true)
         {
             if (value)
             {

backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetEnricher.cs

@@ -128,7 +128,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
 
         private static bool ShouldEnrich(Context context)
         {
-            return !context.IsNoAssetEnrichment();
+            return context.ShouldEnrichAsset();
         }
     }
 }

backend/src/Squidex.Domain.Apps.Entities/Contents/ContextExtensions.cs

@@ -21,101 +21,67 @@ namespace Squidex.Domain.Apps.Entities.Contents
         private const string HeaderResolveAssetUrls = "X-Resolve-Urls";
         private const string HeaderNoResolveLanguages = "X-NoResolveLanguages";
         private const string HeaderNoEnrichment = "X-NoEnrichment";
+        private const string HeaderNoCleanup = "X-NoCleanup";
         private static readonly char[] Separators = { ',', ';' };
 
-        public static bool IsNoEnrichment(this Context context)
+        public static bool ShouldCleanup(this Context context)
         {
-            return context.Headers.ContainsKey(HeaderNoEnrichment);
+            return !context.Headers.ContainsKey(HeaderNoCleanup);
         }
 
-        public static Context WithoutContentEnrichment(this Context context, bool value = true)
+        public static Context WithoutCleanup(this Context context, bool value = true)
         {
-            if (value)
-            {
-                context.Headers[HeaderNoEnrichment] = "1";
-            }
-            else
-            {
-                context.Headers.Remove(HeaderNoEnrichment);
-            }
+            return SetBoolean(context, HeaderNoCleanup, value);
+        }
 
-            return context;
+        public static bool ShouldEnrichContent(this Context context)
+        {
+            return !context.Headers.ContainsKey(HeaderNoEnrichment);
         }
 
-        public static bool IsUnpublished(this Context context)
+        public static Context WithoutContentEnrichment(this Context context, bool value = true)
+        {
+            return SetBoolean(context, HeaderNoEnrichment, value);
+        }
+
+        public static bool ShouldProvideUnpublished(this Context context)
         {
             return context.Headers.ContainsKey(HeaderUnpublished);
         }
 
         public static Context WithUnpublished(this Context context, bool value = true)
         {
-            if (value)
-            {
-                context.Headers[HeaderUnpublished] = "1";
-            }
-            else
-            {
-                context.Headers.Remove(HeaderUnpublished);
-            }
-
-            return context;
+            return SetBoolean(context, HeaderUnpublished, value);
         }
 
-        public static bool IsFlatten(this Context context)
+        public static bool ShouldFlatten(this Context context)
         {
             return context.Headers.ContainsKey(HeaderFlatten);
         }
 
         public static Context WithFlatten(this Context context, bool value = true)
         {
-            if (value)
-            {
-                context.Headers[HeaderFlatten] = "1";
-            }
-            else
-            {
-                context.Headers.Remove(HeaderFlatten);
-            }
-
-            return context;
+            return SetBoolean(context, HeaderFlatten, value);
         }
 
-        public static bool IsResolveFlow(this Context context)
+        public static bool ShouldResolveFlow(this Context context)
         {
             return context.Headers.ContainsKey(HeaderResolveFlow);
         }
 
         public static Context WithResolveFlow(this Context context, bool value = true)
         {
-            if (value)
-            {
-                context.Headers[HeaderResolveFlow] = "1";
-            }
-            else
-            {
-                context.Headers.Remove(HeaderResolveFlow);
-            }
-
-            return context;
+            return SetBoolean(context, HeaderResolveFlow, value);
         }
 
-        public static bool IsNoResolveLanguages(this Context context)
+        public static bool ShouldResolveLanguages(this Context context)
         {
-            return context.Headers.ContainsKey(HeaderNoResolveLanguages);
+            return !context.Headers.ContainsKey(HeaderNoResolveLanguages);
         }
 
         public static Context WithoutResolveLanguages(this Context context, bool value = true)
         {
-            if (value)
-            {
-                context.Headers[HeaderNoResolveLanguages] = "1";
-            }
-            else
-            {
-                context.Headers.Remove(HeaderNoResolveLanguages);
-            }
-
-            return context;
+            return SetBoolean(context, HeaderNoResolveLanguages, value);
         }
 
         public static IEnumerable<string> AssetUrls(this Context context)
@@ -175,5 +141,19 @@ namespace Squidex.Domain.Apps.Entities.Contents
 
             return context;
         }
+
+        private static Context SetBoolean(Context context, string key, bool value)
+        {
+            if (value)
+            {
+                context.Headers[key] = "1";
+            }
+            else
+            {
+                context.Headers.Remove(key);
+            }
+
+            return context;
+        }
     }
 }

backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentQueryService.cs

@@ -229,7 +229,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
 
         private static Status[]? GetStatus(Context context)
         {
-            if (context.IsFrontendClient || context.IsUnpublished())
+            if (context.IsFrontendClient || context.ShouldProvideUnpublished())
             {
                 return null;
             }
@@ -280,7 +280,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
 
         private static bool WithDraft(Context context)
         {
-            return context.IsUnpublished() || context.IsFrontendClient;
+            return context.ShouldProvideUnpublished() || context.IsFrontendClient;
         }
     }
 }

backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/Steps/ConvertData.cs

@@ -36,7 +36,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries.Steps
 
         public async Task EnrichAsync(Context context, IEnumerable<ContentEntity> contents, ProvideSchema schemas)
         {
-            var resolveDataDraft = context.IsUnpublished() || context.IsFrontendClient;
+            var resolveDataDraft = context.ShouldProvideUnpublished() || context.IsFrontendClient;
 
             var referenceCleaner = await CleanReferencesAsync(context, contents, schemas);
 
@@ -67,29 +67,32 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries.Steps
 
         private async Task<ValueConverter?> CleanReferencesAsync(Context context, IEnumerable<ContentEntity> contents, ProvideSchema schemas)
         {
-            var ids = new HashSet<Guid>();
-
-            foreach (var group in contents.GroupBy(x => x.SchemaId.Id))
+            if (context.ShouldCleanup())
             {
-                var schema = await schemas(group.Key);
+                var ids = new HashSet<Guid>();
 
-                foreach (var content in group)
+                foreach (var group in contents.GroupBy(x => x.SchemaId.Id))
                 {
-                    content.Data?.AddReferencedIds(schema.SchemaDef, ids);
-                    content.DataDraft?.AddReferencedIds(schema.SchemaDef, ids);
+                    var schema = await schemas(group.Key);
+
+                    foreach (var content in group)
+                    {
+                        content.Data?.AddReferencedIds(schema.SchemaDef, ids);
+                        content.DataDraft?.AddReferencedIds(schema.SchemaDef, ids);
+                    }
                 }
-            }
 
-            if (ids.Count > 0)
-            {
-                var taskForAssets = QueryAssetIdsAsync(context, ids);
-                var taskForContents = QueryContentIdsAsync(context, ids);
+                if (ids.Count > 0)
+                {
+                    var taskForAssets = QueryAssetIdsAsync(context, ids);
+                    var taskForContents = QueryContentIdsAsync(context, ids);
 
-                await Task.WhenAll(taskForAssets, taskForContents);
+                    await Task.WhenAll(taskForAssets, taskForContents);
 
-                var foundIds = new HashSet<Guid>(taskForAssets.Result.Union(taskForContents.Result));
+                    var foundIds = new HashSet<Guid>(taskForAssets.Result.Union(taskForContents.Result));
 
-                return ValueReferencesConverter.CleanReferences(foundIds);
+                    return ValueReferencesConverter.CleanReferences(foundIds);
+                }
             }
 
             return null;
@@ -131,7 +134,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries.Steps
 
             if (!context.IsFrontendClient)
             {
-                if (!context.IsNoResolveLanguages())
+                if (context.ShouldResolveLanguages())
                 {
                     yield return FieldConverters.ResolveFallbackLanguages(context.App.LanguagesConfig);
                 }

backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/Steps/EnrichWithWorkflows.cs

@@ -76,7 +76,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries.Steps
 
         private static bool ShouldEnrichWithStatuses(Context context)
         {
-            return context.IsFrontendClient || context.IsResolveFlow();
+            return context.IsFrontendClient || context.ShouldResolveFlow();
         }
     }
 }

backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/Steps/ResolveAssets.cs

@@ -110,7 +110,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries.Steps
                 return EmptyAssets;
             }
 
-            var assets = await assetQuery.QueryAsync(context.Clone().WithNoAssetEnrichment(true), null, Q.Empty.WithIds(ids));
+            var assets = await assetQuery.QueryAsync(context.Clone().WithoutAssetEnrichment(true), null, Q.Empty.WithIds(ids));
 
             return assets.ToLookup(x => x.Id);
         }
@@ -125,7 +125,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries.Steps
 
         private static bool ShouldEnrich(Context context)
         {
-            return context.IsFrontendClient && !context.IsNoEnrichment();
+            return context.IsFrontendClient && context.ShouldEnrichContent();
         }
     }
 }

backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/Steps/ResolveReferences.cs

@@ -161,7 +161,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries.Steps
 
         private static bool ShouldEnrich(Context context)
         {
-            return context.IsFrontendClient && !context.IsNoEnrichment();
+            return context.IsFrontendClient && context.ShouldEnrichContent();
         }
     }
 }

backend/src/Squidex/Areas/Api/Controllers/Contents/Models/ContentDto.cs

@@ -110,7 +110,7 @@ namespace Squidex.Areas.Api.Controllers.Contents.Models
         {
             var response = SimpleMapper.Map(content, new ContentDto());
 
-            if (context.IsFlatten())
+            if (context.ShouldFlatten())
             {
                 response.Data = content.Data?.ToFlatten();
                 response.DataDraft = content.DataDraft?.ToFlatten();

backend/tests/Squidex.Domain.Apps.Entities.Tests/Assets/AssetCommandMiddlewareTests.cs

@@ -69,7 +69,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
             A.CallTo(() => assetEnricher.EnrichAsync(A<IAssetEntity>.Ignored, requestContext))
                 .ReturnsLazily(() => SimpleMapper.Map(asset.Snapshot, new AssetEntity()));
 
-            A.CallTo(() => assetQuery.QueryByHashAsync(A<Context>.That.Matches(x => x.IsNoAssetEnrichment()), AppId, A<string>.Ignored))
+            A.CallTo(() => assetQuery.QueryByHashAsync(A<Context>.That.Matches(x => x.ShouldEnrichAsset()), AppId, A<string>.Ignored))
                 .Returns(new List<IEnrichedAssetEntity>());
 
             A.CallTo(() => grainFactory.GetGrain<IAssetGrain>(Id, null))
@@ -301,7 +301,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
                 FileSize = fileSize
             };
 
-            A.CallTo(() => assetQuery.QueryByHashAsync(A<Context>.That.Matches(x => x.IsNoAssetEnrichment()), A<Guid>.Ignored, A<string>.Ignored))
+            A.CallTo(() => assetQuery.QueryByHashAsync(A<Context>.That.Matches(x => x.ShouldEnrichAsset()), A<Guid>.Ignored, A<string>.Ignored))
                 .Returns(new List<IEnrichedAssetEntity> { duplicate });
         }
 

backend/tests/Squidex.Domain.Apps.Entities.Tests/Assets/Queries/AssetEnricherTests.cs

@@ -84,7 +84,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
                 AppId = appId
             };
 
-            var result = await sut.EnrichAsync(source, requestContext.Clone().WithNoAssetEnrichment());
+            var result = await sut.EnrichAsync(source, requestContext.Clone().WithoutAssetEnrichment());
 
             Assert.Null(result.TagNames);
         }

backend/tests/Squidex.Domain.Apps.Entities.Tests/Contents/Queries/ResolveAssetsTests.cs

@@ -93,7 +93,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
                     new[] { document2.Id, image2.Id })
             };
 
-            A.CallTo(() => assetQuery.QueryAsync(A<Context>.That.Matches(x => x.IsNoAssetEnrichment()), null, A<Q>.That.Matches(x => x.Ids.Count == 4)))
+            A.CallTo(() => assetQuery.QueryAsync(A<Context>.That.Matches(x => x.ShouldEnrichAsset()), null, A<Q>.That.Matches(x => x.Ids.Count == 4)))
                 .Returns(ResultList.CreateFrom(4, image1, image2, document1, document2));
 
             await sut.EnrichAsync(requestContext, source, schemaProvider);
@@ -128,7 +128,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
                     new[] { document2.Id, image2.Id })
             };
 
-            A.CallTo(() => assetQuery.QueryAsync(A<Context>.That.Matches(x => x.IsNoAssetEnrichment()), null, A<Q>.That.Matches(x => x.Ids.Count == 4)))
+            A.CallTo(() => assetQuery.QueryAsync(A<Context>.That.Matches(x => x.ShouldEnrichAsset()), null, A<Q>.That.Matches(x => x.Ids.Count == 4)))
                 .Returns(ResultList.CreateFrom(4, image1, image2, document1, document2));
 
             await sut.EnrichAsync(requestContext, source, schemaProvider);

backend/tests/Squidex.Domain.Apps.Entities.Tests/Contents/Queries/ResolveReferencesTests.cs

@@ -142,7 +142,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
                 CreateContent(new[] { ref1_2.Id }, new[] { ref2_2.Id })
             };
 
-            A.CallTo(() => contentQuery.QueryAsync(A<Context>.That.Matches(x => x.IsNoEnrichment()), A<IReadOnlyList<Guid>>.That.Matches(x => x.Count == 4)))
+            A.CallTo(() => contentQuery.QueryAsync(A<Context>.That.Matches(x => x.ShouldEnrichContent()), A<IReadOnlyList<Guid>>.That.Matches(x => x.Count == 4)))
                 .Returns(ResultList.CreateFrom(4, ref1_1, ref1_2, ref2_1, ref2_2));
 
             await sut.EnrichAsync(requestContext, source, schemaProvider);
@@ -194,7 +194,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
                 CreateContent(new[] { ref1_2.Id }, new[] { ref2_1.Id, ref2_2.Id })
             };
 
-            A.CallTo(() => contentQuery.QueryAsync(A<Context>.That.Matches(x => x.IsNoEnrichment()), A<IReadOnlyList<Guid>>.That.Matches(x => x.Count == 4)))
+            A.CallTo(() => contentQuery.QueryAsync(A<Context>.That.Matches(x => x.ShouldEnrichContent()), A<IReadOnlyList<Guid>>.That.Matches(x => x.Count == 4)))
                 .Returns(ResultList.CreateFrom(4, ref1_1, ref1_2, ref2_1, ref2_2));
 
             await sut.EnrichAsync(requestContext, source, schemaProvider);