Unpublished flag.

src/Squidex.Domain.Apps.Core.Operations/HandleRules/Actions/AzureQueueActionHandler.cs

@@ -71,7 +71,7 @@ namespace Squidex.Domain.Apps.Core.HandleRules.Actions
             {
                 QueueConnectionString = action.ConnectionString,
                 QueueName = queueName,
-                MessageBodyV2 = body,
+                MessageBodyV2 = body
             };
 
             return (ruleDescription, ruleJob);

src/Squidex.Domain.Apps.Core.Operations/HandleRules/Actions/ElasticSearchActionHandler.cs

@@ -74,7 +74,7 @@ namespace Squidex.Domain.Apps.Core.HandleRules.Actions
                     Password = action.Password,
                     ContentId = contentId,
                     IndexName = formatter.Format(action.IndexName, @event),
-                    IndexType = formatter.Format(action.IndexType, @event),
+                    IndexType = formatter.Format(action.IndexType, @event)
                 };
 
                 if (contentEvent.Type == EnrichedContentEventType.Deleted ||

src/Squidex.Domain.Apps.Core.Operations/HandleRules/Actions/SlackActionHandler.cs

@@ -67,7 +67,7 @@ namespace Squidex.Domain.Apps.Core.HandleRules.Actions
             var ruleJob = new SlackJob
             {
                 RequestUrl = action.WebhookUrl.ToString(),
-                RequestBodyV2 = body.ToString(Formatting.Indented),
+                RequestBodyV2 = body.ToString(Formatting.Indented)
             };
 
             return (Description, ruleJob);

src/Squidex.Domain.Apps.Entities.MongoDb/Contents/Visitors/FindExtensions.cs

@@ -102,7 +102,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents.Visitors
         {
             var filters = new List<FilterDefinition<MongoContentEntity>>
             {
-                Filter.Eq(x => x.IndexedSchemaId, schemaId),
+                Filter.Eq(x => x.IndexedSchemaId, schemaId)
             };
 
             if (status != null)

src/Squidex.Domain.Apps.Entities/Apps/Templates/CreateBlogCommandMiddleware.cs

@@ -79,7 +79,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
                         .AddField("text",
                             new ContentFieldData()
                                 .AddValue("iv", "Just created a blog with Squidex. I love it!")),
-                Publish = true,
+                Publish = true
             });
         }
 

src/Squidex.Domain.Apps.Entities/Apps/Templates/CreateProfileCommandMiddleware.cs

@@ -77,7 +77,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
                         .AddField("profession",
                             new ContentFieldData()
                                 .AddValue("iv", "Software Developer")),
-                Publish = true,
+                Publish = true
             });
         }
 

src/Squidex.Domain.Apps.Entities/Contents/ContentQueryContext.cs

@@ -38,6 +38,11 @@ namespace Squidex.Domain.Apps.Entities.Contents
             return Clone(c => c.Base = c.Base.WithFlatten(flatten));
         }
 
+        public ContentQueryContext WithUnpublished(bool unpublished)
+        {
+            return Clone(c => c.Base = c.Base.WithUnpublished(unpublished));
+        }
+
         public ContentQueryContext WithSchemaId(Guid id)
         {
             return Clone(c => c.SchemaIdOrName = id.ToString());

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

@@ -21,6 +21,8 @@ using Squidex.Infrastructure;
 using Squidex.Infrastructure.Log;
 using Squidex.Infrastructure.Reflection;
 
+#pragma warning disable RECS0147
+
 namespace Squidex.Domain.Apps.Entities.Contents
 {
     public sealed class ContentQueryService : IContentQueryService
@@ -242,12 +244,23 @@ namespace Squidex.Domain.Apps.Entities.Contents
                 {
                     return StatusArchived;
                 }
-
+                else
+                {
                     return StatusDraftOrPublished;
                 }
-
+            }
+            else
+            {
+                if (context.Unpublished)
+                {
+                    return StatusDraftOrPublished;
+                }
+                else
+                {
                     return StatusPublished;
                 }
+            }
+        }
 
         private Task<IContentEntity> FindContentByVersionAsync(Guid id, long version)
         {

src/Squidex.Domain.Apps.Entities/QueryContext.cs

@@ -23,6 +23,8 @@ namespace Squidex.Domain.Apps.Entities
 
         public bool Flatten { get; private set; }
 
+        public bool Unpublished { get; set; }
+
         public IEnumerable<Language> Languages { get; private set; }
 
         private QueryContext()
@@ -34,6 +36,11 @@ namespace Squidex.Domain.Apps.Entities
             return new QueryContext { App = app, User = user };
         }
 
+        public QueryContext WithUnpublished(bool unpublished)
+        {
+            return Clone(c => c.Unpublished = unpublished);
+        }
+
         public QueryContext WithArchived(bool archived)
         {
             return Clone(c => c.Archived = archived);

src/Squidex/Areas/Api/Controllers/Contents/ContentsController.cs

@@ -482,7 +482,10 @@ namespace Squidex.Areas.Api.Controllers.Contents
 
         private ContentQueryContext Context()
         {
-            return new ContentQueryContext(QueryContext.Create(App, User).WithLanguages(Request.Headers["X-Languages"])).WithFlatten(Request.Headers.ContainsKey("X-Flatten"));
+            return new ContentQueryContext(QueryContext.Create(App, User)
+                .WithLanguages(Request.Headers["X-Languages"]))
+                .WithFlatten(Request.Headers.ContainsKey("X-Flatten"))
+                .WithUnpublished(Request.Headers.ContainsKey("X-Unpublished"));
         }
     }
 }

src/Squidex/Areas/Api/Controllers/Schemas/Models/SchemaDetailsDto.cs

