Added ConfigureAwait(false) to permission storages

usercode · usercode · commit 1956c34e7767 · 2025-03-24T18:04:17.000+01:00
diff --git a/src/DragonFly.AspNetCore/Permissions/DragonFlyApiPermissionExtensions.cs b/src/DragonFly.AspNetCore/Permissions/DragonFlyApiPermissionExtensions.cs
@@ -17,6 +17,6 @@ public static async Task<Result> AuthorizeAsync(this IDragonFlyApi api, ClaimsPr
     {
         IAuthorizationService authorizationService = api.ServiceProvider.GetRequiredService<IAuthorizationService>();
 
-        return await authorizationService.AuthorizeAsync(principal, permission);
+        return await authorizationService.AuthorizeAsync(principal, permission).ConfigureAwait(false);
     }
 }
diff --git a/src/DragonFly.AspNetCore/Permissions/Storages/AssetFolderPermissionStorage.cs b/src/DragonFly.AspNetCore/Permissions/Storages/AssetFolderPermissionStorage.cs
@@ -34,26 +34,36 @@ public AssetFolderPermissionStorage(IAssetFolderStorage storage, IDragonFlyApi a
 
     public async Task<Result> CreateAsync(AssetFolder folder)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.CreateAssetFolder).ThenAsync(x => Storage.CreateAsync(folder));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.CreateAssetFolder)
+                        .ThenAsync(x => Storage.CreateAsync(folder))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> DeleteAsync(AssetFolder folder)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.DeleteAssetFolder).ThenAsync(x => Storage.DeleteAsync(folder));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.DeleteAssetFolder)
+                        .ThenAsync(x => Storage.DeleteAsync(folder))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<AssetFolder?>> GetAssetFolderAsync(Guid id)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.ReadAssetFolder).ThenAsync(x => Storage.GetAssetFolderAsync(id));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.ReadAssetFolder)
+                        .ThenAsync(x => Storage.GetAssetFolderAsync(id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<QueryResult<AssetFolder>>> QueryAsync(AssetFolderQuery query)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.QueryAssetFolder).ThenAsync(x => Storage.QueryAsync(query));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.QueryAssetFolder)
+                        .ThenAsync(x => Storage.QueryAsync(query))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> UpdateAsync(AssetFolder folder)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.UpdateAssetFolder).ThenAsync(x => Storage.UpdateAsync(folder));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.UpdateAssetFolder)
+                        .ThenAsync(x => Storage.UpdateAsync(folder))
+                        .ConfigureAwait(false);
     }
 }
diff --git a/src/DragonFly.AspNetCore/Permissions/Storages/AssetPermissionStorage.cs b/src/DragonFly.AspNetCore/Permissions/Storages/AssetPermissionStorage.cs
@@ -33,51 +33,71 @@ public AssetPermissionStorage(IAssetStorage storage, IDragonFlyApi api, IPrincip
 
     public async Task<Result> ApplyMetadataAsync(Asset asset)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset).ThenAsync(x => Storage.ApplyMetadataAsync(asset));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset)
