Unpublished content for single content.

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

@@ -72,12 +72,12 @@ namespace Squidex.Domain.Apps.Entities.Contents
             {
                 var isVersioned = version > EtagVersion.Empty;
 
-                var parsedStatus = context.Base.IsFrontendClient ? StatusAll : StatusPublished;
+                var status = GetFindStatus(context.Base);
 
                 var content =
                     isVersioned ?
                     await FindContentByVersionAsync(id, version) :
-                    await FindContentAsync(context.Base, id, parsedStatus, schema);
+                    await FindContentAsync(context.Base, id, status, schema);
 
                 if (content == null || (content.Status != Status.Published && !context.Base.IsFrontendClient) || content.SchemaId.Id != schema.Id)
                 {
@@ -96,20 +96,20 @@ namespace Squidex.Domain.Apps.Entities.Contents
 
             using (Profiler.TraceMethod<ContentQueryService>())
             {
-                var parsedStatus = ParseStatus(context.Base);
+                var status = GetQueryStatus(context.Base);
 
                 IResultList<IContentEntity> contents;
 
                 if (query.Ids?.Count > 0)
                 {
-                    contents = await contentRepository.QueryAsync(context.Base.App, schema, parsedStatus, new HashSet<Guid>(query.Ids));
+                    contents = await contentRepository.QueryAsync(context.Base.App, schema, status, new HashSet<Guid>(query.Ids));
                     contents = Sort(contents, query.Ids);
                 }
                 else
                 {
                     var parsedQuery = ParseQuery(context.Base, query.ODataQuery, schema);
 
-                    contents = await contentRepository.QueryAsync(context.Base.App, schema, parsedStatus, parsedQuery);
+                    contents = await contentRepository.QueryAsync(context.Base.App, schema, status, parsedQuery);
                 }
 
                 return Transform(context.Base, schema, true, contents);
@@ -236,7 +236,23 @@ namespace Squidex.Domain.Apps.Entities.Contents
             return schema;
         }
 
-        private static Status[] ParseStatus(QueryContext context)
+        private static Status[] GetFindStatus(QueryContext context)
+        {
+            if (context.IsFrontendClient)
+            {
+                return StatusAll;
+            }
+            else if (context.Unpublished)
+            {
+                return StatusDraftOrPublished;
+            }
+            else
+            {
+                return StatusPublished;
+            }
+        }
+
+        private static Status[] GetQueryStatus(QueryContext context)
         {
             if (context.IsFrontendClient)
             {

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

@@ -105,13 +105,15 @@ namespace Squidex.Domain.Apps.Entities.Contents
 
         public static IEnumerable<object[]> SingleRequestData = new[]
         {
-            new object[] { true,  new[] { Status.Archived, Status.Draft, Status.Published } },
+            new object[] { true,  true,  new[] { Status.Archived, Status.Draft, Status.Published } },
-            new object[] { false, new[] { Status.Published } }
+            new object[] { true,  false, new[] { Status.Archived, Status.Draft, Status.Published } },
+            new object[] { false, true,  new[] { Status.Draft, Status.Published } },
+            new object[] { false, false, new[] { Status.Published } }
         };
 
         [Theory]
         [MemberData(nameof(SingleRequestData))]
-        public async Task Should_return_content_from_repository_and_transform(bool isFrontend, params Status[] status)
+        public async Task Should_return_content_from_repository_and_transform(bool isFrontend, bool unpublished, params Status[] status)
         {
             var contentId = Guid.NewGuid();
             var content = CreateContent(contentId);
@@ -124,7 +126,9 @@ namespace Squidex.Domain.Apps.Entities.Contents
             A.CallTo(() => contentRepository.FindContentAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), contentId))
                 .Returns(content);
 
-            var result = await sut.FindContentAsync(context.WithSchemaId(schemaId), contentId);
+            var ctx = context.WithSchemaId(schemaId).WithUnpublished(unpublished);
+
+            var result = await sut.FindContentAsync(ctx, contentId);
 
             Assert.Equal(contentTransformed, result.Data);
             Assert.Equal(content.Id, result.Id);