Temp

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

@@ -30,11 +30,10 @@ namespace Squidex.Domain.Apps.Entities.Apps
         private readonly IGrainFactory grainFactory;
         private readonly IUserResolver userResolver;
         private readonly IAppsByNameIndex appsByNameIndex;
-        private readonly HashSet<string> activeUsers = new HashSet<string>();
+        private readonly HashSet<string> contributors = new HashSet<string>();
         private Dictionary<string, string> usersWithEmail = new Dictionary<string, string>();
         private Dictionary<string, RefToken> userMapping = new Dictionary<string, RefToken>();
         private bool isReserved;
-        private bool isActorAssigned;
         private string appName;
 
         public override string Name { get; } = "Apps";
@@ -76,7 +75,7 @@ namespace Squidex.Domain.Apps.Entities.Apps
             await WriteSettingsAsync(writer, appId);
         }
 
-        public override async Task RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
+        public override async Task<bool> RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
         {
             switch (@event.Payload)
             {
@@ -92,26 +91,25 @@ namespace Squidex.Domain.Apps.Entities.Apps
 
                 case AppContributorAssigned contributorAssigned:
                     {
-                        if (isActorAssigned)
+                        if (!userMapping.TryGetValue(contributorAssigned.ContributorId, out var user) || user.Equals(actor))
                         {
-                            contributorAssigned.ContributorId = MapUser(contributorAssigned.ContributorId, actor).Identifier;
-                        }
-                        else
-                        {
-                            isActorAssigned = true;
-
-                            contributorAssigned.ContributorId = actor.Identifier;
+                            return false;
                         }
 
-                        activeUsers.Add(contributorAssigned.ContributorId);
+                        contributorAssigned.ContributorId = user.Identifier;
+                        contributors.Add(contributorAssigned.ContributorId);
                         break;
                     }
 
                 case AppContributorRemoved contributorRemoved:
                     {
-                        contributorRemoved.ContributorId = MapUser(contributorRemoved.ContributorId, actor).Identifier;
+                        if (!userMapping.TryGetValue(contributorRemoved.ContributorId, out var user) || user.Equals(actor))
+                        {
+                            return false;
+                        }
 
-                        activeUsers.Remove(contributorRemoved.ContributorId);
+                        contributorRemoved.ContributorId = user.Identifier;
+                        contributors.Remove(contributorRemoved.ContributorId);
                         break;
                     }
             }
@@ -120,6 +118,8 @@ namespace Squidex.Domain.Apps.Entities.Apps
             {
                 squidexEvent.Actor = MapUser(squidexEvent.Actor.Identifier, actor);
             }
+
+            return true;
         }
 
         public override Task RestoreAsync(Guid appId, BackupReader reader)
@@ -201,7 +201,7 @@ namespace Squidex.Domain.Apps.Entities.Apps
 
             await appsByNameIndex.AddAppAsync(appId, appName);
 
-            foreach (var user in activeUsers)
+            foreach (var user in contributors)
             {
                 await grainFactory.GetGrain<IAppsByUserIndex>(user).AddAppAsync(appId);
             }

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

@@ -65,17 +65,19 @@ namespace Squidex.Domain.Apps.Entities.Assets
             return TaskHelper.Done;
         }
 
-        public override Task RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
+        public override async Task<bool> RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
         {
             switch (@event.Payload)
             {
                 case AssetCreated assetCreated:
-                    return ReadAssetAsync(assetCreated.AssetId, assetCreated.FileVersion, reader);
+                    await ReadAssetAsync(assetCreated.AssetId, assetCreated.FileVersion, reader);
+                    break;
                 case AssetUpdated assetUpdated:
-                    return ReadAssetAsync(assetUpdated.AssetId, assetUpdated.FileVersion, reader);
+                    await ReadAssetAsync(assetUpdated.AssetId, assetUpdated.FileVersion, reader);
+                    break;
             }
 
-            return TaskHelper.Done;
+            return true;
         }
 
         public override async Task RestoreAsync(Guid appId, BackupReader reader)

src/Squidex.Domain.Apps.Entities/Backup/BackupHandler.cs