+                        .ThenAsync(x => Storage.ApplyMetadataAsync(asset))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<BackgroundTaskInfo>> ApplyMetadataAsync(AssetQuery query)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset).ThenAsync(x => Storage.ApplyMetadataAsync(query));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset)
+                        .ThenAsync(x => Storage.ApplyMetadataAsync(query))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> CreateAsync(Asset asset)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.CreateAsset).ThenAsync(x => Storage.CreateAsync(asset));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.CreateAsset)
+                        .ThenAsync(x => Storage.CreateAsync(asset))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> DeleteAsync(Asset asset)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.DeleteAsset).ThenAsync(x => Storage.DeleteAsync(asset));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.DeleteAsset)
+                        .ThenAsync(x => Storage.DeleteAsync(asset))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<Asset?>> GetAssetAsync(Guid id)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.ReadAsset).ThenAsync(x  => Storage.GetAssetAsync(id));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.ReadAsset)
+                        .ThenAsync(x  => Storage.GetAssetAsync(id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<Stream>> OpenStreamAsync(Guid assetId)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.DownloadAsset).ThenAsync(x => Storage.OpenStreamAsync(assetId));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.DownloadAsset)
+                        .ThenAsync(x => Storage.OpenStreamAsync(assetId))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> PublishAsync(Asset asset)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.PublishAsset).ThenAsync(x => Storage.PublishAsync(asset));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.PublishAsset)
+                        .ThenAsync(x => Storage.PublishAsync(asset))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<QueryResult<Asset>>> QueryAsync(AssetQuery query)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.QueryAsset).ThenAsync(x => Storage.QueryAsync(query));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.QueryAsset)
+                        .ThenAsync(x => Storage.QueryAsync(query))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> UpdateAsync(Asset asset)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset).ThenAsync(x => Storage.UpdateAsync(asset));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset)
+                        .ThenAsync(x => Storage.UpdateAsync(asset))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> UploadAsync(Guid assetId, string mimetype, Stream stream)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UploadAsset).ThenAsync(x => Storage.UploadAsync(assetId, mimetype, stream));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UploadAsset)
+                      .ThenAsync(x => Storage.UploadAsync(assetId, mimetype, stream))
+                      .ConfigureAwait(false);
     }
 }
diff --git a/src/DragonFly.AspNetCore/Permissions/Storages/BackgroundTaskPermissionStorage.cs b/src/DragonFly.AspNetCore/Permissions/Storages/BackgroundTaskPermissionStorage.cs
@@ -33,17 +33,23 @@ public BackgroundTaskPermissionStorage(IBackgroundTaskManager storage, IDragonFl
 
     public async Task<Result> CancelAsync(int id)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.CancelBackgroundTask).ThenAsync(x => Storage.CancelAsync(id));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.CancelBackgroundTask)
+                        .ThenAsync(x => Storage.CancelAsync(id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<BackgroundTaskInfo[]>> GetTasksAsync()
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.QueryBackgroundTask).ThenAsync(x => Storage.GetTasksAsync());
+        return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.QueryBackgroundTask)
+                        .ThenAsync(x => Storage.GetTasksAsync())
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<IBackgroundTaskNotificationProvider>> StartNotificationProviderAsync()
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.QueryBackgroundTask).ThenAsync(x => Storage.StartNotificationProviderAsync());
+        return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.QueryBackgroundTask)
+                        .ThenAsync(x => Storage.StartNotificationProviderAsync())
+                        .ConfigureAwait(false);
     }
 
     public BackgroundTask Start(string name, Func<BackgroundTaskContext, Task> action)
diff --git a/src/DragonFly.AspNetCore/Permissions/Storages/ContentPermissionStorage.cs b/src/DragonFly.AspNetCore/Permissions/Storages/ContentPermissionStorage.cs
@@ -34,17 +34,23 @@ public ContentPermissionStorage(IContentStorage storage, IDragonFlyApi api, IPri
 
     public async Task<Result> CreateAsync(ContentItem content)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(content.Schema.Name, ContentAction.Create)).ThenAsync(x => Storage.CreateAsync(content));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(content.Schema.Name, ContentAction.Create))
+                        .ThenAsync(x => Storage.CreateAsync(content))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<bool>> DeleteAsync(string schema, Guid id)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Delete)).ThenAsync(x => Storage.DeleteAsync(schema, id));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Delete))
+                        .ThenAsync(x => Storage.DeleteAsync(schema, id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<ContentItem?>> GetContentAsync(string schema, Guid id)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Read)).ThenAsync(x => Storage.GetContentAsync(schema, id));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Read))
+                        .ThenAsync(x => Storage.GetContentAsync(schema, id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<ContentReferenceIndex>> GetReferencedByAsync(string schema, Guid id)
@@ -56,36 +62,48 @@ public async Task<Result<ContentReferenceIndex>> GetReferencedByAsync(string sch
 
     public async Task<Result<bool>> PublishAsync(string schema, Guid id)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Publish)).ThenAsync(x => Storage.PublishAsync(schema, id));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Publish))
