Mapped StatusFlow to new DefaultContentWorkflow (#365)

* Mapped StatusFlow to new DefaultContentWorkflow and Added Status2 to IContentEntity

* Added DefaultContentWorkflow to DI and added tests.

* Addressed feedback from Code Review.

* Removed unused reference.

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

@@ -0,0 +1,75 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschränkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Squidex.Domain.Apps.Core.Contents;
+using Squidex.Domain.Apps.Entities.Schemas;
+using Squidex.Infrastructure.Tasks;
+
+namespace Squidex.Domain.Apps.Entities.Contents
+{
+    public sealed class DefaultContentWorkflow : IContentWorkflow
+    {
+        private static readonly Status2 Draft = new Status2("Draft");
+        private static readonly Status2 Archived = new Status2("Archived");
+        private static readonly Status2 Published = new Status2("Published");
+
+        private static readonly Dictionary<Status2, Status2[]> Flow = new Dictionary<Status2, Status2[]>
+        {
+            [Draft] = new[] { Published, Archived },
+            [Archived] = new[] { Draft },
+            [Published] = new[] { Draft, Archived }
+        };
+
+        public Task<Status2> GetInitialStatusAsync(ISchemaEntity schema)
+        {
+            return Task.FromResult(Draft);
+        }
+
+        public Task<bool> IsValidNextStatus(IContentEntity content, Status2 next)
+        {
+            return TaskHelper.True;
+        }
+
+        public Task<bool> CanUpdateAsync(IContentEntity content)
+        {
+            return TaskHelper.True;
+        }
+
+        public Task<Status2[]> GetNextsAsync(IContentEntity content)
+        {
+            Status2 statusToCheck;
+
+            switch (content.Status)
+            {
+                case Status.Draft:
+                    statusToCheck = Draft;
+                    break;
+                case Status.Archived:
+                    statusToCheck = Archived;
+                    break;
+                case Status.Published:
+                    statusToCheck = Published;
+                    break;
+                default:
+                {
+                    statusToCheck = Draft;
+                    break;
+                }
+            }
+
+            return Task.FromResult(Flow.TryGetValue(statusToCheck, out var result) ? result : Array.Empty<Status2>());
+        }
+
+        public Task<Status2[]> GetAllAsync(ISchemaEntity schema)
+        {
+            return Task.FromResult(new[] { Draft, Archived, Published } );
+        }
+    }
+}

src/Squidex/Config/Domain/EntitiesServices.cs

@@ -101,6 +101,9 @@ namespace Squidex.Config.Domain
             services.AddSingletonAs<SchemaHistoryEventsCreator>()
                 .As<IHistoryEventsCreator>();
 
+            services.AddSingletonAs<DefaultContentWorkflow>()
+                .AsOptional<IContentWorkflow>();
+
             services.AddSingletonAs<RolePermissionsProvider>()
                 .AsSelf();
 

tests/Squidex.Domain.Apps.Core.Tests/Squidex.Domain.Apps.Core.Tests.csproj

@@ -9,6 +9,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\src\Squidex.Domain.Apps.Core.Model\Squidex.Domain.Apps.Core.Model.csproj" />
     <ProjectReference Include="..\..\src\Squidex.Domain.Apps.Core.Operations\Squidex.Domain.Apps.Core.Operations.csproj" />
+    <ProjectReference Include="..\..\src\Squidex.Domain.Apps.Entities\Squidex.Domain.Apps.Entities.csproj" />
     <ProjectReference Include="..\..\src\Squidex.Infrastructure\Squidex.Infrastructure.csproj" />
   </ItemGroup>
   <ItemGroup>

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

@@ -0,0 +1,101 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschränkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System;
+using System.Threading.Tasks;
+using FakeItEasy;
+using Squidex.Domain.Apps.Core.Contents;
+using Xunit;
+
+namespace Squidex.Domain.Apps.Entities.Contents
+{
+    public class DefaultContentWorkflowTests
+    {
+        private static readonly DefaultContentWorkflow Sut = new DefaultContentWorkflow();
+
+        [Fact]
+        public async Task Should_draft_as_initial_status_async_tests()
+        {
+            var result = await Sut.GetInitialStatusAsync(null);
+
+            Assert.IsType<Status2>(result);
+            Assert.Equal("Draft", result.Name);
+        }
+
+        [Fact]
+        public async Task Should_check_is_valid_next_status_tests()
+        {
+            var entity = CreateMockContentEntity(Status.Draft);
+
+            var status = new Status2("Draft");
+
+            var result = await Sut.IsValidNextStatus(entity, status);
+
+            Assert.IsType<bool>(result);
+            Assert.True(result);
+        }
+
+        [Fact]
+        public async Task Should_update_async_tests()
+        {
+            var entity = CreateMockContentEntity(Status.Draft);
+
+            var result = await Sut.CanUpdateAsync(entity);
+
+            Assert.IsType<bool>(result);
+            Assert.True(result);
+        }
+
+        [Fact]
+        public async Task Should_get_nexts_async_tests()
+        {
+            var draftContent = CreateMockContentEntity(Status.Draft);
+            var archivedContent = CreateMockContentEntity(Status.Archived);
+            var publishedContent = CreateMockContentEntity(Status.Published);
+
+            var draftExpected = new[] { new Status2("Published"), new Status2("Archived") };
+            var archivedExpected = new[] { new Status2("Draft") };
+            var publishedExpected = new[] { new Status2("Draft"), new Status2("Archived") };
+
+            var draftResult = await Sut.GetNextsAsync(draftContent);
+            var archivedResult = await Sut.GetNextsAsync(archivedContent);
+            var publishedResult = await Sut.GetNextsAsync(publishedContent);
+
+            Assert.IsType<Status2[]>(draftResult);
+            Assert.IsType<Status2[]>(archivedResult);
+            Assert.IsType<Status2[]>(publishedResult);
+
+            Assert.Equal(draftExpected, draftResult);
+            Assert.Equal(archivedExpected, archivedResult);
+            Assert.Equal(publishedExpected, publishedResult);
+        }
+
+        [Fact]
+        public async Task Should_get_all_async_tests()
+        {
+            var expected = new[] { new Status2("Draft"), new Status2("Archived"), new Status2("Published") };
+
+            var result = await Sut.GetAllAsync(null);
+
+            Assert.IsType<Status2[]>(result);
+            Assert.Equal(expected, result);
+        }
+
+        private IContentEntity CreateMockContentEntity(Status status)
+        {
+            var content = A.Fake<IContentEntity>();
+
+            A.CallTo(() => content.Id).Returns(default(Guid));
+            A.CallTo(() => content.Data).Returns(null);
+            A.CallTo(() => content.DataDraft).Returns(null);
+            A.CallTo(() => content.SchemaId).Returns(null);
+            A.CallTo(() => content.Status).Returns(status);
+
+            return content;
+        }
+    }
+}