@@ -17,9 +17,9 @@ namespace Squidex.Domain.Apps.Entities.Backup
     {
         public abstract string Name { get; }
 
-        public virtual Task RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
+        public virtual Task<bool> RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
         {
-            return TaskHelper.Done;
+            return TaskHelper.True;
         }
 
         public virtual Task BackupEventAsync(Envelope<IEvent> @event, Guid appId, BackupWriter writer)

src/Squidex.Domain.Apps.Entities/Backup/RestoreGrain.cs

@@ -9,11 +9,14 @@ using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using NodaTime;
+using Squidex.Domain.Apps.Core.Apps;
+using Squidex.Domain.Apps.Entities.Apps.Commands;
 using Squidex.Domain.Apps.Entities.Backup.Helpers;
 using Squidex.Domain.Apps.Entities.Backup.State;
 using Squidex.Domain.Apps.Events;
 using Squidex.Domain.Apps.Events.Apps;
 using Squidex.Infrastructure;
+using Squidex.Infrastructure.Commands;
 using Squidex.Infrastructure.EventSourcing;
 using Squidex.Infrastructure.Log;
 using Squidex.Infrastructure.Orleans;
@@ -26,6 +29,7 @@ namespace Squidex.Domain.Apps.Entities.Backup
     {
         private readonly IBackupArchiveLocation backupArchiveLocation;
         private readonly IClock clock;
+        private readonly ICommandBus commandBus;
         private readonly IEnumerable<BackupHandler> handlers;
         private readonly IEventStore eventStore;
         private readonly IEventDataFormatter eventDataFormatter;
@@ -43,6 +47,7 @@ namespace Squidex.Domain.Apps.Entities.Backup
 
         public RestoreGrain(IBackupArchiveLocation backupArchiveLocation,
             IClock clock,
+            ICommandBus commandBus,
             IEventStore eventStore,
             IEventDataFormatter eventDataFormatter,
             IEnumerable<BackupHandler> handlers,
@@ -52,6 +57,7 @@ namespace Squidex.Domain.Apps.Entities.Backup
         {
             Guard.NotNull(backupArchiveLocation, nameof(backupArchiveLocation));
             Guard.NotNull(clock, nameof(clock));
+            Guard.NotNull(commandBus, nameof(commandBus));
             Guard.NotNull(eventStore, nameof(eventStore));
             Guard.NotNull(eventDataFormatter, nameof(eventDataFormatter));
             Guard.NotNull(handlers, nameof(handlers));
@@ -61,6 +67,7 @@ namespace Squidex.Domain.Apps.Entities.Backup
 
             this.backupArchiveLocation = backupArchiveLocation;
             this.clock = clock;
+            this.commandBus = commandBus;
             this.eventStore = eventStore;
             this.eventDataFormatter = eventDataFormatter;
             this.handlers = handlers;
@@ -182,6 +189,13 @@ namespace Squidex.Domain.Apps.Entities.Backup
                         }
                     }
 
+                    using (Profiler.Trace("AssignContributor"))
+                    {
+                        await AssignContributorAsync();
+
+                        Log("Assigned current user as owner");
+                    }
+
                     CurrentJob.Status = JobStatus.Completed;
 
                     Log("Completed, Yeah!");
@@ -230,6 +244,17 @@ namespace Squidex.Domain.Apps.Entities.Backup
             }
         }
 
+        private async Task AssignContributorAsync()
+        {
+            await commandBus.PublishAsync(new AssignContributor
+            {
+                Actor = actor,
+                AppId = CurrentJob.AppId,
+                ContributorId = actor.Identifier,
+                Permission = AppContributorPermission.Developer
+            });
+        }
+
         private async Task CleanupAsync()
         {
             await Safe.DeleteAsync(backupArchiveLocation, CurrentJob.Id, log);
@@ -258,40 +283,48 @@ namespace Squidex.Domain.Apps.Entities.Backup
             {
                 var @event = eventDataFormatter.Parse(storedEvent.Data);
 
-                if (@event.Payload is SquidexEvent squidexEvent)
-                {
-                    squidexEvent.Actor = actor;
-                }
+                await HandleEventAsync(reader, storedEvent, @event);
+            });
 