+                        .ThenAsync(x => Storage.PublishAsync(schema, id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<BackgroundTaskInfo>> PublishQueryAsync(ContentQuery query)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Publish)).ThenAsync(x => Storage.PublishQueryAsync(query));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Publish))
+                        .ThenAsync(x => Storage.PublishQueryAsync(query))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<QueryResult<ContentItem>>> QueryAsync(ContentQuery query)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Query)).ThenAsync(x => Storage.QueryAsync(query));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Query))
+                        .ThenAsync(x => Storage.QueryAsync(query))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<bool>> UnpublishAsync(string schema, Guid id)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Unpublish)).ThenAsync(x => Storage.UnpublishAsync(schema, id));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Unpublish))
+                        .ThenAsync(x => Storage.UnpublishAsync(schema, id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<BackgroundTaskInfo>> UnpublishQueryAsync(ContentQuery query)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Unpublish)).ThenAsync(x => Storage.UnpublishQueryAsync(query));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Unpublish))
+                        .ThenAsync(x => Storage.UnpublishQueryAsync(query))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> UpdateAsync(ContentItem content)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(content.Schema.Name, ContentAction.Update)).ThenAsync(x => Storage.UpdateAsync(content));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(content.Schema.Name, ContentAction.Update))
+                        .ThenAsync(x => Storage.UpdateAsync(content))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> RebuildDatabaseAsync()
     {
-       return await Storage.RebuildDatabaseAsync();
+       return await Storage.RebuildDatabaseAsync().ConfigureAwait(false);
     }
 }
diff --git a/src/DragonFly.AspNetCore/Permissions/Storages/ContentVersionPermissionStorage.cs b/src/DragonFly.AspNetCore/Permissions/Storages/ContentVersionPermissionStorage.cs
@@ -35,12 +35,14 @@ public ContentVersionPermissionStorage(IContentVersionStorage storage, IDragonFl
     public async Task<Result<ContentItem?>> GetContentByVersionAsync(string schema, Guid id)
     {
         return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Read))
-                                            .ThenAsync(x => Storage.GetContentByVersionAsync(schema, id));
+                        .ThenAsync(x => Storage.GetContentByVersionAsync(schema, id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<QueryResult<ContentVersionEntry>>> GetContentVersionsAsync(string schema, Guid id)
     {
         return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Read))
-                                            .ThenAsync(x => Storage.GetContentVersionsAsync(schema, id));
+                        .ThenAsync(x => Storage.GetContentVersionsAsync(schema, id))
+                        .ConfigureAwait(false);
     }
 }
diff --git a/src/DragonFly.AspNetCore/Permissions/Storages/SchemaPermissionStorage.cs b/src/DragonFly.AspNetCore/Permissions/Storages/SchemaPermissionStorage.cs
@@ -34,31 +34,43 @@ public SchemaPermissionStorage(ISchemaStorage storage, IDragonFlyApi api, IPrinc
 
     public async Task<Result> CreateAsync(ContentSchema schema)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.CreateSchema).ThenAsync(x => Storage.CreateAsync(schema));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.CreateSchema)