@@ -142,7 +142,7 @@ namespace Squidex.Areas.Api.Controllers.Schemas.Models
                             new NestedFieldDto
                             {
                                 FieldId = nestedField.Id,
-                                Properties = nestedFieldPropertiesDto,
+                                Properties = nestedFieldPropertiesDto
                             });
 
                         fieldDto.Nested.Add(nestedFieldDto);

tests/Squidex.Domain.Apps.Core.Tests/Operations/ValidateContent/ContentValidationTests.cs

@@ -340,7 +340,7 @@ namespace Squidex.Domain.Apps.Core.Operations.ValidateContent
                 new List<ValidationError>
                 {
                     new ValidationError("my-field[1].my-nested: Field is required.", "my-field[1].my-nested"),
-                    new ValidationError("my-field[3].my-nested: Field is required.", "my-field[3].my-nested"),
+                    new ValidationError("my-field[3].my-nested: Field is required.", "my-field[3].my-nested")
                 });
         }
     }

tests/Squidex.Domain.Apps.Entities.Tests/Contents/ContentQueryServiceTests.cs

@@ -165,16 +165,22 @@ namespace Squidex.Domain.Apps.Entities.Contents
 
         public static IEnumerable<object[]> ManyRequestData = new[]
         {
-            new object[] { 5, 200, false, true,  new[] { Status.Published } },
+            new object[] { true,  true,  true,  new[] { Status.Archived } },
-            new object[] { 5, 200, false, false, new[] { Status.Published } },
+            new object[] { true,  true,  false, new[] { Status.Archived } },
-            new object[] { 5, 200, true,  false, new[] { Status.Draft, Status.Published } },
+            new object[] { true,  false, true,  new[] { Status.Draft, Status.Published } },
-            new object[] { 5, 200, true,  true,  new[] { Status.Archived } }
+            new object[] { true,  false, false, new[] { Status.Draft, Status.Published } },
+            new object[] { false, true,  true,  new[] { Status.Draft, Status.Published } },
+            new object[] { false, false, true,  new[] { Status.Draft, Status.Published } },
+            new object[] { false, false, false, new[] { Status.Published } },
+            new object[] { false, true,  false, new[] { Status.Published } }
         };
 
         [Theory]
         [MemberData(nameof(ManyRequestData))]
-        public async Task Should_query_contents_by_query_from_repository_and_transform(int count, int total, bool isFrontend, bool archive, params Status[] status)
+        public async Task Should_query_contents_by_query_from_repository_and_transform(bool isFrontend, bool archive, bool unpublished, params Status[] status)
         {
+            const int count = 5, total = 200;
+
             var contentId = Guid.NewGuid();
             var content = CreateContent(contentId);
 
@@ -187,7 +193,9 @@ namespace Squidex.Domain.Apps.Entities.Contents
             A.CallTo(() => contentRepository.QueryAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), A<ODataUriParser>.Ignored))
                 .Returns(ResultList.Create(total, Enumerable.Repeat(content, count)));
 
-            var result = await sut.QueryAsync(context.WithSchemaId(schemaId).WithArchived(archive), Query.Empty);
+            var ctx = context.WithSchemaId(schemaId).WithArchived(archive).WithUnpublished(unpublished);
+
+            var result = await sut.QueryAsync(ctx, Query.Empty);
 
             Assert.Equal(contentData, result[0].Data);
             Assert.Equal(content.Id, result[0].Id);
@@ -220,16 +228,22 @@ namespace Squidex.Domain.Apps.Entities.Contents
 
         public static IEnumerable<object[]> ManyIdRequestData = new[]
         {
-            new object[] { 5, 200, false, true,  new[] { Status.Published } },
+            new object[] { true,  true,  true,  new[] { Status.Archived } },
-            new object[] { 5, 200, false, false, new[] { Status.Published } },
+            new object[] { true,  true,  false, new[] { Status.Archived } },
-            new object[] { 5, 200, true,  false, new[] { Status.Draft, Status.Published } },
+            new object[] { true,  false, true,  new[] { Status.Draft, Status.Published } },
-            new object[] { 5, 200, true,  true,  new[] { Status.Archived } }
+            new object[] { true,  false, false, new[] { Status.Draft, Status.Published } },
+            new object[] { false, true,  true,  new[] { Status.Draft, Status.Published } },
+            new object[] { false, false, true,  new[] { Status.Draft, Status.Published } },
+            new object[] { false, false, false, new[] { Status.Published } },
+            new object[] { false, true,  false, new[] { Status.Published } }
         };
 
         [Theory]
         [MemberData(nameof(ManyIdRequestData))]
-        public async Task Should_query_contents_by_id_from_repository_and_transform(int count, int total, bool isFrontend, bool archive, params Status[] status)
+        public async Task Should_query_contents_by_id_from_repository_and_transform(bool isFrontend, bool archive, bool unpublished, params Status[] status)
         {
+            const int count = 5, total = 200;
+
             var ids = Enumerable.Range(0, count).Select(x => Guid.NewGuid()).ToList();
 
             SetupClaims(isFrontend);
@@ -241,7 +255,9 @@ namespace Squidex.Domain.Apps.Entities.Contents
             A.CallTo(() => contentRepository.QueryAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), A<HashSet<Guid>>.Ignored))
                 .Returns(ResultList.Create(total, ids.Select(x => CreateContent(x)).Shuffle()));
 
-            var result = await sut.QueryAsync(context.WithSchemaId(schemaId).WithArchived(archive), Query.Empty.WithIds(ids));
+            var ctx = context.WithSchemaId(schemaId).WithArchived(archive).WithUnpublished(unpublished);
+
+            var result = await sut.QueryAsync(ctx, Query.Empty.WithIds(ids));
 
             Assert.Equal(ids, result.Select(x => x.Id).ToList());
             Assert.Equal(total, result.Total);