-                if (@event.Payload is AppCreated appCreated)
-                {
-                    CurrentJob.AppId = appCreated.AppId.Id;
+            Log("Reading events completed.");
+        }
 
-                    if (!string.IsNullOrWhiteSpace(CurrentJob.NewAppName))
-                    {
-                        appCreated.Name = CurrentJob.NewAppName;
-                    }
-                }
+        private async Task HandleEventAsync(BackupReader reader, StoredEvent storedEvent, Envelope<IEvent> @event)
+        {
+            if (@event.Payload is SquidexEvent squidexEvent)
+            {
+                squidexEvent.Actor = actor;
+            }
 
-                if (@event.Payload is AppEvent appEvent && !string.IsNullOrWhiteSpace(CurrentJob.NewAppName))
+            if (@event.Payload is AppCreated appCreated)
+            {
+                CurrentJob.AppId = appCreated.AppId.Id;
+
+                if (!string.IsNullOrWhiteSpace(CurrentJob.NewAppName))
                 {
-                    appEvent.AppId = new NamedId<Guid>(appEvent.AppId.Id, CurrentJob.NewAppName);
+                    appCreated.Name = CurrentJob.NewAppName;
                 }
+            }
 
-                foreach (var handler in handlers)
+            if (@event.Payload is AppEvent appEvent && !string.IsNullOrWhiteSpace(CurrentJob.NewAppName))
+            {
+                appEvent.AppId = new NamedId<Guid>(appEvent.AppId.Id, CurrentJob.NewAppName);
+            }
+
+            foreach (var handler in handlers)
+            {
+                if (!await handler.RestoreEventAsync(@event, CurrentJob.AppId, reader, actor))
                 {
-                    await handler.RestoreEventAsync(@event, CurrentJob.AppId, reader, actor);
+                    return;
                 }
+            }
 
-                var eventData = eventDataFormatter.ToEventData(@event, @event.Headers.CommitId());
-                var eventCommit = new List<EventData> { eventData };
-
-                await eventStore.AppendAsync(Guid.NewGuid(), storedEvent.StreamName, eventCommit);
+            var eventData = eventDataFormatter.ToEventData(@event, @event.Headers.CommitId());
+            var eventCommit = new List<EventData> { eventData };
 
-                Log($"Read {reader.ReadEvents} events and {reader.ReadAttachments} attachments.", true);
-            });
+            await eventStore.AppendAsync(Guid.NewGuid(), storedEvent.StreamName, eventCommit);
 
-            Log("Reading events completed.");
+            Log($"Read {reader.ReadEvents} events and {reader.ReadAttachments} attachments.", true);
         }
 
         private void Log(string message, bool replace = false)

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

@@ -29,7 +29,7 @@ namespace Squidex.Domain.Apps.Entities.Contents
         {
         }
 
-        public override Task RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
+        public override Task<bool> RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
         {
             switch (@event.Payload)
             {
@@ -38,7 +38,7 @@ namespace Squidex.Domain.Apps.Entities.Contents
                     break;
             }
 
-            return TaskHelper.Done;
+            return TaskHelper.True;
         }
 
         public override Task RestoreAsync(Guid appId, BackupReader reader)

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

@@ -37,7 +37,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
             this.grainFactory = grainFactory;
         }
 
-        public override Task RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
+        public override Task<bool> RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
         {
             switch (@event.Payload)
             {
@@ -49,7 +49,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
                     break;
             }
 
-            return TaskHelper.Done;
+            return TaskHelper.True;
         }
 
         public override async Task RestoreAsync(Guid appId, BackupReader reader)

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

@@ -42,7 +42,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
             this.grainFactory = grainFactory;
         }
 
-        public override Task RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
+        public override Task<bool> RestoreEventAsync(Envelope<IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
         {
             switch (@event.Payload)
             {
@@ -52,7 +52,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
                     break;
             }
 
-            return TaskHelper.Done;
+            return TaskHelper.True;
         }
 
         public override async Task RestoreAsync(Guid appId, BackupReader reader)