+                        .ThenAsync(x => Storage.CreateAsync(schema))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> DeleteAsync(ContentSchema schema)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.DeleteSchema).ThenAsync(x => Storage.DeleteAsync(schema));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.DeleteSchema)
+                        .ThenAsync(x => Storage.DeleteAsync(schema))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<ContentSchema?>> GetSchemaAsync(Guid id)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.ReadSchema).ThenAsync(x => Storage.GetSchemaAsync(id));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.ReadSchema)
+                        .ThenAsync(x => Storage.GetSchemaAsync(id))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<ContentSchema?>> GetSchemaAsync(string name)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.ReadSchema).ThenAsync(x => Storage.GetSchemaAsync(name));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.ReadSchema)
+                        .ThenAsync(x => Storage.GetSchemaAsync(name))
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result<QueryResult<ContentSchema>>> QuerySchemasAsync()
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.QuerySchema).ThenAsync(x => Storage.QuerySchemasAsync());
+        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.QuerySchema)
+                        .ThenAsync(x => Storage.QuerySchemasAsync())
+                        .ConfigureAwait(false);
     }
 
     public async Task<Result> UpdateAsync(ContentSchema schema)
     {
-        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.UpdateSchema).ThenAsync(x => Storage.UpdateAsync(schema));
+        return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.UpdateSchema)
+                        .ThenAsync(x => Storage.UpdateAsync(schema))
+                        .ConfigureAwait(false);
     }
 }
diff --git a/src/DragonFly.AspNetCore/Permissions/Storages/WebHookPermissionStorage.cs b/src/DragonFly.AspNetCore/Permissions/Storages/WebHookPermissionStorage.cs
diff --git a/src/DragonFly.Core/DragonFly.Core.csproj b/src/DragonFly.Core/DragonFly.Core.csproj

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,6 @@ public static async Task<Result> AuthorizeAsync(this IDragonFlyApi api, ClaimsPr`
`17`	`17`	`{`
`18`	`18`	`IAuthorizationService authorizationService = api.ServiceProvider.GetRequiredService<IAuthorizationService>();`
`19`	`19`
`20`		`- return await authorizationService.AuthorizeAsync(principal, permission);`
	`20`	`+ return await authorizationService.AuthorizeAsync(principal, permission).ConfigureAwait(false);`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,26 +34,36 @@ public AssetFolderPermissionStorage(IAssetFolderStorage storage, IDragonFlyApi a`
`34`	`34`
`35`	`35`	`public async Task<Result> CreateAsync(AssetFolder folder)`
`36`	`36`	`{`
`37`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.CreateAssetFolder).ThenAsync(x => Storage.CreateAsync(folder));`
	`37`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.CreateAssetFolder)`
	`38`	`+ .ThenAsync(x => Storage.CreateAsync(folder))`
	`39`	`+ .ConfigureAwait(false);`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`public async Task<Result> DeleteAsync(AssetFolder folder)`
`41`	`43`	`{`
`42`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.DeleteAssetFolder).ThenAsync(x => Storage.DeleteAsync(folder));`
	`44`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.DeleteAssetFolder)`
	`45`	`+ .ThenAsync(x => Storage.DeleteAsync(folder))`
	`46`	`+ .ConfigureAwait(false);`
`43`	`47`	`}`
`44`	`48`
`45`	`49`	`public async Task<Result<AssetFolder?>> GetAssetFolderAsync(Guid id)`
`46`	`50`	`{`
`47`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.ReadAssetFolder).ThenAsync(x => Storage.GetAssetFolderAsync(id));`
	`51`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.ReadAssetFolder)`
	`52`	`+ .ThenAsync(x => Storage.GetAssetFolderAsync(id))`
	`53`	`+ .ConfigureAwait(false);`
`48`	`54`	`}`
`49`	`55`
`50`	`56`	`public async Task<Result<QueryResult<AssetFolder>>> QueryAsync(AssetFolderQuery query)`
`51`	`57`	`{`
`52`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.QueryAssetFolder).ThenAsync(x => Storage.QueryAsync(query));`
	`58`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.QueryAssetFolder)`
	`59`	`+ .ThenAsync(x => Storage.QueryAsync(query))`
	`60`	`+ .ConfigureAwait(false);`
`53`	`61`	`}`
`54`	`62`
`55`	`63`	`public async Task<Result> UpdateAsync(AssetFolder folder)`
`56`	`64`	`{`
`57`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.UpdateAssetFolder).ThenAsync(x => Storage.UpdateAsync(folder));`
	`65`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetFolderPermissions.UpdateAssetFolder)`
	`66`	`+ .ThenAsync(x => Storage.UpdateAsync(folder))`
	`67`	`+ .ConfigureAwait(false);`
