Cleaned up the commands and removed unnecessary properties.

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

@@ -8,14 +8,11 @@
 using System;
 using System.Collections.Generic;
 using System.Net.Http;
-using System.Text;
 using System.Threading.Tasks;
-using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Squidex.Domain.Apps.Core.Rules;
 using Squidex.Domain.Apps.Core.Rules.Actions;
 using Squidex.Domain.Apps.Events;
-using Squidex.Infrastructure;
 using Squidex.Infrastructure.EventSourcing;
 using Squidex.Infrastructure.Http;
 

src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetEntity.cs

@@ -20,9 +20,16 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
         IAssetEntity,
         IUpdateableEntityWithVersion,
         IUpdateableEntityWithCreatedBy,
-        IUpdateableEntityWithLastModifiedBy,
-        IUpdateableEntityWithAppRef
+        IUpdateableEntityWithLastModifiedBy
     {
+        [BsonRequired]
+        [BsonElement]
+        public Guid IdxAppId { get; set; }
+
+        [BsonRequired]
+        [BsonElement]
+        public NamedId<Guid> AppId { get; set; }
+
         [BsonRequired]
         [BsonElement]
         public string MimeType { get; set; }
@@ -55,10 +62,6 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
         [BsonElement]
         public int? PixelHeight { get; set; }
 
-        [BsonRequired]
-        [BsonElement]
-        public Guid AppId { get; set; }
-
         [BsonRequired]
         [BsonElement]
         public RefToken CreatedBy { get; set; }

src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetRepository_SnapshotStore.cs

@@ -36,6 +36,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
             var entity = SimpleMapper.Map(value, new MongoAssetEntity());
 
             entity.Version = newVersion;
+            entity.IdxAppId = value.AppId.Id;
 
             await Collection.ReplaceOneAsync(x => x.Id == key && x.Version == oldVersion, entity, Upsert);
         }

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