`58`	`68`	`}`
`59`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,51 +33,71 @@ public AssetPermissionStorage(IAssetStorage storage, IDragonFlyApi api, IPrincip`
`33`	`33`
`34`	`34`	`public async Task<Result> ApplyMetadataAsync(Asset asset)`
`35`	`35`	`{`
`36`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset).ThenAsync(x => Storage.ApplyMetadataAsync(asset));`
	`36`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset)`
	`37`	`+ .ThenAsync(x => Storage.ApplyMetadataAsync(asset))`
	`38`	`+ .ConfigureAwait(false);`
`37`	`39`	`}`
`38`	`40`
`39`	`41`	`public async Task<Result<BackgroundTaskInfo>> ApplyMetadataAsync(AssetQuery query)`
`40`	`42`	`{`
`41`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset).ThenAsync(x => Storage.ApplyMetadataAsync(query));`
	`43`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset)`
	`44`	`+ .ThenAsync(x => Storage.ApplyMetadataAsync(query))`
	`45`	`+ .ConfigureAwait(false);`
`42`	`46`	`}`
`43`	`47`
`44`	`48`	`public async Task<Result> CreateAsync(Asset asset)`
`45`	`49`	`{`
`46`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.CreateAsset).ThenAsync(x => Storage.CreateAsync(asset));`
	`50`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.CreateAsset)`
	`51`	`+ .ThenAsync(x => Storage.CreateAsync(asset))`
	`52`	`+ .ConfigureAwait(false);`
`47`	`53`	`}`
`48`	`54`
`49`	`55`	`public async Task<Result> DeleteAsync(Asset asset)`
`50`	`56`	`{`
`51`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.DeleteAsset).ThenAsync(x => Storage.DeleteAsync(asset));`
	`57`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.DeleteAsset)`
	`58`	`+ .ThenAsync(x => Storage.DeleteAsync(asset))`
	`59`	`+ .ConfigureAwait(false);`
`52`	`60`	`}`
`53`	`61`
`54`	`62`	`public async Task<Result<Asset?>> GetAssetAsync(Guid id)`
`55`	`63`	`{`
`56`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.ReadAsset).ThenAsync(x => Storage.GetAssetAsync(id));`
	`64`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.ReadAsset)`
	`65`	`+ .ThenAsync(x => Storage.GetAssetAsync(id))`
	`66`	`+ .ConfigureAwait(false);`
`57`	`67`	`}`
`58`	`68`
`59`	`69`	`public async Task<Result<Stream>> OpenStreamAsync(Guid assetId)`
`60`	`70`	`{`
`61`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.DownloadAsset).ThenAsync(x => Storage.OpenStreamAsync(assetId));`
	`71`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.DownloadAsset)`
	`72`	`+ .ThenAsync(x => Storage.OpenStreamAsync(assetId))`
	`73`	`+ .ConfigureAwait(false);`
`62`	`74`	`}`
`63`	`75`
`64`	`76`	`public async Task<Result> PublishAsync(Asset asset)`
`65`	`77`	`{`
`66`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.PublishAsset).ThenAsync(x => Storage.PublishAsync(asset));`
	`78`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.PublishAsset)`
	`79`	`+ .ThenAsync(x => Storage.PublishAsync(asset))`
	`80`	`+ .ConfigureAwait(false);`
`67`	`81`	`}`
`68`	`82`
`69`	`83`	`public async Task<Result<QueryResult<Asset>>> QueryAsync(AssetQuery query)`
`70`	`84`	`{`
`71`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.QueryAsset).ThenAsync(x => Storage.QueryAsync(query));`
	`85`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.QueryAsset)`
	`86`	`+ .ThenAsync(x => Storage.QueryAsync(query))`
	`87`	`+ .ConfigureAwait(false);`
`72`	`88`	`}`
`73`	`89`
`74`	`90`	`public async Task<Result> UpdateAsync(Asset asset)`
`75`	`91`	`{`
`76`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset).ThenAsync(x => Storage.UpdateAsync(asset));`
	`92`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UpdateAsset)`
	`93`	`+ .ThenAsync(x => Storage.UpdateAsync(asset))`
	`94`	`+ .ConfigureAwait(false);`
`77`	`95`	`}`
`78`	`96`
`79`	`97`	`public async Task<Result> UploadAsync(Guid assetId, string mimetype, Stream stream)`
`80`	`98`	`{`
`81`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UploadAsset).ThenAsync(x => Storage.UploadAsync(assetId, mimetype, stream));`
	`99`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, AssetPermissions.UploadAsset)`
	`100`	`+ .ThenAsync(x => Storage.UploadAsync(assetId, mimetype, stream))`
	`101`	`+ .ConfigureAwait(false);`
`82`	`102`	`}`
`83`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,17 +33,23 @@ public BackgroundTaskPermissionStorage(IBackgroundTaskManager storage, IDragonFl`
`33`	`33`
`34`	`34`	`public async Task<Result> CancelAsync(int id)`
`35`	`35`	`{`
`36`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.CancelBackgroundTask).ThenAsync(x => Storage.CancelAsync(id));`
	`36`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.CancelBackgroundTask)`
	`37`	`+ .ThenAsync(x => Storage.CancelAsync(id))`
	`38`	`+ .ConfigureAwait(false);`
`37`	`39`	`}`
`38`	`40`
`39`	`41`	`public async Task<Result<BackgroundTaskInfo[]>> GetTasksAsync()`
`40`	`42`	`{`
`41`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.QueryBackgroundTask).ThenAsync(x => Storage.GetTasksAsync());`
	`43`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.QueryBackgroundTask)`
	`44`	`+ .ThenAsync(x => Storage.GetTasksAsync())`
	`45`	`+ .ConfigureAwait(false);`
`42`	`46`	`}`
`43`	`47`
`44`	`48`	`public async Task<Result<IBackgroundTaskNotificationProvider>> StartNotificationProviderAsync()`
`45`	`49`	`{`
`46`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.QueryBackgroundTask).ThenAsync(x => Storage.StartNotificationProviderAsync());`
	`50`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, BackgroundTaskPermissions.QueryBackgroundTask)`
	`51`	`+ .ThenAsync(x => Storage.StartNotificationProviderAsync())`
	`52`	`+ .ConfigureAwait(false);`
`47`	`53`	`}`
`48`	`54`
`49`	`55`	`public BackgroundTask Start(string name, Func<BackgroundTaskContext, Task> action)`
Original file line number	Diff line number	Diff line change
`@@ -34,17 +34,23 @@ public ContentPermissionStorage(IContentStorage storage, IDragonFlyApi api, IPri`
`34`	`34`
`35`	`35`	`public async Task<Result> CreateAsync(ContentItem content)`
`36`	`36`	`{`
`37`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(content.Schema.Name, ContentAction.Create)).ThenAsync(x => Storage.CreateAsync(content));`
	`37`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(content.Schema.Name, ContentAction.Create))`
	`38`	`+ .ThenAsync(x => Storage.CreateAsync(content))`
	`39`	`+ .ConfigureAwait(false);`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`public async Task<Result<bool>> DeleteAsync(string schema, Guid id)`
`41`	`43`	`{`
`42`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Delete)).ThenAsync(x => Storage.DeleteAsync(schema, id));`
	`44`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Delete))`
	`45`	`+ .ThenAsync(x => Storage.DeleteAsync(schema, id))`
	`46`	`+ .ConfigureAwait(false);`