@@ -51,7 +51,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets.Visitors
         {
             var filters = new List<FilterDefinition<MongoAssetEntity>>
             {
-                Filter.Eq(x => x.AppId, appId),
+                Filter.Eq(x => x.IdxAppId, appId),
                 Filter.Eq(x => x.IsDeleted, false)
             };
 

src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentEntity.cs

@@ -35,12 +35,12 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
         [BsonRequired]
         [BsonElement("ai")]
         [BsonRepresentation(BsonType.String)]
-        public Guid AppId { get; set; }
+        public Guid IdxAppId { get; set; }
 
         [BsonRequired]
         [BsonElement("si")]
         [BsonRepresentation(BsonType.String)]
-        public Guid SchemaId { get; set; }
+        public Guid IdxSchemaId { get; set; }
 
         [BsonRequired]
         [BsonElement("rf")]
@@ -62,6 +62,22 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
         [BsonJson]
         public IdContentData DataByIds { get; set; }
 
+        [BsonRequired]
+        [BsonElement("ai2")]
+        public NamedId<Guid> AppId { get; set; }
+
+        [BsonRequired]
+        [BsonElement("si2")]
+        public NamedId<Guid> SchemaId { get; set; }
+
+        [BsonIgnoreIfNull]
+        [BsonElement("pa")]
+        public Instant? PublishAt { get; set; }
+
+        [BsonIgnoreIfNull]
+        [BsonElement("pb")]
+        public RefToken PublishAtBy { get; set; }
+
         [BsonRequired]
         [BsonElement("ct")]
         public Instant Created { get; set; }

src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentRepository.cs

@@ -11,6 +11,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.OData.UriParser;
 using MongoDB.Driver;
+using NodaTime;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Entities.Apps;
 using Squidex.Domain.Apps.Entities.Contents;
@@ -59,13 +60,13 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
             await collection.Indexes.CreateOneAsync(
                 Index
                     .Text(x => x.DataText)
-                    .Ascending(x => x.SchemaId)
+                    .Ascending(x => x.IdxSchemaId)
                     .Ascending(x => x.Status)
                     .Ascending(x => x.IsDeleted));
 
             await collection.Indexes.CreateOneAsync(
                 Index
-                    .Ascending(x => x.SchemaId)
+                    .Ascending(x => x.IdxSchemaId)
                     .Ascending(x => x.Id)
                     .Ascending(x => x.IsDeleted)
                     .Ascending(x => x.Status));
@@ -121,7 +122,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
 
         public async Task<IResultList<IContentEntity>> QueryAsync(IAppEntity app, ISchemaEntity schema, Status[] status, HashSet<Guid> ids)
         {
-            var find = Collection.Find(x => x.SchemaId == schema.Id && ids.Contains(x.Id) && x.IsDeleted == false && status.Contains(x.Status));
+            var find = Collection.Find(x => x.IdxSchemaId == schema.Id && ids.Contains(x.Id) && x.IsDeleted == false && status.Contains(x.Status));
 
             var contentItems = find.ToListAsync();
             var contentCount = find.CountAsync();
@@ -139,7 +140,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
         public async Task<IReadOnlyList<Guid>> QueryNotFoundAsync(Guid appId, Guid schemaId, IList<Guid> ids)
         {
             var contentEntities =
-                await Collection.Find(x => x.SchemaId == schemaId && ids.Contains(x.Id) && x.IsDeleted == false).Only(x => x.Id)
+                await Collection.Find(x => x.IdxSchemaId == schemaId && ids.Contains(x.Id) && x.IsDeleted == false).Only(x => x.Id)
                     .ToListAsync();
 
             return ids.Except(contentEntities.Select(x => Guid.Parse(x["id"].AsString))).ToList();
@@ -159,7 +160,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
         public async Task<IContentEntity> FindContentAsync(IAppEntity app, ISchemaEntity schema, Guid id)
         {
             var contentEntity =
-                await Collection.Find(x => x.SchemaId == schema.Id && x.Id == id && x.IsDeleted == false)
+                await Collection.Find(x => x.IdxSchemaId == schema.Id && x.Id == id && x.IsDeleted == false)
                     .FirstOrDefaultAsync();
 
             contentEntity?.ParseData(schema.SchemaDef);
@@ -173,5 +174,10 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
 
             await base.ClearAsync();
         }
+
+        public Task QueryContentToPublishAsync(Instant now, Func<IContentEntity, Task> callback)
+        {
+            throw new NotSupportedException();
+        }
     }
 }

src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentRepository_SnapshotStore.cs

@@ -28,7 +28,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
 
             if (contentEntity != null)
             {
-                var schema = await GetSchemaAsync(contentEntity.AppId, contentEntity.SchemaId);
+                var schema = await GetSchemaAsync(contentEntity.IdxAppId, contentEntity.IdxSchemaId);
 
                 contentEntity?.ParseData(schema.SchemaDef);
 
@@ -40,12 +40,12 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
 
         public async Task WriteAsync(Guid key, ContentState value, long oldVersion, long newVersion)
         {
-            if (value.SchemaId == Guid.Empty)
+            if (value.SchemaId.Id == Guid.Empty)
             {
                 return;
             }
 
-            var schema = await GetSchemaAsync(value.AppId, value.SchemaId);
+            var schema = await GetSchemaAsync(value.SchemaId.Id, value.SchemaId.Id);
 
             var idData = value.Data?.ToIdModel(schema.SchemaDef, true);
 
@@ -53,6 +53,8 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
 
             var document = SimpleMapper.Map(value, new MongoContentEntity
             {
+                IdxAppId = value.AppId.Id,
+                IdxSchemaId = value.SchemaId.Id,
                 IsDeleted = value.IsDeleted,
                 DocumentId = key.ToString(),
                 DataText = idData?.ToFullText(),

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

@@ -80,7 +80,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents.Visitors
         {
             var filters = new List<FilterDefinition<MongoContentEntity>>
             {
-                Filter.Eq(x => x.SchemaId, schemaId),
+                Filter.Eq(x => x.IdxSchemaId, schemaId),
                 Filter.In(x => x.Status, status),
                 Filter.Eq(x => x.IsDeleted, false)
             };

src/Squidex.Domain.Apps.Entities.MongoDb/History/MongoHistoryEventEntity.cs

@@ -16,11 +16,9 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.History
 {
     public sealed class MongoHistoryEventEntity : MongoEntity,
         IEntity,
-        IEntityWithAppRef,
         IUpdateableEntity,
         IUpdateableEntityWithVersion,
-        IUpdateableEntityWithCreatedBy,
-        IUpdateableEntityWithAppRef
+        IUpdateableEntityWithCreatedBy
     {
         [BsonElement]
         [BsonRequired]

src/Squidex.Domain.Apps.Entities.MongoDb/Rules/MongoRuleRepository_SnapshotStore.cs

@@ -35,7 +35,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Rules
         {
             return Collection.UpsertVersionedAsync(key, oldVersion, newVersion, u => u
                 .Set(x => x.State, value)
-                .Set(x => x.AppId, value.AppId)
+                .Set(x => x.AppId, value.AppId.Id)
                 .Set(x => x.IsDeleted, value.IsDeleted));
         }
     }

src/Squidex.Domain.Apps.Entities.MongoDb/Schemas/MongoSchemaRepository_SnapshotStore.cs

@@ -35,7 +35,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Schemas
         {
             return Collection.UpsertVersionedAsync(key, oldVersion, newVersion, u => u
                 .Set(x => x.State, value)
-                .Set(x => x.AppId, value.AppId)
+                .Set(x => x.AppId, value.AppId.Id)
                 .Set(x => x.Name, value.Name)
                 .Set(x => x.IsDeleted, value.IsDeleted));
         }

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

@@ -92,7 +92,7 @@ namespace Squidex.Domain.Apps.Entities
         {
             var schema = await stateFactory.GetSingleAsync<SchemaDomainObject>(id);
 
-            if (!IsFound(schema) || schema.Snapshot.IsDeleted || schema.Snapshot.AppId != appId)
+            if (!IsFound(schema) || schema.Snapshot.IsDeleted || schema.Snapshot.AppId.Id != appId)
             {
                 return null;
             }

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

@@ -6,7 +6,6 @@
 // ==========================================================================
 
 using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
 using Squidex.Domain.Apps.Entities.Apps.Commands;
 using Squidex.Domain.Apps.Entities.Apps.Guards;
@@ -180,7 +179,7 @@ namespace Squidex.Domain.Apps.Entities.Apps
                 }
                 else
                 {
-                    var result = await appPlansBillingManager.ChangePlanAsync(command.Actor.Identifier, command.AppId.Id, a.Snapshot.Name, command.PlanId);
+                    var result = await appPlansBillingManager.ChangePlanAsync(command.Actor.Identifier, a.Snapshot.Id, a.Snapshot.Name, command.PlanId);
 
                     if (result is PlanChangedResult)
                     {

src/Squidex.Domain.Apps.Entities/Apps/Commands/AddLanguage.cs

@@ -9,7 +9,7 @@ using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class AddLanguage : AppAggregateCommand
+    public sealed class AddLanguage : AppCommand
     {
         public Language Language { get; set; }
     }

src/Squidex.Domain.Apps.Entities/Apps/Commands/AddPattern.cs

@@ -9,7 +9,7 @@ using System;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class AddPattern : AppAggregateCommand
+    public sealed class AddPattern : AppCommand
     {
         public Guid PatternId { get; set; }
 

src/Squidex.Domain.Apps.Entities/SchemaAggregateCommand.cs → src/Squidex.Domain.Apps.Entities/Apps/Commands/AppCommand.cs

@@ -8,13 +8,15 @@
 using System;
 using Squidex.Infrastructure.Commands;
 
-namespace Squidex.Domain.Apps.Entities
+namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public abstract class SchemaAggregateCommand : SchemaCommand, IAggregateCommand
+    public abstract class AppCommand : SquidexCommand, IAggregateCommand
     {
+        public Guid AppId { get; set; }
+
         Guid IAggregateCommand.AggregateId
         {
-            get { return SchemaId.Id; }
+            get { return AppId; }
         }
     }
 }

src/Squidex.Domain.Apps.Entities/Apps/Commands/AssignContributor.cs

@@ -9,7 +9,7 @@ using Squidex.Domain.Apps.Core.Apps;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class AssignContributor : AppAggregateCommand
+    public sealed class AssignContributor : AppCommand
     {
         public string ContributorId { get; set; }
 

src/Squidex.Domain.Apps.Entities/Apps/Commands/AttachClient.cs

@@ -9,10 +9,15 @@ using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class AttachClient : AppAggregateCommand
+    public sealed class AttachClient : AppCommand
     {
         public string Id { get; set; }
 
-        public string Secret { get; } = RandomHash.New();
+        public string Secret { get; set; }
+
+        public AttachClient()
+        {
+            Secret = RandomHash.New();
+        }
     }
 }

src/Squidex.Domain.Apps.Entities/Apps/Commands/ChangePlan.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class ChangePlan : AppAggregateCommand
+    public sealed class ChangePlan : AppCommand
     {
         public bool FromCallback { get; set; }
 

src/Squidex.Domain.Apps.Entities/Apps/Commands/CreateApp.cs

@@ -10,19 +10,12 @@ using Squidex.Infrastructure.Commands;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class CreateApp : SquidexCommand, IAggregateCommand
+    public sealed class CreateApp : AppCommand, IAggregateCommand
     {
-        public Guid AppId { get; set; }
-
         public string Name { get; set; }
 
         public string Template { get; set; }
 
-        Guid IAggregateCommand.AggregateId
-        {
-            get { return AppId; }
-        }
-
         public CreateApp()
         {
             AppId = Guid.NewGuid();

src/Squidex.Domain.Apps.Entities/Apps/Commands/DeletePattern.cs

@@ -9,7 +9,7 @@ using System;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class DeletePattern : AppAggregateCommand
+    public sealed class DeletePattern : AppCommand
     {
         public Guid PatternId { get; set; }
     }

src/Squidex.Domain.Apps.Entities/Apps/Commands/RemoveContributor.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class RemoveContributor : AppAggregateCommand
+    public sealed class RemoveContributor : AppCommand
     {
         public string ContributorId { get; set; }
     }

src/Squidex.Domain.Apps.Entities/Apps/Commands/RemoveLanguage.cs

@@ -9,7 +9,7 @@ using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class RemoveLanguage : AppAggregateCommand
+    public sealed class RemoveLanguage : AppCommand
     {
         public Language Language { get; set; }
     }

src/Squidex.Domain.Apps.Entities/Apps/Commands/RevokeClient.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class RevokeClient : AppAggregateCommand
+    public sealed class RevokeClient : AppCommand
     {
         public string Id { get; set; }
     }

src/Squidex.Domain.Apps.Entities/Apps/Commands/UpdateClient.cs

@@ -9,7 +9,7 @@ using Squidex.Domain.Apps.Core.Apps;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class UpdateClient : AppAggregateCommand
+    public sealed class UpdateClient : AppCommand
     {
         public string Id { get; set; }
 

src/Squidex.Domain.Apps.Entities/Apps/Commands/UpdateLanguage.cs

@@ -10,7 +10,7 @@ using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class UpdateLanguage : AppAggregateCommand
+    public sealed class UpdateLanguage : AppCommand
     {
         public Language Language { get; set; }
 

src/Squidex.Domain.Apps.Entities/Apps/Commands/UpdatePattern.cs

@@ -9,7 +9,7 @@ using System;
 
 namespace Squidex.Domain.Apps.Entities.Apps.Commands
 {
-    public sealed class UpdatePattern : AppAggregateCommand
+    public sealed class UpdatePattern : AppCommand
     {
         public Guid PatternId { get; set; }
 

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

@@ -36,17 +36,10 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
             {
                 var appId = new NamedId<Guid>(createApp.AppId, createApp.Name);
 
-                Task publishAsync(AppCommand command)
-                {
-                    command.AppId = appId;
-
-                    return context.CommandBus.PublishAsync(command);
-                }
-
                 return Task.WhenAll(
-                    CreatePagesAsync(publishAsync, appId),
-                    CreatePostsAsync(publishAsync, appId),
-                    CreateClientAsync(publishAsync, appId));
+                    CreatePagesAsync(context.CommandBus, appId),
+                    CreatePostsAsync(context.CommandBus, appId),
+                    CreateClientAsync(context.CommandBus, appId));
             }
 
             return TaskHelper.Done;
@@ -57,16 +50,16 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
             return string.Equals(createApp.Template, TemplateName, StringComparison.OrdinalIgnoreCase);
         }
 
-        private static async Task CreateClientAsync(Func<AppCommand, Task> publishAsync, NamedId<Guid> appId)
+        private static async Task CreateClientAsync(ICommandBus bus, NamedId<Guid> appId)
         {
-            await publishAsync(new AttachClient { Id = "sample-client" });
+            await bus.PublishAsync(new AttachClient { Id = "sample-client" });
         }
 
-        private async Task CreatePostsAsync(Func<AppCommand, Task> publishAsync, NamedId<Guid> appId)
+        private async Task CreatePostsAsync(ICommandBus bus, NamedId<Guid> appId)
         {
-            var postsId = await CreatePostsSchema(publishAsync);
+            var postsId = await CreatePostsSchema(bus, appId);
 
-            await publishAsync(new CreateContent
+            await bus.PublishAsync(new CreateContent
             {
                 SchemaId = postsId,
                 Data =
@@ -81,11 +74,11 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
             });
         }
 
-        private async Task CreatePagesAsync(Func<AppCommand, Task> publishAsync, NamedId<Guid> appId)
+        private async Task CreatePagesAsync(ICommandBus bus, NamedId<Guid> appId)
         {
-            var pagesId = await CreatePagesSchema(publishAsync);
+            var pagesId = await CreatePagesSchema(bus, appId);
 
-            await publishAsync(new CreateContent
+            await bus.PublishAsync(new CreateContent
             {
                 SchemaId = pagesId,
                 Data =
@@ -100,7 +93,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
             });
         }
 
-        private async Task<NamedId<Guid>> CreatePostsSchema(Func<AppCommand, Task> publishAsync)
+        private async Task<NamedId<Guid>> CreatePostsSchema(ICommandBus bus, NamedId<Guid> appId)
         {
             var command = new CreateSchema
             {
@@ -111,58 +104,59 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
                     Label = "Posts"
                 },
                 Fields = new List<CreateSchemaField>
+                {
+                    new CreateSchemaField
                     {
-                        new CreateSchemaField
+                        Name = "title",
+                        Partitioning = Partitioning.Invariant.Key,
+                        Properties = new StringFieldProperties
                         {
-                            Name = "title",
-                            Partitioning = Partitioning.Invariant.Key,
-                            Properties = new StringFieldProperties
-                            {
-                                Editor = StringFieldEditor.Input,
-                                IsRequired = true,
-                                IsListField = true,
-                                MaxLength = 100,
-                                MinLength = 0,
-                                Label = "Title"
-                            }
-                        },
-                        new CreateSchemaField
+                            Editor = StringFieldEditor.Input,
+                            IsRequired = true,
+                            IsListField = true,
+                            MaxLength = 100,
+                            MinLength = 0,
+                            Label = "Title"
+                        }
+                    },
+                    new CreateSchemaField
+                    {
+                        Name = "slug",
+                        Partitioning = Partitioning.Invariant.Key,
+                        Properties = new StringFieldProperties
                         {
-                            Name = "slug",
-                            Partitioning = Partitioning.Invariant.Key,
-                            Properties = new StringFieldProperties
-                            {
-                                Editor = StringFieldEditor.Slug,
-                                IsRequired = false,
-                                IsListField = true,
-                                MaxLength = 100,
-                                MinLength = 0,
-                                Label = "Slug (Autogenerated)"
-                            },
-                            IsDisabled = true
+                            Editor = StringFieldEditor.Slug,
+                            IsRequired = false,
+                            IsListField = true,
+                            MaxLength = 100,
+                            MinLength = 0,
+                            Label = "Slug (Autogenerated)"
                         },
-                        new CreateSchemaField
+                        IsDisabled = true
+                    },
+                    new CreateSchemaField
+                    {
+                        Name = "text",
+                        Partitioning = Partitioning.Invariant.Key,
+                        Properties = new StringFieldProperties
                         {
-                            Name = "text",
-                            Partitioning = Partitioning.Invariant.Key,
-                            Properties = new StringFieldProperties
-                            {
-                                Editor = StringFieldEditor.RichText,
-                                IsRequired = true,
-                                IsListField = false,
-                                Label = "Text"
-                            }
+                            Editor = StringFieldEditor.RichText,
+                            IsRequired = true,
+                            IsListField = false,
+                            Label = "Text"
                         }
                     }
+                },
+                AppId = appId
             };
 
-            await publishAsync(command);
+            await bus.PublishAsync(command);
 
             var schemaId = new NamedId<Guid>(command.SchemaId, command.Name);
 
-            await publishAsync(new ConfigureScripts
+            await bus.PublishAsync(new ConfigureScripts
             {
-                SchemaId = schemaId,
+                SchemaId = schemaId.Id,
                 ScriptCreate = SlugScript,
                 ScriptUpdate = SlugScript
             });
@@ -170,7 +164,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
             return schemaId;
         }
 
-        private async Task<NamedId<Guid>> CreatePagesSchema(Func<AppCommand, Task> publishAsync)
+        private async Task<NamedId<Guid>> CreatePagesSchema(ICommandBus bus, NamedId<Guid> appId)
         {
             var command = new CreateSchema
             {
@@ -180,58 +174,59 @@ namespace Squidex.Domain.Apps.Entities.Apps.Templates
                     Label = "Pages"
                 },
                 Fields = new List<CreateSchemaField>
+                {
+                    new CreateSchemaField
                     {
-                        new CreateSchemaField
+                        Name = "title",
+                        Partitioning = Partitioning.Invariant.Key,
+                        Properties = new StringFieldProperties
                         {
-                            Name = "title",
-                            Partitioning = Partitioning.Invariant.Key,
-                            Properties = new StringFieldProperties
-                            {
-                                Editor = StringFieldEditor.Input,
-                                IsRequired = true,
-                                IsListField = true,
-                                MaxLength = 100,
-                                MinLength = 0,
-                                Label = "Title"
-                            }
-                        },
-                        new CreateSchemaField
+                            Editor = StringFieldEditor.Input,
+                            IsRequired = true,
+                            IsListField = true,
+                            MaxLength = 100,
+                            MinLength = 0,
+                            Label = "Title"
+                        }
+                    },
+                    new CreateSchemaField
+                    {
+                        Name = "slug",
+                        Partitioning = Partitioning.Invariant.Key,
+                        Properties = new StringFieldProperties
                         {
-                            Name = "slug",
-                            Partitioning = Partitioning.Invariant.Key,
-                            Properties = new StringFieldProperties
-                            {
-                                Editor = StringFieldEditor.Slug,
-                                IsRequired = false,
-                                IsListField = true,
-                                MaxLength = 100,
-                                MinLength = 0,
-                                Label = "Slug (Autogenerated)"
-                            },
-                            IsDisabled = true
+                            Editor = StringFieldEditor.Slug,
+                            IsRequired = false,
+                            IsListField = true,
+                            MaxLength = 100,
+                            MinLength = 0,
+                            Label = "Slug (Autogenerated)"
                         },
-                        new CreateSchemaField
+                        IsDisabled = true
+                    },
+                    new CreateSchemaField
+                    {
+                        Name = "text",
+                        Partitioning = Partitioning.Invariant.Key,
+                        Properties = new StringFieldProperties
                         {
-                            Name = "text",
-                            Partitioning = Partitioning.Invariant.Key,
-                            Properties = new StringFieldProperties
-                            {
-                                Editor = StringFieldEditor.RichText,
-                                IsRequired = true,
-                                IsListField = false,
-                                Label = "Text"
-                            }
+                            Editor = StringFieldEditor.RichText,
+                            IsRequired = true,
+                            IsListField = false,
+                            Label = "Text"
                         }
                     }
+                },
+                AppId = appId
             };
 
-            await publishAsync(command);
+            await bus.PublishAsync(command);
 
             var schemaId = new NamedId<Guid>(command.SchemaId, command.Name);
 
-            await publishAsync(new ConfigureScripts
+            await bus.PublishAsync(new ConfigureScripts
             {
-                SchemaId = schemaId,
+                SchemaId = schemaId.Id,
                 ScriptCreate = SlugScript,
                 ScriptUpdate = SlugScript
             });

src/Squidex.Domain.Apps.Entities/Assets/AssetDomainObject.cs

@@ -7,6 +7,7 @@
 
 using Squidex.Domain.Apps.Entities.Assets.Commands;
 using Squidex.Domain.Apps.Entities.Assets.State;
+using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Assets;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Commands;
@@ -74,6 +75,16 @@ namespace Squidex.Domain.Apps.Entities.Assets
             return this;
         }
 
+        private void RaiseEvent(AppEvent @event)
+        {
+            if (@event.AppId == null)
+            {
+                @event.AppId = Snapshot.AppId;
+            }
+
+            RaiseEvent(Envelope.Create(@event));
+        }
+
         private void VerifyNotCreated()
         {
             if (!string.IsNullOrWhiteSpace(Snapshot.FileName))

src/Squidex.Domain.Apps.Entities/Assets/Commands/AssetAggregateCommand.cs → src/Squidex.Domain.Apps.Entities/Assets/Commands/AssetCommand.cs

@@ -10,7 +10,7 @@ using Squidex.Infrastructure.Commands;
 
 namespace Squidex.Domain.Apps.Entities.Assets.Commands
 {
-    public abstract class AssetAggregateCommand : AppCommand, IAggregateCommand
+    public abstract class AssetCommand : SquidexCommand, IAggregateCommand
     {
         public Guid AssetId { get; set; }
 

src/Squidex.Domain.Apps.Entities/Assets/Commands/CreateAsset.cs

@@ -6,12 +6,15 @@
 // ==========================================================================
 
 using System;
+using Squidex.Infrastructure;
 using Squidex.Infrastructure.Assets;
 
 namespace Squidex.Domain.Apps.Entities.Assets.Commands
 {
-    public sealed class CreateAsset : AssetAggregateCommand
+    public sealed class CreateAsset : AssetCommand, IAppCommand
     {
+        public NamedId<Guid> AppId { get; set; }
+
         public AssetFile File { get; set; }
 
         public ImageInfo ImageInfo { get; set; }

src/Squidex.Domain.Apps.Entities/Assets/Commands/DeleteAsset.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Assets.Commands
 {
-    public sealed class DeleteAsset : AssetAggregateCommand
+    public sealed class DeleteAsset : AssetCommand
     {
     }
 }

src/Squidex.Domain.Apps.Entities/Assets/Commands/RenameAsset.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Assets.Commands
 {
-    public sealed class RenameAsset : AssetAggregateCommand
+    public sealed class RenameAsset : AssetCommand
     {
         public string FileName { get; set; }
     }

src/Squidex.Domain.Apps.Entities/Assets/Commands/UpdateAsset.cs

@@ -9,7 +9,7 @@ using Squidex.Infrastructure.Assets;
 
 namespace Squidex.Domain.Apps.Entities.Assets.Commands
 {
-    public sealed class UpdateAsset : AssetAggregateCommand
+    public sealed class UpdateAsset : AssetCommand
     {
         public AssetFile File { get; set; }
 

src/Squidex.Domain.Apps.Entities/Assets/IAssetEntity.cs

@@ -5,18 +5,21 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System;
 using Squidex.Domain.Apps.Core.ValidateContent;
+using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Assets
 {
     public interface IAssetEntity :
         IEntity,
-        IEntityWithAppRef,
         IEntityWithCreatedBy,
         IEntityWithLastModifiedBy,
         IEntityWithVersion,
         IAssetInfo
     {
+        NamedId<Guid> AppId { get; }
+
         string MimeType { get; }
 
         long FileVersion { get; }

src/Squidex.Domain.Apps.Entities/Assets/State/AssetState.cs

@@ -10,6 +10,7 @@ using Newtonsoft.Json;
 using Squidex.Domain.Apps.Core.ValidateContent;
 using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Assets;
+using Squidex.Infrastructure;
 using Squidex.Infrastructure.Dispatching;
 using Squidex.Infrastructure.EventSourcing;
 using Squidex.Infrastructure.Reflection;
@@ -18,11 +19,10 @@ namespace Squidex.Domain.Apps.Entities.Assets.State
 {
     public class AssetState : DomainObjectState<AssetState>,
         IAssetEntity,
-        IAssetInfo,
-        IUpdateableEntityWithAppRef
+        IAssetInfo
     {
         [JsonProperty]
-        public Guid AppId { get; set; }
+        public NamedId<Guid> AppId { get; set; }
 
         [JsonProperty]
         public string FileName { get; set; }
@@ -61,6 +61,8 @@ namespace Squidex.Domain.Apps.Entities.Assets.State
             SimpleMapper.Map(@event, this);
 
             TotalSize += @event.FileSize;
+
+            AppId = @event.AppId;
         }
 
         protected void On(AssetUpdated @event)

src/Squidex.Domain.Apps.Entities/Contents/Commands/ContentCommand.cs

@@ -10,7 +10,7 @@ using Squidex.Infrastructure.Commands;
 
 namespace Squidex.Domain.Apps.Entities.Contents.Commands
 {
-    public abstract class ContentCommand : SchemaCommand, IAggregateCommand
+    public abstract class ContentCommand : SquidexCommand, IAggregateCommand
     {
         public Guid ContentId { get; set; }
 

src/Squidex.Domain.Apps.Entities/Contents/Commands/CreateContent.cs

@@ -6,11 +6,16 @@
 // ==========================================================================
 
 using System;
+using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Contents.Commands
 {
-    public sealed class CreateContent : ContentDataCommand
+    public sealed class CreateContent : ContentDataCommand, ISchemaCommand, IAppCommand
     {
+        public NamedId<Guid> AppId { get; set; }
+
+        public NamedId<Guid> SchemaId { get; set; }
+
         public bool Publish { get; set; }
 
         public CreateContent()

src/Squidex.Domain.Apps.Entities/IUpdateableEntityWithAppRef.cs → src/Squidex.Domain.Apps.Entities/Contents/Commands/PublishContentAt.cs

@@ -7,10 +7,10 @@
 
 using System;
 
-namespace Squidex.Domain.Apps.Entities
+namespace Squidex.Domain.Apps.Entities.Contents.Commands
 {
-    public interface IUpdateableEntityWithAppRef
+    public sealed class PublishContentAt : ContentDataCommand
     {
-        Guid AppId { get; set; }
+        public DateTimeOffset PublishAt { get; set; }
     }
 }

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

@@ -131,6 +131,16 @@ namespace Squidex.Domain.Apps.Entities.Contents
             });
         }
 
+        protected Task On(PublishContentAt command, CommandContext context)
+        {
+            return handler.UpdateAsync<ContentDomainObject>(context, content =>
+            {
+                GuardContent.CanPublishAt(command);
+
+                content.PublishAt(command);
+            });
+        }
+
         public async Task HandleAsync(CommandContext context, Func<Task> next)
         {
             await this.DispatchActionAsync(context.Command, context);

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

@@ -8,6 +8,7 @@
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Entities.Contents.Commands;
 using Squidex.Domain.Apps.Entities.Contents.State;
+using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Contents;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Commands;
@@ -50,6 +51,15 @@ namespace Squidex.Domain.Apps.Entities.Contents
             return this;
         }
 
+        public ContentDomainObject PublishAt(PublishContentAt command)
+        {
+            VerifyCreatedAndNotDeleted();
+
+            RaiseEvent(SimpleMapper.Map(command, new ContentPublishScheduled()));
+
+            return this;
+        }
+
         public ContentDomainObject Update(UpdateContent command)
         {
             VerifyCreatedAndNotDeleted();
@@ -80,6 +90,21 @@ namespace Squidex.Domain.Apps.Entities.Contents
             return this;
         }
 
+        private void RaiseEvent(SchemaEvent @event)
+        {
+            if (@event.AppId == null)
+            {
+                @event.AppId = Snapshot.AppId;
+            }
+
+            if (@event.SchemaId == null)
+            {
+                @event.SchemaId = Snapshot.SchemaId;
+            }
+
+            RaiseEvent(Envelope.Create(@event));
+        }
+
         private void VerifyNotCreated()
         {
             if (Snapshot.Data != null)

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

@@ -18,7 +18,9 @@ namespace Squidex.Domain.Apps.Entities.Contents
     {
         public Guid Id { get; set; }
 
-        public Guid AppId { get; set; }
+        public NamedId<Guid> AppId { get; set; }
+
+        public NamedId<Guid> SchemaId { get; set; }
 
         public long Version { get; set; }
 
@@ -26,6 +28,10 @@ namespace Squidex.Domain.Apps.Entities.Contents
 
         public Instant LastModified { get; set; }
 
+        public Instant? PublishAt { get; set; }
+
+        public RefToken PublishAtBy { get; set; }
+
         public RefToken CreatedBy { get; set; }
 
         public RefToken LastModifiedBy { get; set; }

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

@@ -42,7 +42,16 @@ namespace Squidex.Domain.Apps.Entities.Contents
             IScriptEngine scriptEngine,
             Func<string> message)
         {
-            var (appEntity, schemaEntity) = await appProvider.GetAppWithSchemaAsync(command.AppId.Id, command.SchemaId.Id);
+            var a = content.Snapshot.AppId;
+            var s = content.Snapshot.SchemaId;
+
+            if (command is CreateContent createContent)
+            {
+                a = a ?? createContent.AppId;
+                s = s ?? createContent.SchemaId;
+            }
+
+            var (appEntity, schemaEntity) = await appProvider.GetAppWithSchemaAsync(a.Id, s.Id);
 
             var context = new ContentOperationContext
             {
@@ -75,17 +84,15 @@ namespace Squidex.Domain.Apps.Entities.Contents
             {
                 var errors = new List<ValidationError>();
 
-                var appId = command.AppId.Id;
-
                 var ctx =
                     new ValidationContext(
                         (contentIds, schemaId) =>
                         {
-                            return QueryContentsAsync(appId, schemaId, contentIds);
+                            return QueryContentsAsync(content.Snapshot.AppId.Id, schemaId, contentIds);
                         },
                         assetIds =>
                         {
-                            return QueryAssetsAsync(appId, assetIds);
+                            return QueryAssetsAsync(content.Snapshot.AppId.Id, assetIds);
                         });
 
                 if (partial)

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

@@ -0,0 +1,58 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System.Threading.Tasks;
+using NodaTime;
+using Squidex.Domain.Apps.Core.Contents;
+using Squidex.Domain.Apps.Entities.Contents.Commands;
+using Squidex.Domain.Apps.Entities.Contents.Repositories;
+using Squidex.Infrastructure;
+using Squidex.Infrastructure.Commands;
+using Squidex.Infrastructure.Timers;
+
+namespace Squidex.Domain.Apps.Entities.Contents
+{
+    public sealed class ContentPublisher : IRunnable
+    {
+        private readonly CompletionTimer timer;
+        private readonly IContentRepository contentRepository;
+        private readonly ICommandBus commandBus;
+        private readonly IClock clock;
+
+        public ContentPublisher(
+            IContentRepository contentRepository,
+            ICommandBus commandBus,
+            IClock clock)
+        {
+            Guard.NotNull(contentRepository, nameof(contentRepository));
+            Guard.NotNull(commandBus, nameof(commandBus));
+            Guard.NotNull(clock, nameof(clock));
+
+            this.contentRepository = contentRepository;
+            this.commandBus = commandBus;
+            this.clock = clock;
+
+            timer = new CompletionTimer(5000, x => PublishAsync());
+        }
+
+        public void Run()
+        {
+        }
+
+        private Task PublishAsync()
+        {
+            var now = clock.GetCurrentInstant();
+
+            return contentRepository.QueryContentToPublishAsync(now, content =>
+            {
+                var command = new ChangeContentStatus { ContentId = content.Id, Status = Status.Published, Actor = content.PublishAtBy };
+
+                return commandBus.PublishAsync(command);
+            });
+        }
+    }
+}

src/Squidex.Domain.Apps.Entities/Contents/GraphQL/Types/AppMutationsGraphType.cs

@@ -38,13 +38,13 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
                 var inputType = new ContentDataGraphInputType(model, schema);
 
                 AddContentCreate(schemaId, schemaType, schemaName, inputType, contentDataType, contentType);
-                AddContentUpdate(schemaId, schemaType, schemaName, inputType, resultType);
-                AddContentPatch(schemaId, schemaType, schemaName, inputType, resultType);
-                AddContentPublish(schemaId, schemaType, schemaName);
-                AddContentUnpublish(schemaId, schemaType, schemaName);
-                AddContentArchive(schemaId, schemaType, schemaName);
-                AddContentRestore(schemaId, schemaType, schemaName);
-                AddContentDelete(schemaId, schemaType, schemaName);
+                AddContentUpdate(schemaType, schemaName, inputType, resultType);
+                AddContentPatch(schemaType, schemaName, inputType, resultType);
+                AddContentPublish(schemaType, schemaName);
+                AddContentUnpublish(schemaType, schemaName);
+                AddContentArchive(schemaType, schemaName);
+                AddContentRestore(schemaType, schemaName);
+                AddContentDelete(schemaType, schemaName);
             }
 
             Description = "The app mutations.";
@@ -86,7 +86,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
 
                     var contentData = GetContentData(c);
 
-                    var command = new CreateContent { SchemaId = schemaId, ContentId = Guid.NewGuid(), Data = contentData, Publish = argPublish };
+                    var command = new CreateContent { SchemaId = schemaId, Data = contentData, Publish = argPublish };
                     var commandContext = await publish(command);
 
                     var result = commandContext.Result<EntityCreatedResult<NamedContentData>>();
@@ -98,7 +98,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
             });
         }
 
-        private void AddContentUpdate(NamedId<Guid> schemaId, string schemaType, string schemaName, ContentDataGraphInputType inputType, IComplexGraphType resultType)
+        private void AddContentUpdate(string schemaType, string schemaName, ContentDataGraphInputType inputType, IComplexGraphType resultType)
         {
             AddField(new FieldType
             {
@@ -133,7 +133,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
                     var contentId = c.GetArgument<Guid>("id");
                     var contentData = GetContentData(c);
 
-                    var command = new UpdateContent { SchemaId = schemaId, ContentId = contentId, Data = contentData };
+                    var command = new UpdateContent { ContentId = contentId, Data = contentData };
                     var commandContext = await publish(command);
 
                     var result = commandContext.Result<ContentDataChangedResult>();
@@ -144,7 +144,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
             });
         }
 
-        private void AddContentPatch(NamedId<Guid> schemaId, string schemaType, string schemaName, ContentDataGraphInputType inputType, IComplexGraphType resultType)
+        private void AddContentPatch(string schemaType, string schemaName, ContentDataGraphInputType inputType, IComplexGraphType resultType)
         {
             AddField(new FieldType
             {
@@ -179,7 +179,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
                     var contentId = c.GetArgument<Guid>("id");
                     var contentData = GetContentData(c);
 
-                    var command = new PatchContent { SchemaId = schemaId, ContentId = contentId, Data = contentData };
+                    var command = new PatchContent { ContentId = contentId, Data = contentData };
                     var commandContext = await publish(command);
 
                     var result = commandContext.Result<ContentDataChangedResult>();
@@ -190,7 +190,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
             });
         }
 
-        private void AddContentPublish(NamedId<Guid> schemaId, string schemaType, string schemaName)
+        private void AddContentPublish(string schemaType, string schemaName)
         {
             AddField(new FieldType
             {
@@ -201,7 +201,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
                 {
                     var contentId = c.GetArgument<Guid>("id");
 
-                    var command = new ChangeContentStatus { SchemaId = schemaId, ContentId = contentId, Status = Status.Published };
+                    var command = new ChangeContentStatus { ContentId = contentId, Status = Status.Published };
 
                     return publish(command);
                 }),
@@ -209,7 +209,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
             });
         }
 
-        private void AddContentUnpublish(NamedId<Guid> schemaId, string schemaType, string schemaName)
+        private void AddContentUnpublish(string schemaType, string schemaName)
         {
             AddField(new FieldType
             {
@@ -220,7 +220,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
                 {
                     var contentId = c.GetArgument<Guid>("id");
 
-                    var command = new ChangeContentStatus { SchemaId = schemaId, ContentId = contentId, Status = Status.Draft };
+                    var command = new ChangeContentStatus { ContentId = contentId, Status = Status.Draft };
 
                     return publish(command);
                 }),
@@ -228,7 +228,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
             });
         }
 
-        private void AddContentArchive(NamedId<Guid> schemaId, string schemaType, string schemaName)
+        private void AddContentArchive(string schemaType, string schemaName)
         {
             AddField(new FieldType
             {
@@ -239,7 +239,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
                 {
                     var contentId = c.GetArgument<Guid>("id");
 
-                    var command = new ChangeContentStatus { SchemaId = schemaId, ContentId = contentId, Status = Status.Archived };
+                    var command = new ChangeContentStatus { ContentId = contentId, Status = Status.Archived };
 
                     return publish(command);
                 }),
@@ -247,7 +247,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
             });
         }
 
-        private void AddContentRestore(NamedId<Guid> schemaId, string schemaType, string schemaName)
+        private void AddContentRestore(string schemaType, string schemaName)
         {
             AddField(new FieldType
             {
@@ -258,7 +258,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
                 {
                     var contentId = c.GetArgument<Guid>("id");
 
-                    var command = new ChangeContentStatus { SchemaId = schemaId, ContentId = contentId, Status = Status.Draft };
+                    var command = new ChangeContentStatus { ContentId = contentId, Status = Status.Draft };
 
                     return publish(command);
                 }),
@@ -266,7 +266,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
             });
         }
 
-        private void AddContentDelete(NamedId<Guid> schemaId, string schemaType, string schemaName)
+        private void AddContentDelete(string schemaType, string schemaName)
         {
             AddField(new FieldType
             {
@@ -277,7 +277,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types
                 {
                     var contentId = c.GetArgument<Guid>("id");
 
-                    var command = new DeleteContent { SchemaId = schemaId, ContentId = contentId };
+                    var command = new DeleteContent { ContentId = contentId };
 
                     return publish(command);
                 }),

src/Squidex.Domain.Apps.Entities/Contents/Guards/GuardContent.cs

@@ -5,6 +5,7 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Entities.Contents.Commands;
 using Squidex.Infrastructure;
@@ -65,6 +66,19 @@ namespace Squidex.Domain.Apps.Entities.Contents.Guards
             });
         }
 
+        public static void CanPublishAt(PublishContentAt command)
+        {
+            Guard.NotNull(command, nameof(command));
+
+            Validate.It(() => "Cannot schedule content tol publish.", error =>
+            {
+                if (command.PublishAt < DateTime.UtcNow)
+                {
+                    error(new ValidationError("Date must be in the future.", nameof(command.PublishAt)));
+                }
+            });
+        }
+
         public static void CanDelete(DeleteContent command)
         {
             Guard.NotNull(command, nameof(command));

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

@@ -6,19 +6,29 @@
 // ==========================================================================
 // ==========================================================================
 
+using System;
+using NodaTime;
 using Squidex.Domain.Apps.Core.Contents;
+using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Contents
 {
     public interface IContentEntity :
         IEntity,
-        IEntityWithAppRef,
         IEntityWithCreatedBy,
         IEntityWithLastModifiedBy,
         IEntityWithVersion
     {
+        NamedId<Guid> AppId { get; }
+
+        NamedId<Guid> SchemaId { get; }
+
         Status Status { get; }
 
+        Instant? PublishAt { get; }
+
+        RefToken PublishAtBy { get; }
+
         NamedContentData Data { get; }
     }
 }

src/Squidex.Domain.Apps.Entities/Contents/Repositories/IContentRepository.cs

@@ -9,6 +9,7 @@ using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.OData.UriParser;
+using NodaTime;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Entities.Apps;
 using Squidex.Domain.Apps.Entities.Schemas;
@@ -27,5 +28,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Repositories
         Task<IContentEntity> FindContentAsync(IAppEntity app, ISchemaEntity schema, Guid id);
 
         Task<IContentEntity> FindContentAsync(IAppEntity app, ISchemaEntity schema, Guid id, long version);
+
+        Task QueryContentToPublishAsync(Instant now, Func<IContentEntity, Task> callback);
     }
 }

src/Squidex.Domain.Apps.Entities/Contents/State/ContentState.cs

@@ -7,38 +7,47 @@
 
 using System;
 using Newtonsoft.Json;
+using NodaTime;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Contents;
+using Squidex.Infrastructure;
 using Squidex.Infrastructure.Dispatching;
 using Squidex.Infrastructure.EventSourcing;
 
 namespace Squidex.Domain.Apps.Entities.Contents.State
 {
     public class ContentState : DomainObjectState<ContentState>,
-        IContentEntity,
-        IUpdateableEntityWithAppRef
+        IContentEntity
     {
         [JsonProperty]
-        public NamedContentData Data { get; set; }
+        public NamedId<Guid> AppId { get; set; }
 
         [JsonProperty]
-        public Guid AppId { get; set; }
+        public NamedId<Guid> SchemaId { get; set; }
 
         [JsonProperty]
-        public Guid SchemaId { get; set; }
+        public NamedContentData Data { get; set; }
 
         [JsonProperty]
         public Status Status { get; set; }
 
+        [JsonProperty]
+        public RefToken PublishAtBy { get; set; }
+
+        [JsonProperty]
+        public Instant? PublishAt { get; set; }
+
         [JsonProperty]
         public bool IsDeleted { get; set; }
 
         protected void On(ContentCreated @event)
         {
-            SchemaId = @event.SchemaId.Id;
+            SchemaId = @event.SchemaId;
 
             Data = @event.Data;
+
+            AppId = @event.AppId;
         }
 
         protected void On(ContentUpdated @event)
@@ -46,9 +55,18 @@ namespace Squidex.Domain.Apps.Entities.Contents.State
             Data = @event.Data;
         }
 
+        protected void On(ContentPublishScheduled @event)
+        {
+            PublishAt = @event.PublishAt;
+            PublishAtBy = @event.Actor;
+        }
+
         protected void On(ContentStatusChanged @event)
         {
             Status = @event.Status;
+
+            PublishAt = null;
+            PublishAtBy = null;
         }
 
         protected void On(ContentDeleted @event)

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

@@ -17,7 +17,6 @@ namespace Squidex.Domain.Apps.Entities
         public static T Update<T>(this T entity, SquidexEvent @event, EnvelopeHeaders headers, Action<T> updater = null) where T : IEntity
         {
             SetId(entity, headers);
-            SetAppId(entity, @event);
             SetCreated(entity, headers);
             SetCreatedBy(entity, @event);
             SetLastModified(entity, headers);
@@ -76,13 +75,5 @@ namespace Squidex.Domain.Apps.Entities
                 withModifiedBy.LastModifiedBy = @event.Actor;
             }
         }
-
-        private static void SetAppId(IEntity entity, SquidexEvent @event)
-        {
-            if (entity is IUpdateableEntityWithAppRef appEntity && @event is AppEvent appEvent)
-            {
-                appEntity.AppId = appEvent.AppId.Id;
-            }
-        }
     }
 }

src/Squidex.Domain.Apps.Entities/AppCommand.cs → src/Squidex.Domain.Apps.Entities/IAppCommand.cs

@@ -1,17 +1,18 @@
 // ==========================================================================
 //  Squidex Headless CMS
 // ==========================================================================
-//  Copyright (c) Squidex UG (haftungsbeschränkt)
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
 using System;
 using Squidex.Infrastructure;
+using Squidex.Infrastructure.Commands;
 
 namespace Squidex.Domain.Apps.Entities
 {
-    public abstract class AppCommand : SquidexCommand
+    public interface IAppCommand : ICommand
     {
-        public NamedId<Guid> AppId { get; set; }
+        NamedId<Guid> AppId { get; set; }
     }
 }

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

@@ -1,16 +0,0 @@
-// ==========================================================================
-//  Squidex Headless CMS
-// ==========================================================================
-//  Copyright (c) Squidex UG (haftungsbeschränkt)
-//  All rights reserved. Licensed under the MIT license.
-// ==========================================================================
-
-using System;
-
-namespace Squidex.Domain.Apps.Entities
-{
-    public interface IEntityWithAppRef
-    {
-        Guid AppId { get; }
-    }
-}

src/Squidex.Domain.Apps.Entities/SchemaCommand.cs → src/Squidex.Domain.Apps.Entities/ISchemaCommand.cs

@@ -1,17 +1,18 @@
 // ==========================================================================
 //  Squidex Headless CMS
 // ==========================================================================
-//  Copyright (c) Squidex UG (haftungsbeschränkt)
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
 using System;
 using Squidex.Infrastructure;
+using Squidex.Infrastructure.Commands;
 
 namespace Squidex.Domain.Apps.Entities
 {
-    public abstract class SchemaCommand : AppCommand
+    public interface ISchemaCommand : ICommand
     {
-        public NamedId<Guid> SchemaId { get; set; }
+        NamedId<Guid> SchemaId { get; set; }
     }
 }

src/Squidex.Domain.Apps.Entities/Rules/Commands/CreateRule.cs

@@ -6,11 +6,14 @@
 // ==========================================================================
 
 using System;
+using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Rules.Commands
 {
-    public sealed class CreateRule : RuleEditCommand
+    public sealed class CreateRule : RuleEditCommand, IAppCommand
     {
+        public NamedId<Guid> AppId { get; set; }
+
         public CreateRule()
         {
             RuleId = Guid.NewGuid();

src/Squidex.Domain.Apps.Entities/Rules/Commands/DeleteRule.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Rules.Commands
 {
-    public sealed class DeleteRule : RuleAggregateCommand
+    public sealed class DeleteRule : RuleCommand
     {
     }
 }

src/Squidex.Domain.Apps.Entities/Rules/Commands/DisableRule.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Rules.Commands
 {
-    public sealed class DisableRule : RuleAggregateCommand
+    public sealed class DisableRule : RuleCommand
     {
     }
 }

src/Squidex.Domain.Apps.Entities/Rules/Commands/EnableRule.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Rules.Commands
 {
-    public sealed class EnableRule : RuleAggregateCommand
+    public sealed class EnableRule : RuleCommand
     {
     }
 }

src/Squidex.Domain.Apps.Entities/Rules/Commands/RuleAggregateCommand.cs → src/Squidex.Domain.Apps.Entities/Rules/Commands/RuleCommand.cs

@@ -10,7 +10,7 @@ using Squidex.Infrastructure.Commands;
 
 namespace Squidex.Domain.Apps.Entities.Rules.Commands
 {
-    public abstract class RuleAggregateCommand : AppCommand, IAggregateCommand
+    public abstract class RuleCommand : SquidexCommand, IAggregateCommand
     {
         public Guid RuleId { get; set; }
 

src/Squidex.Domain.Apps.Entities/Rules/Commands/RuleEditCommand.cs

@@ -9,7 +9,7 @@ using Squidex.Domain.Apps.Core.Rules;
 
 namespace Squidex.Domain.Apps.Entities.Rules.Commands
 {
-    public abstract class RuleEditCommand : RuleAggregateCommand
+    public abstract class RuleEditCommand : RuleCommand
     {
         public RuleTrigger Trigger { get; set; }
 

src/Squidex.Domain.Apps.Entities/Rules/Guards/GuardRule.cs

@@ -5,6 +5,7 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System;
 using System.Threading.Tasks;
 using Squidex.Domain.Apps.Core.Rules;
 using Squidex.Domain.Apps.Entities.Rules.Commands;
@@ -44,7 +45,7 @@ namespace Squidex.Domain.Apps.Entities.Rules.Guards
             });
         }
 
-        public static Task CanUpdate(UpdateRule command, IAppProvider appProvider)
+        public static Task CanUpdate(UpdateRule command, Guid appId, IAppProvider appProvider)
         {
             Guard.NotNull(command, nameof(command));
 
@@ -57,7 +58,7 @@ namespace Squidex.Domain.Apps.Entities.Rules.Guards
 
                 if (command.Trigger != null)
                 {
-                    var errors = await RuleTriggerValidator.ValidateAsync(command.AppId.Id, command.Trigger, appProvider);
+                    var errors = await RuleTriggerValidator.ValidateAsync(appId, command.Trigger, appProvider);
 
                     errors.Foreach(error);
                 }

src/Squidex.Domain.Apps.Entities/Rules/IRuleEntity.cs

@@ -5,17 +5,20 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System;
 using Squidex.Domain.Apps.Core.Rules;
+using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Rules
 {
     public interface IRuleEntity :
         IEntity,
-        IEntityWithAppRef,
         IEntityWithCreatedBy,
         IEntityWithLastModifiedBy,
         IEntityWithVersion
     {
+        NamedId<Guid> AppId { get; set; }
+
         Rule RuleDef { get; }
     }
 }

src/Squidex.Domain.Apps.Entities/Rules/RuleCommandMiddleware.cs

@@ -44,7 +44,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
         {
             return handler.UpdateSyncedAsync<RuleDomainObject>(context, async r =>
             {
-                await GuardRule.CanUpdate(command, appProvider);
+                await GuardRule.CanUpdate(command, r.Snapshot.AppId.Id, appProvider);
 
                 r.Update(command);
             });

src/Squidex.Domain.Apps.Entities/Rules/RuleDomainObject.cs

@@ -7,6 +7,7 @@
 
 using Squidex.Domain.Apps.Entities.Rules.Commands;
 using Squidex.Domain.Apps.Entities.Rules.State;
+using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Rules;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Commands;
@@ -52,6 +53,16 @@ namespace Squidex.Domain.Apps.Entities.Rules
             RaiseEvent(SimpleMapper.Map(command, new RuleDeleted()));
         }
 
+        private void RaiseEvent(AppEvent @event)
+        {
+            if (@event.AppId == null)
+            {
+                @event.AppId = Snapshot.AppId;
+            }
+
+            RaiseEvent(Envelope.Create(@event));
+        }
+
         private void VerifyNotCreated()
         {
             if (Snapshot.RuleDef != null)

src/Squidex.Domain.Apps.Entities/Rules/State/RuleState.cs

@@ -10,18 +10,17 @@ using Newtonsoft.Json;
 using Squidex.Domain.Apps.Core.Rules;
 using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Rules;
+using Squidex.Infrastructure;
 using Squidex.Infrastructure.Dispatching;
 using Squidex.Infrastructure.EventSourcing;
 
 namespace Squidex.Domain.Apps.Entities.Rules.State
 {
     public class RuleState : DomainObjectState<RuleState>,
-        IRuleEntity,
-        IEntityWithAppRef,
-        IUpdateableEntityWithAppRef
+        IRuleEntity
     {
         [JsonProperty]
-        public Guid AppId { get; set; }
+        public NamedId<Guid> AppId { get; set; }
 
         [JsonProperty]
         public Rule RuleDef { get; set; }
@@ -32,6 +31,8 @@ namespace Squidex.Domain.Apps.Entities.Rules.State
         protected void On(RuleCreated @event)
         {
             RuleDef = new Rule(@event.Trigger, @event.Action);
+
+            AppId = @event.AppId;
         }
 
         protected void On(RuleUpdated @event)

src/Squidex.Domain.Apps.Entities/Schemas/Commands/AddField.cs

@@ -9,7 +9,7 @@ using Squidex.Domain.Apps.Core.Schemas;
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public sealed class AddField : SchemaAggregateCommand
+    public sealed class AddField : SchemaCommand
     {
         public string Name { get; set; }
 

src/Squidex.Domain.Apps.Entities/Schemas/Commands/ConfigureScripts.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public sealed class ConfigureScripts : SchemaAggregateCommand
+    public sealed class ConfigureScripts : SchemaCommand
     {
         public string ScriptQuery { get; set; }
 

src/Squidex.Domain.Apps.Entities/Schemas/Commands/CreateSchema.cs

@@ -7,14 +7,16 @@
 
 using System;
 using Squidex.Domain.Apps.Core.Schemas;
-using Squidex.Infrastructure.Commands;
+using Squidex.Infrastructure;
 using SchemaFields = System.Collections.Generic.List<Squidex.Domain.Apps.Entities.Schemas.Commands.CreateSchemaField>;
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public sealed class CreateSchema : AppCommand, IAggregateCommand
+    public sealed class CreateSchema : SchemaCommand, IAppCommand
     {
-        public Guid SchemaId { get; set; }
+        public NamedId<Guid> AppId { get; set; }
+
+        public string Name { get; set; }
 
         public SchemaFields Fields { get; set; }
 
@@ -22,13 +24,6 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 
         public bool Publish { get; set; }
 
-        public string Name { get; set; }
-
-        Guid IAggregateCommand.AggregateId
-        {
-            get { return SchemaId; }
-        }
-
         public CreateSchema()
         {
             SchemaId = Guid.NewGuid();

src/Squidex.Domain.Apps.Entities/Schemas/Commands/DeleteSchema.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public sealed class DeleteSchema : SchemaAggregateCommand
+    public sealed class DeleteSchema : SchemaCommand
     {
     }
 }

src/Squidex.Domain.Apps.Entities/Schemas/Commands/FieldCommand.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public class FieldCommand : SchemaAggregateCommand
+    public class FieldCommand : SchemaCommand
     {
         public long FieldId { get; set; }
     }

src/Squidex.Domain.Apps.Entities/Schemas/Commands/PublishSchema.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public sealed class PublishSchema : SchemaAggregateCommand
+    public sealed class PublishSchema : SchemaCommand
     {
     }
 }

src/Squidex.Domain.Apps.Entities/Schemas/Commands/ReorderFields.cs

@@ -9,7 +9,7 @@ using System.Collections.Generic;
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public sealed class ReorderFields : SchemaAggregateCommand
+    public sealed class ReorderFields : SchemaCommand
     {
         public List<long> FieldIds { get; set; }
     }

src/Squidex.Domain.Apps.Entities/AppAggregateCommand.cs → src/Squidex.Domain.Apps.Entities/Schemas/Commands/SchemaCommand.cs

@@ -10,11 +10,13 @@ using Squidex.Infrastructure.Commands;
 
 namespace Squidex.Domain.Apps.Entities
 {
-    public class AppAggregateCommand : AppCommand, IAggregateCommand
+    public abstract class SchemaCommand : SquidexCommand, IAggregateCommand
     {
+        public Guid SchemaId { get; set; }
+
         Guid IAggregateCommand.AggregateId
         {
-            get { return AppId.Id; }
+            get { return SchemaId; }
         }
     }
 }

src/Squidex.Domain.Apps.Entities/Schemas/Commands/UnpublishSchema.cs

@@ -7,7 +7,7 @@
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public sealed class UnpublishSchema : SchemaAggregateCommand
+    public sealed class UnpublishSchema : SchemaCommand
     {
     }
 }

src/Squidex.Domain.Apps.Entities/Schemas/Commands/UpdateSchema.cs

@@ -9,7 +9,7 @@ using Squidex.Domain.Apps.Core.Schemas;
 
 namespace Squidex.Domain.Apps.Entities.Schemas.Commands
 {
-    public sealed class UpdateSchema : SchemaAggregateCommand
+    public sealed class UpdateSchema : SchemaCommand
     {
         public SchemaProperties Properties { get; set; }
     }

src/Squidex.Domain.Apps.Entities/Schemas/ISchemaEntity.cs

@@ -5,17 +5,20 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System;
 using Squidex.Domain.Apps.Core.Schemas;
+using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.Schemas
 {
     public interface ISchemaEntity :
         IEntity,
-        IEntityWithAppRef,
         IEntityWithCreatedBy,
         IEntityWithLastModifiedBy,
         IEntityWithVersion
     {
+        NamedId<Guid> AppId { get; }
+
         string Name { get; }
 
         bool IsPublished { get; }

src/Squidex.Domain.Apps.Entities/Schemas/SchemaDomainObject.cs

@@ -10,6 +10,7 @@ using System.Collections.Generic;
 using Squidex.Domain.Apps.Core.Schemas;
 using Squidex.Domain.Apps.Entities.Schemas.Commands;
 using Squidex.Domain.Apps.Entities.Schemas.State;
+using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Schemas;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Commands;
@@ -190,6 +191,21 @@ namespace Squidex.Domain.Apps.Entities.Schemas
             RaiseEvent(@event);
         }
 
+        private void RaiseEvent(SchemaEvent @event)
+        {
+            if (@event.SchemaId == null)
+            {
+                @event.SchemaId = new NamedId<Guid>(Snapshot.Id, Snapshot.Name);
+            }
+
+            if (@event.AppId == null)
+            {
+                @event.AppId = Snapshot.AppId;
+            }
+
+            RaiseEvent(Envelope.Create(@event));
+        }
+
         private void VerifyNotCreated()
         {
             if (Snapshot.SchemaDef != null)

src/Squidex.Domain.Apps.Entities/Schemas/State/SchemaState.cs

@@ -11,6 +11,7 @@ using Squidex.Domain.Apps.Core;
 using Squidex.Domain.Apps.Core.Schemas;
 using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Schemas;
+using Squidex.Infrastructure;
 using Squidex.Infrastructure.Dispatching;
 using Squidex.Infrastructure.EventSourcing;
 using Squidex.Infrastructure.Reflection;
@@ -18,16 +19,13 @@ using Squidex.Infrastructure.Reflection;
 namespace Squidex.Domain.Apps.Entities.Schemas.State
 {
     public class SchemaState : DomainObjectState<SchemaState>,
-        ISchemaEntity,
-        IUpdateableEntityWithAppRef,
-        IUpdateableEntityWithCreatedBy,
-        IUpdateableEntityWithLastModifiedBy
+        ISchemaEntity
     {
         [JsonProperty]
-        public string Name { get; set; }
+        public NamedId<Guid> AppId { get; set; }
 
         [JsonProperty]
-        public Guid AppId { get; set; }
+        public string Name { get; set; }
 
         [JsonProperty]
         public int TotalFields { get; set; } = 0;
@@ -108,6 +106,8 @@ namespace Squidex.Domain.Apps.Entities.Schemas.State
             }
 
             SchemaDef = schema;
+
+            AppId = @event.AppId;
         }
 
         protected void On(FieldAdded @event, FieldRegistry registry)

src/Squidex.Domain.Apps.Events/Contents/ContentPublishScheduled.cs

@@ -0,0 +1,18 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschränkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using NodaTime;
+using Squidex.Infrastructure.EventSourcing;
+
+namespace Squidex.Domain.Apps.Events.Contents
+{
+    [EventType(nameof(ContentPublishScheduled))]
+    public sealed class ContentPublishScheduled : ContentEvent
+    {
+        public Instant PublishAt { get; set; }
+    }
+}

src/Squidex/Config/Authentication/MicrosoftHandler.cs

@@ -5,7 +5,6 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
-using System.Security.Claims;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authentication.OAuth;
 using Squidex.Shared.Identity;

src/Squidex/Pipeline/CommandMiddlewares/EnrichWithAppIdCommandMiddleware.cs

@@ -25,7 +25,7 @@ namespace Squidex.Pipeline.CommandMiddlewares
 
         public Task HandleAsync(CommandContext context, Func<Task> next)
         {
-            if (context.Command is AppCommand appCommand && appCommand.AppId == null)
+            if (context.Command is IAppCommand appCommand && appCommand.AppId == null)
             {
                 var appFeature = httpContextAccessor.HttpContext.Features.Get<IAppFeature>();
 

src/Squidex/Pipeline/CommandMiddlewares/EnrichWithSchemaIdCommandMiddleware.cs

@@ -29,8 +29,30 @@ namespace Squidex.Pipeline.CommandMiddlewares
 
         public async Task HandleAsync(CommandContext context, Func<Task> next)
         {
-            if (context.Command is SchemaCommand schemaCommand && schemaCommand.SchemaId == null)
+            if (context.Command is ISchemaCommand schemaCommand && schemaCommand.SchemaId == null)
             {
+                NamedId<Guid> appId = null;
+
+                if (context.Command is IAppCommand appCommand)
+                {
+                    appId = appCommand.AppId;
+                }
+
+                if (appId == null)
+                {
+                    var appFeature = actionContextAccessor.ActionContext.HttpContext.Features.Get<IAppFeature>();
+
+                    if (appFeature != null && appFeature.App != null)
+                    {
+                        appId = new NamedId<Guid>(appFeature.App.Id, appFeature.App.Name);
+                    }
+                }
+
+                if (appId == null)
+                {
+                    return;
+                }
+
                 var routeValues = actionContextAccessor.ActionContext.RouteData.Values;
 
                 if (routeValues.ContainsKey("name"))
@@ -41,11 +63,11 @@ namespace Squidex.Pipeline.CommandMiddlewares
 
                     if (Guid.TryParse(schemaName, out var id))
                     {
-                        schema = await appProvider.GetSchemaAsync(schemaCommand.AppId.Id, id);
+                        schema = await appProvider.GetSchemaAsync(appId.Id, id);
                     }
                     else
                     {
-                        schema = await appProvider.GetSchemaAsync(schemaCommand.AppId.Id, schemaName);
+                        schema = await appProvider.GetSchemaAsync(appId.Id, schemaName);
                     }
 
                     if (schema == null)

tests/Squidex.Domain.Apps.Entities.Tests/Apps/AppCommandMiddlewareTests.cs

@@ -14,6 +14,7 @@ using Squidex.Domain.Apps.Entities.Apps.Services.Implementations;
 using Squidex.Domain.Apps.Entities.TestHelpers;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Commands;
+using Squidex.Infrastructure.States;
 using Squidex.Shared.Users;
 using Xunit;
 
@@ -46,6 +47,8 @@ namespace Squidex.Domain.Apps.Entities.Apps
                 .Returns(A.Fake<IUser>());
 
             sut = new AppCommandMiddleware(Handler, appProvider, appPlansProvider, appPlansBillingManager, userResolver);
+
+            app.ActivateAsync(Id, A.Fake<IStore<Guid>>());
         }
 
         [Fact]

tests/Squidex.Domain.Apps.Entities.Tests/Apps/AppDomainObjectTests.cs

@@ -8,11 +8,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using FakeItEasy;
 using Squidex.Domain.Apps.Core.Apps;
 using Squidex.Domain.Apps.Entities.Apps.Commands;
 using Squidex.Domain.Apps.Entities.TestHelpers;
 using Squidex.Domain.Apps.Events.Apps;
 using Squidex.Infrastructure;
+using Squidex.Infrastructure.States;
 using Xunit;
 
 namespace Squidex.Domain.Apps.Entities.Apps
@@ -31,6 +33,11 @@ namespace Squidex.Domain.Apps.Entities.Apps
             get { return AppId; }
         }
 
+        public AppDomainObjectTests()
+        {
+            sut.ActivateAsync(Id, A.Fake<IStore<Guid>>());
+        }
+
         [Fact]
         public void Create_should_throw_exception_if_created()
         {

tests/Squidex.Domain.Apps.Entities.Tests/Assets/AssetDomainObjectTests.cs

@@ -7,11 +7,13 @@
 
 using System;
 using System.IO;
+using FakeItEasy;
 using Squidex.Domain.Apps.Entities.Assets.Commands;
 using Squidex.Domain.Apps.Entities.TestHelpers;
 using Squidex.Domain.Apps.Events.Assets;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Assets;
+using Squidex.Infrastructure.States;
 using Xunit;
 
 namespace Squidex.Domain.Apps.Entities.Assets
@@ -28,6 +30,11 @@ namespace Squidex.Domain.Apps.Entities.Assets
             get { return assetId; }
         }
 
+        public AssetDomainObjectTests()
+        {
+            sut.ActivateAsync(Id, A.Fake<IStore<Guid>>());
+        }
+
         [Fact]
         public void Create_should_throw_exception_if_created()
         {
@@ -203,7 +210,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
             return CreateEvent(@event);
         }
 
-        protected T CreateAssetCommand<T>(T command) where T : AssetAggregateCommand
+        protected T CreateAssetCommand<T>(T command) where T : AssetCommand
         {
             command.AssetId = assetId;
 

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

@@ -6,12 +6,14 @@
 // ==========================================================================
 
 using System;
+using FakeItEasy;
 using FluentAssertions;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Entities.Contents.Commands;
 using Squidex.Domain.Apps.Entities.TestHelpers;
 using Squidex.Domain.Apps.Events.Contents;
 using Squidex.Infrastructure;
+using Squidex.Infrastructure.States;
 using Xunit;
 
 namespace Squidex.Domain.Apps.Entities.Contents
@@ -40,6 +42,8 @@ namespace Squidex.Domain.Apps.Entities.Contents
         public ContentDomainObjectTests()
         {
             patched = otherData.MergeInto(data);
+
+            sut.ActivateAsync(Id, A.Fake<IStore<Guid>>());
         }
 
         [Fact]

tests/Squidex.Domain.Apps.Entities.Tests/Contents/GraphQL/GraphQLMutationTests.cs

@@ -11,7 +11,6 @@ using FakeItEasy;
 using Newtonsoft.Json.Linq;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Entities.Contents.Commands;
-using Squidex.Domain.Apps.Entities.Schemas;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Commands;
 using Xunit;
@@ -328,7 +327,6 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 
             A.CallTo(() => commandBus.PublishAsync(
                 A<ChangeContentStatus>.That.Matches(x =>
-                    x.SchemaId.Equals(schema.NamedId()) &&
                     x.ContentId == contentId &&
                     x.Status == Status.Published &&
                     x.ExpectedVersion == 10)))
@@ -364,7 +362,6 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 
             A.CallTo(() => commandBus.PublishAsync(
                 A<ChangeContentStatus>.That.Matches(x =>
-                    x.SchemaId.Equals(schema.NamedId()) &&
                     x.ContentId == contentId &&
                     x.Status == Status.Draft &&
                     x.ExpectedVersion == 10)))
@@ -400,7 +397,6 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 
             A.CallTo(() => commandBus.PublishAsync(
                 A<ChangeContentStatus>.That.Matches(x =>
-                    x.SchemaId.Equals(schema.NamedId()) &&
                     x.ContentId == contentId &&
                     x.Status == Status.Archived &&
                     x.ExpectedVersion == 10)))
@@ -436,7 +432,6 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 
             A.CallTo(() => commandBus.PublishAsync(
                 A<ChangeContentStatus>.That.Matches(x =>
-                    x.SchemaId.Equals(schema.NamedId()) &&
                     x.ContentId == contentId &&
                     x.Status == Status.Draft &&
                     x.ExpectedVersion == 10)))
@@ -472,7 +467,6 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 
             A.CallTo(() => commandBus.PublishAsync(
                 A<DeleteContent>.That.Matches(x =>
-                    x.SchemaId.Equals(schema.NamedId()) &&
                     x.ContentId == contentId &&
                     x.ExpectedVersion == 10)))
                 .MustHaveHappened();

tests/Squidex.Domain.Apps.Entities.Tests/Contents/TestData/FakeAssetEntity.cs

@@ -14,9 +14,9 @@ namespace Squidex.Domain.Apps.Entities.Contents.TestData
 {
     public sealed class FakeAssetEntity : IAssetEntity
     {
-        public Guid Id { get; set; }
+        public NamedId<Guid> AppId { get; set; }
 
-        public Guid AppId { get; set; }
+        public Guid Id { get; set; }
 
         public Guid AssetId { get; set; }
 

tests/Squidex.Domain.Apps.Entities.Tests/Rules/Guards/GuardRuleTests.cs

@@ -87,13 +87,13 @@ namespace Squidex.Domain.Apps.Entities.Rules.Guards
         {
             var command = new UpdateRule();
 
-            await Assert.ThrowsAsync<ValidationException>(() => GuardRule.CanUpdate(command, appProvider));
+            await Assert.ThrowsAsync<ValidationException>(() => GuardRule.CanUpdate(command, appId.Id, appProvider));
         }
 
         [Fact]
         public async Task CanUpdate_should_not_throw_exception_if_trigger_and_action_valid()
         {
-            var command = CreateCommand(new UpdateRule
+            var command = new UpdateRule
             {
                 Trigger = new ContentChangedTrigger
                 {
@@ -103,9 +103,9 @@ namespace Squidex.Domain.Apps.Entities.Rules.Guards
                 {
                     Url = validUrl
                 }
-            });
+            };
 
-            await GuardRule.CanUpdate(command, appProvider);
+            await GuardRule.CanUpdate(command, appId.Id, appProvider);
         }
 
         [Fact]
@@ -156,7 +156,7 @@ namespace Squidex.Domain.Apps.Entities.Rules.Guards
             GuardRule.CanDelete(command);
         }
 
-        private T CreateCommand<T>(T command) where T : AppCommand
+        private CreateRule CreateCommand(CreateRule command)
         {
             command.AppId = appId;
 

tests/Squidex.Domain.Apps.Entities.Tests/Rules/RuleDomainObjectTests.cs

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections.Immutable;
+using FakeItEasy;
 using Squidex.Domain.Apps.Core.Rules;
 using Squidex.Domain.Apps.Core.Rules.Actions;
 using Squidex.Domain.Apps.Core.Rules.Triggers;
@@ -14,6 +15,7 @@ using Squidex.Domain.Apps.Entities.Rules.Commands;
 using Squidex.Domain.Apps.Entities.TestHelpers;
 using Squidex.Domain.Apps.Events.Rules;
 using Squidex.Infrastructure;
+using Squidex.Infrastructure.States;
 using Xunit;
 
 namespace Squidex.Domain.Apps.Entities.Rules
@@ -30,6 +32,11 @@ namespace Squidex.Domain.Apps.Entities.Rules
             get { return ruleId; }
         }
 
+        public RuleDomainObjectTests()
+        {
+            sut.ActivateAsync(Id, A.Fake<IStore<Guid>>());
+        }
+
         [Fact]
         public void Create_should_throw_exception_if_created()
         {
@@ -48,7 +55,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
 
             sut.Create(CreateRuleCommand(command));
 
-            Assert.Equal(AppId, sut.Snapshot.AppId);
+            Assert.Equal(AppId, sut.Snapshot.AppId.Id);
 
             Assert.Same(ruleTrigger, sut.Snapshot.RuleDef.Trigger);
             Assert.Same(ruleAction, sut.Snapshot.RuleDef.Action);
@@ -239,7 +246,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
             return CreateEvent(@event);
         }
 
-        protected T CreateRuleCommand<T>(T command) where T : RuleAggregateCommand
+        protected T CreateRuleCommand<T>(T command) where T : RuleCommand
         {
             command.RuleId = ruleId;
 

tests/Squidex.Domain.Apps.Entities.Tests/Schemas/SchemaDomainObjectTests.cs

@@ -8,11 +8,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using FakeItEasy;
 using Squidex.Domain.Apps.Core.Schemas;
 using Squidex.Domain.Apps.Entities.Schemas.Commands;
 using Squidex.Domain.Apps.Entities.TestHelpers;
 using Squidex.Domain.Apps.Events.Schemas;
 using Squidex.Infrastructure;
+using Squidex.Infrastructure.States;
 using Xunit;
 
 namespace Squidex.Domain.Apps.Entities.Schemas
@@ -35,6 +37,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
             var fieldRegistry = new FieldRegistry(new TypeNameRegistry());
 
             sut = new SchemaDomainObject(fieldRegistry);
+            sut.ActivateAsync(Id, A.Fake<IStore<Guid>>());
         }
 
         [Fact]
@@ -55,7 +58,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
 
             sut.Create(CreateCommand(new CreateSchema { Name = SchemaName, SchemaId = SchemaId, Properties = properties }));
 
-            Assert.Equal(AppId, sut.Snapshot.AppId);
+            Assert.Equal(AppId, sut.Snapshot.AppId.Id);
 
             Assert.Equal(SchemaName, sut.Snapshot.Name);
             Assert.Equal(SchemaName, sut.Snapshot.SchemaDef.Name);
@@ -81,7 +84,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
 
             var @event = (SchemaCreated)sut.GetUncomittedEvents().Single().Payload;
 
-            Assert.Equal(AppId, sut.Snapshot.AppId);
+            Assert.Equal(AppId, sut.Snapshot.AppId.Id);
             Assert.Equal(SchemaName, sut.Snapshot.Name);
             Assert.Equal(SchemaName, sut.Snapshot.SchemaDef.Name);
 

tests/Squidex.Domain.Apps.Entities.Tests/TestHelpers/HandlerTestBase.cs

@@ -134,16 +134,12 @@ namespace Squidex.Domain.Apps.Entities.TestHelpers
                 command.Actor = User;
             }
 
-            var appCommand = command as AppCommand;
-
-            if (appCommand != null && appCommand.AppId == null)
+            if (command is IAppCommand appCommand && appCommand.AppId == null)
             {
                 appCommand.AppId = AppNamedId;
             }
 
-            var schemaCommand = command as SchemaCommand;
-
-            if (schemaCommand != null && schemaCommand.SchemaId == null)
+            if (command is ISchemaCommand schemaCommand && schemaCommand.SchemaId == null)
             {
                 schemaCommand.SchemaId = SchemaNamedId;
             }

tools/Migrate_01/Migration02_AddPatterns.cs

@@ -11,7 +11,6 @@ using System.Threading.Tasks;
 using Squidex.Domain.Apps.Entities.Apps;
 using Squidex.Domain.Apps.Entities.Apps.Commands;
 using Squidex.Domain.Apps.Entities.Apps.Repositories;
-using Squidex.Infrastructure;
 using Squidex.Infrastructure.Migrations;
 using Squidex.Infrastructure.States;
 
@@ -50,7 +49,7 @@ namespace Migrate_01
                             new AddPattern
                             {
                                 Actor = app.Snapshot.CreatedBy,
-                                AppId = new NamedId<Guid>(app.Snapshot.Id, app.Snapshot.Name),
+                                AppId = app.Snapshot.Id,
                                 Name = pattern.Name,
                                 PatternId = Guid.NewGuid(),
                                 Pattern = pattern.Pattern,