`43`	`47`	`}`
`44`	`48`
`45`	`49`	`public async Task<Result<ContentItem?>> GetContentAsync(string schema, Guid id)`
`46`	`50`	`{`
`47`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Read)).ThenAsync(x => Storage.GetContentAsync(schema, id));`
	`51`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Read))`
	`52`	`+ .ThenAsync(x => Storage.GetContentAsync(schema, id))`
	`53`	`+ .ConfigureAwait(false);`
`48`	`54`	`}`
`49`	`55`
`50`	`56`	`public async Task<Result<ContentReferenceIndex>> GetReferencedByAsync(string schema, Guid id)`
`@@ -56,36 +62,48 @@ public async Task<Result<ContentReferenceIndex>> GetReferencedByAsync(string sch`
`56`	`62`
`57`	`63`	`public async Task<Result<bool>> PublishAsync(string schema, Guid id)`
`58`	`64`	`{`
`59`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Publish)).ThenAsync(x => Storage.PublishAsync(schema, id));`
	`65`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Publish))`
	`66`	`+ .ThenAsync(x => Storage.PublishAsync(schema, id))`
	`67`	`+ .ConfigureAwait(false);`
`60`	`68`	`}`
`61`	`69`
`62`	`70`	`public async Task<Result<BackgroundTaskInfo>> PublishQueryAsync(ContentQuery query)`
`63`	`71`	`{`
`64`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Publish)).ThenAsync(x => Storage.PublishQueryAsync(query));`
	`72`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Publish))`
	`73`	`+ .ThenAsync(x => Storage.PublishQueryAsync(query))`
	`74`	`+ .ConfigureAwait(false);`
`65`	`75`	`}`
`66`	`76`
`67`	`77`	`public async Task<Result<QueryResult<ContentItem>>> QueryAsync(ContentQuery query)`
`68`	`78`	`{`
`69`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Query)).ThenAsync(x => Storage.QueryAsync(query));`
	`79`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Query))`
	`80`	`+ .ThenAsync(x => Storage.QueryAsync(query))`
	`81`	`+ .ConfigureAwait(false);`
`70`	`82`	`}`
`71`	`83`
`72`	`84`	`public async Task<Result<bool>> UnpublishAsync(string schema, Guid id)`
`73`	`85`	`{`
`74`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Unpublish)).ThenAsync(x => Storage.UnpublishAsync(schema, id));`
	`86`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Unpublish))`
	`87`	`+ .ThenAsync(x => Storage.UnpublishAsync(schema, id))`
	`88`	`+ .ConfigureAwait(false);`
`75`	`89`	`}`
`76`	`90`
`77`	`91`	`public async Task<Result<BackgroundTaskInfo>> UnpublishQueryAsync(ContentQuery query)`
`78`	`92`	`{`
`79`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Unpublish)).ThenAsync(x => Storage.UnpublishQueryAsync(query));`
	`93`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(query.Schema, ContentAction.Unpublish))`
	`94`	`+ .ThenAsync(x => Storage.UnpublishQueryAsync(query))`
	`95`	`+ .ConfigureAwait(false);`
`80`	`96`	`}`
`81`	`97`
`82`	`98`	`public async Task<Result> UpdateAsync(ContentItem content)`
`83`	`99`	`{`
`84`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(content.Schema.Name, ContentAction.Update)).ThenAsync(x => Storage.UpdateAsync(content));`
	`100`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(content.Schema.Name, ContentAction.Update))`
	`101`	`+ .ThenAsync(x => Storage.UpdateAsync(content))`
	`102`	`+ .ConfigureAwait(false);`
`85`	`103`	`}`
`86`	`104`
`87`	`105`	`public async Task<Result> RebuildDatabaseAsync()`
`88`	`106`	`{`
`89`		`- return await Storage.RebuildDatabaseAsync();`
	`107`	`+ return await Storage.RebuildDatabaseAsync().ConfigureAwait(false);`
`90`	`108`	`}`
`91`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,12 +35,14 @@ public ContentVersionPermissionStorage(IContentVersionStorage storage, IDragonFl`
`35`	`35`	`public async Task<Result<ContentItem?>> GetContentByVersionAsync(string schema, Guid id)`
`36`	`36`	`{`
`37`	`37`	`return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Read))`
`38`		`- .ThenAsync(x => Storage.GetContentByVersionAsync(schema, id));`
	`38`	`+ .ThenAsync(x => Storage.GetContentByVersionAsync(schema, id))`
	`39`	`+ .ConfigureAwait(false);`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`public async Task<Result<QueryResult<ContentVersionEntry>>> GetContentVersionsAsync(string schema, Guid id)`
`42`	`43`	`{`
`43`	`44`	`return await Api.AuthorizeAsync(PrincipalContext.Current, ContentPermissions.Create(schema, ContentAction.Read))`
`44`		`- .ThenAsync(x => Storage.GetContentVersionsAsync(schema, id));`
	`45`	`+ .ThenAsync(x => Storage.GetContentVersionsAsync(schema, id))`
	`46`	`+ .ConfigureAwait(false);`
`45`	`47`	`}`
`46`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,31 +34,43 @@ public SchemaPermissionStorage(ISchemaStorage storage, IDragonFlyApi api, IPrinc`
`34`	`34`
`35`	`35`	`public async Task<Result> CreateAsync(ContentSchema schema)`
`36`	`36`	`{`
`37`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.CreateSchema).ThenAsync(x => Storage.CreateAsync(schema));`
	`37`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.CreateSchema)`
	`38`	`+ .ThenAsync(x => Storage.CreateAsync(schema))`
	`39`	`+ .ConfigureAwait(false);`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`public async Task<Result> DeleteAsync(ContentSchema schema)`
`41`	`43`	`{`
`42`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.DeleteSchema).ThenAsync(x => Storage.DeleteAsync(schema));`
	`44`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.DeleteSchema)`
	`45`	`+ .ThenAsync(x => Storage.DeleteAsync(schema))`
	`46`	`+ .ConfigureAwait(false);`
`43`	`47`	`}`
`44`	`48`
`45`	`49`	`public async Task<Result<ContentSchema?>> GetSchemaAsync(Guid id)`
`46`	`50`	`{`
`47`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.ReadSchema).ThenAsync(x => Storage.GetSchemaAsync(id));`
	`51`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.ReadSchema)`
	`52`	`+ .ThenAsync(x => Storage.GetSchemaAsync(id))`
	`53`	`+ .ConfigureAwait(false);`
`48`	`54`	`}`
`49`	`55`
`50`	`56`	`public async Task<Result<ContentSchema?>> GetSchemaAsync(string name)`
`51`	`57`	`{`
`52`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.ReadSchema).ThenAsync(x => Storage.GetSchemaAsync(name));`
	`58`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.ReadSchema)`
	`59`	`+ .ThenAsync(x => Storage.GetSchemaAsync(name))`
	`60`	`+ .ConfigureAwait(false);`
`53`	`61`	`}`
`54`	`62`
`55`	`63`	`public async Task<Result<QueryResult<ContentSchema>>> QuerySchemasAsync()`
`56`	`64`	`{`
`57`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.QuerySchema).ThenAsync(x => Storage.QuerySchemasAsync());`
	`65`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.QuerySchema)`
	`66`	`+ .ThenAsync(x => Storage.QuerySchemasAsync())`
	`67`	`+ .ConfigureAwait(false);`
`58`	`68`	`}`
`59`	`69`
`60`	`70`	`public async Task<Result> UpdateAsync(ContentSchema schema)`
`61`	`71`	`{`
`62`		`- return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.UpdateSchema).ThenAsync(x => Storage.UpdateAsync(schema));`
	`72`	`+ return await Api.AuthorizeAsync(PrincipalContext.Current, SchemaPermissions.UpdateSchema)`
	`73`	`+ .ThenAsync(x => Storage.UpdateAsync(schema))`
	`74`	`+ .ConfigureAwait(false);`
`63`	`75`	`}`
`64`	`76`	`}`