Getting list of permissions

src/AbpDesk/AbpDesk.Web.Mvc/Permissions/AbpDeskPermissionDefinitionProvider.cs

@@ -2,17 +2,26 @@
 
 namespace AbpDesk.Web.Mvc.Permissions
 {
-    public class AbpDeskPermissionDefinitionProvider : IPermissionDefinitionProvider
+    public class AbpDeskPermissionDefinitionProvider : PermissionDefinitionProvider
     {
-        public void Define(IPermissionDefinitionContext context)
+        public override void Define(IPermissionDefinitionContext context)
         {
-            var tickets = context.Add("AbpDesk.Tickets");
+            var abpDeskGroup = context.AddGroup("AbpDesk");
+
+            var tickets = abpDeskGroup.AddPermission("AbpDesk.Tickets");
             tickets.AddChild("AbpDesk.Tickets.Reply");
             tickets.AddChild("AbpDesk.Tickets.Close");
 
-            var customers = context.Add("AbpDesk.Customers");
+            var customers = abpDeskGroup.AddPermission("AbpDesk.Customers");
             customers.AddChild("AbpDesk.Customers.Create");
             customers.AddChild("AbpDesk.Customers.Delete");
+
+            var identityGroup = context.AddGroup("Identity");
+
+            var userManagement = identityGroup.AddPermission("Identity.UserManagement");
+            userManagement.AddChild("Identity.UserManagement.Create");
+            userManagement.AddChild("Identity.UserManagement.Update");
+            userManagement.AddChild("Identity.UserManagement.Delete");
         }
     }
 }

src/Volo.Abp.Permissions.Application/Volo/Abp/Permissions/PermissionAppService.cs

@@ -8,10 +8,14 @@ namespace Volo.Abp.Permissions
     public class PermissionAppService : ApplicationService, IPermissionAppService
     {
         private readonly IPermissionManager _permissionManager;
+        private readonly IPermissionDefinitionManager _permissionDefinitionManager;
 
-        public PermissionAppService(IPermissionManager permissionManager)
+        public PermissionAppService(
+            IPermissionManager permissionManager, 
+            IPermissionDefinitionManager permissionDefinitionManager)
         {
             _permissionManager = permissionManager;
+            _permissionDefinitionManager = permissionDefinitionManager;
         }
 
         public async Task<PermissionGrantInfoDto> GetAsync(string name, string providerName, string providerKey)
@@ -21,109 +25,50 @@ namespace Volo.Abp.Permissions
 
         public async Task<GetPermissionListResultDto> GetListAsync(string providerName, string providerKey)
         {
-            var permissionInfos = await _permissionManager.GetAllAsync(providerName, providerKey);
-            
-            return new GetPermissionListResultDto
+            var result = new GetPermissionListResultDto
+            {
+                Groups = new List<PermissionGroupDto>()
+            };
+
+            foreach (var group in _permissionDefinitionManager.GetGroups())
             {
-                Groups = new List<PermissionGroupDto>
+                var groupDto = new PermissionGroupDto
                 {
-                    new PermissionGroupDto
+                    Name = group.Name,
+                    DisplayName = group.Name, //TODO: DisplayName
+                    Permissions = new List<PermissionGrantInfoDto>()
+                };
+
+                foreach (var permission in group.GetPermissionsWithChildren())
+                {
+                    var grantInfoDto = new PermissionGrantInfoDto
                     {
-                        Name = "Volo.Calendar",
-                        DisplayName = "Calendar",
-                        Permissions = new List<PermissionGrantInfoDto>
-                        {
-                            new PermissionGrantInfoDto
-                            {
-                                Name = "CalendarManagement",
-                                DisplayName = "Calendar management",
-                                ParentName = null,
-                                IsGranted = true,
-                                Providers = new List<ProviderInfoDto>
-                                {
-                                    new ProviderInfoDto
-                                    {
-                                        ProviderKey = "Role",
-                                        ProviderName = "Moderator"
-                                    },
-                                    new ProviderInfoDto
-                                    {
-                                        ProviderKey = "OU",
-                                        ProviderName = "44238045-6f18-44cd-8f1f-4e2d61ef1c81"
-                                    }
-                                }
-                            },
-                            new PermissionGrantInfoDto
-                            {
-                                Name = "CreateNewCalendar",
-                                DisplayName = "Create new calendar",
-                                ParentName = "CalendarManagement",
-                                IsGranted = true,
-                                Providers = new List<ProviderInfoDto>
-                                {
-                                    new ProviderInfoDto
-                                    {
-                                        ProviderKey = "User",
-                                        ProviderName = "bb3c2a2f-118d-4d2e-b1d5-e07f3b0a917c"
-                                    }
-                                }
-                            },
-                            new PermissionGrantInfoDto
-                            {
-                                Name = "DeleteExistingCalendars",
-                                DisplayName = "Delete existing calendars",
-                                ParentName = "CalendarManagement",
-                                IsGranted = false
-                            }
-                        }
-                    },
-                    new PermissionGroupDto
+                        Name = permission.Name,
+                        DisplayName = permission.Name, //TODO: Add DisplayName to permission definition
+                        ParentName = permission.Parent?.Name,
+                        Providers = new List<ProviderInfoDto>()
+                    };
+
+                    var grantInfo = await _permissionManager.GetAsync(permission.Name, providerName, providerKey);
+
+                    grantInfoDto.IsGranted = grantInfo.IsGranted;
+
+                    foreach (var provider in grantInfo.Providers)
                     {
-                        Name = "Volo.Identity",
-                        DisplayName = "Identity",
-                        Permissions = new List<PermissionGrantInfoDto>
+                        grantInfoDto.Providers.Add(new ProviderInfoDto
                         {
-                            new PermissionGrantInfoDto
-                            {
-                                Name = "UserManagement",
-                                DisplayName = "User management",
-                                ParentName = null,
-                                IsGranted = true,
-                                Providers = new List<ProviderInfoDto>
-                                {
-                                    new ProviderInfoDto
-                                    {
-                                        ProviderKey = "Role",
-                                        ProviderName = "Administrator"
-                                    }
-                                }
-                            },
-                            new PermissionGrantInfoDto
-                            {
-                                Name = "CreateNewUser",
-                                DisplayName = "Create new user",
-                                ParentName = "UserManagement",
-                                IsGranted = true,
-                                Providers = new List<ProviderInfoDto>
-                                {
-                                    new ProviderInfoDto
-                                    {
-                                        ProviderKey = "User",
-                                        ProviderName = "bb3c2a2f-118d-4d2e-b1d5-e07f3b0a917c"
-                                    }
-                                }
-                            },
-                            new PermissionGrantInfoDto
-                            {
-                                Name = "DeleteExistingUsers",
-                                DisplayName = "Delete existing users",
-                                ParentName = "UserManagement",
-                                IsGranted = false
-                            }
-                        }
+                            ProviderName = provider.Name,
+                            ProviderKey = provider.Key,
+                        });
                     }
+
+                    groupDto.Permissions.Add(grantInfoDto);
                 }
-            };
+
+                result.Groups.Add(groupDto);
+            }
+
+            return result;
         }
 
         public async Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)

src/Volo.Abp.Permissions.Domain/Volo/Abp/Permissions/IPermissionManagementProvider.cs

@@ -1,8 +1,9 @@
 using System.Threading.Tasks;
+using Volo.Abp.DependencyInjection;
 
 namespace Volo.Abp.Permissions
 {
-    public interface IPermissionManagementProvider
+    public interface IPermissionManagementProvider : ISingletonDependency //TODO: Create an abstract base class.
     {
         string Name { get; }
 

src/Volo.Abp.Permissions.Domain/Volo/Abp/Permissions/IPermissionManager.cs

@@ -6,7 +6,7 @@ namespace Volo.Abp.Permissions
 {
     public interface IPermissionManager
     {
-        //Task<PermissionWithGrantedProviders> GetAsync([NotNull]string name, [NotNull] string providerName, [NotNull] string providerKey);
+        Task<PermissionWithGrantedProviders> GetAsync(string name, string providerName, string providerKey);
 
         Task<List<PermissionWithGrantedProviders>> GetAllAsync([NotNull] string providerName, [NotNull] string providerKey);
 

src/Volo.Abp.Permissions.Domain/Volo/Abp/Permissions/PermissionManager.cs

@@ -104,28 +104,38 @@ namespace Volo.Abp.Permissions
         //    await PermissionGrantRepository.DeleteAsync(grant);
         //}
 
+        public async Task<PermissionWithGrantedProviders> GetAsync(string name, string providerName, string providerKey)
+        {
+            return await GetInternalAsync(PermissionDefinitionManager.Get(name), providerName, providerKey);
+        }
+
         public async Task<List<PermissionWithGrantedProviders>> GetAllAsync(string providerName, string providerKey)
         {
             var results = new List<PermissionWithGrantedProviders>();
 
-            foreach (var permissionDefinition in PermissionDefinitionManager.GetAll())
+            foreach (var permissionDefinition in PermissionDefinitionManager.GetPermissions())
             {
-                var result = new PermissionWithGrantedProviders(permissionDefinition.Name, false);
+                results.Add(await GetInternalAsync(permissionDefinition, providerName, providerKey));
+            }
+
+            return results;
+        }
+
+        public async Task<PermissionWithGrantedProviders> GetInternalAsync(PermissionDefinition permissionDefinition, string providerName, string providerKey)
+        {
+            var result = new PermissionWithGrantedProviders(permissionDefinition.Name, false);
 
-                foreach (var provider in ManagementProviders)
+            foreach (var provider in ManagementProviders)
+            {
+                var providerResult = await provider.CheckAsync(permissionDefinition.Name, providerName, providerKey);
+                if (providerResult.IsGranted)
                 {
-                    var providerResult = await provider.CheckAsync(permissionDefinition.Name, providerName, providerKey);
-                    if (providerResult.IsGranted)
-                    {
-                        result.IsGranted = true;
-                        result.Providers.Add(new PermissionValueProviderInfo(provider.Name, providerResult.ProviderKey));
-                    }
+                    result.IsGranted = true;
+                    result.Providers.Add(new PermissionValueProviderInfo(provider.Name, providerResult.ProviderKey));
                 }
-
-                results.Add(result);
             }
 
-            return results;
+            return result;
         }
     }
 }

src/Volo.Abp.Permissions/Volo/Abp/Permissions/IPermissionDefinitionContext.cs

@@ -4,8 +4,8 @@ namespace Volo.Abp.Permissions
 {
     public interface IPermissionDefinitionContext
     {
-        PermissionDefinition GetOrNull([NotNull] string name);
+        //TODO: Add Get methods to find and modify a permission or group.
 
-        PermissionDefinition Add([NotNull] string name);
+        PermissionGroupDefinition AddGroup([NotNull] string name);
     }
 }

src/Volo.Abp.Permissions/Volo/Abp/Permissions/IPermissionDefinitionManager.cs

@@ -8,6 +8,8 @@ namespace Volo.Abp.Permissions
         [NotNull]
         PermissionDefinition Get([NotNull] string name);
 
-        IReadOnlyList<PermissionDefinition> GetAll();
+        IReadOnlyList<PermissionDefinition> GetPermissions();
+
+        IReadOnlyList<PermissionGroupDefinition> GetGroups();
     }
 }

src/Volo.Abp.Permissions/Volo/Abp/Permissions/IPermissionDefinitionProvider.cs

@@ -1,6 +1,8 @@
-namespace Volo.Abp.Permissions
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.Abp.Permissions
 {
-    public interface IPermissionDefinitionProvider
+    public interface IPermissionDefinitionProvider : ISingletonDependency
     {
         void Define(IPermissionDefinitionContext context);
     }

src/Volo.Abp.Permissions/Volo/Abp/Permissions/PermissionDefinition.cs

@@ -19,7 +19,7 @@ namespace Volo.Abp.Permissions
         public IReadOnlyList<PermissionDefinition> Children => _children.ToImmutableList();
         private readonly List<PermissionDefinition> _children;
 
-        public Dictionary<string, object> Properties { get; set; }
+        public Dictionary<string, object> Properties { get; }
 
         /// <summary>
         /// Gets/sets a key-value on the <see cref="Properties"/>.
@@ -38,6 +38,8 @@ namespace Volo.Abp.Permissions
         protected internal PermissionDefinition(string name)
         {
             Name = name;
+
+            Properties = new Dictionary<string, object>();
             _children = new List<PermissionDefinition>();
         }
 
@@ -55,7 +57,7 @@ namespace Volo.Abp.Permissions
 
         public override string ToString()
         {
-            return $"[Permission {Name}]";
+            return $"[{nameof(PermissionDefinition)} {Name}]";
         }
     }
 }

src/Volo.Abp.Permissions/Volo/Abp/Permissions/PermissionDefinitionContext.cs

@@ -6,65 +6,23 @@ namespace Volo.Abp.Permissions
 {
     public class PermissionDefinitionContext : IPermissionDefinitionContext
     {
-        internal Dictionary<string, PermissionDefinition> Permissions { get; }
+        internal Dictionary<string, PermissionGroupDefinition> Groups { get; }
 
-        public PermissionDefinitionContext()
+        internal PermissionDefinitionContext()
         {
-            Permissions = new Dictionary<string, PermissionDefinition>();
+            Groups = new Dictionary<string, PermissionGroupDefinition>();
         }
 
-        public virtual PermissionDefinition GetOrNull(string name)
+        public virtual PermissionGroupDefinition AddGroup(string name)
         {
             Check.NotNull(name, nameof(name));
 
-            return Permissions.GetOrDefault(name);
-        }
-
-        public virtual IReadOnlyList<PermissionDefinition> GetAll()
-        {
-            return Permissions.Values.ToImmutableList();
-        }
-
-        public virtual PermissionDefinition Add(string name)
-        {
-            Check.NotNull(name, nameof(name));
-
-            if (Permissions.ContainsKey(name))
+            if (Groups.ContainsKey(name))
             {
-                throw new AbpException($"There is already an existing permission with name: {name}");
+                throw new AbpException($"There is already an existing permission group with name: {name}");
             }
 
-            return Permissions[name] = new PermissionDefinition(name);
-        }
-
-        internal void HandleNewChildren()
-        {
-            Permissions.Values
-                .SelectMany(p => p.Children)
-                .ToList()
-                .ForEach(AddPermissionRecursively);
-        }
-
-        private void AddPermissionRecursively(PermissionDefinition permission)
-        {
-            //Prevent multiple adding of same named permission.
-            if (Permissions.TryGetValue(permission.Name, out var existingPermission))
-            {
-                if (existingPermission != permission)
-                {
-                    throw new AbpException("Duplicate permission name detected for " + permission.Name);
-                }
-            }
-            else
-            {
-                Permissions[permission.Name] = permission;
-            }
-
-            //Add child permissions (recursive call)
-            foreach (var childPermission in permission.Children)
-            {
-                AddPermissionRecursively(childPermission);
-            }
+            return Groups[name] = new PermissionGroupDefinition(name);
         }
     }
 }

src/Volo.Abp.Permissions/Volo/Abp/Permissions/PermissionDefinitionManager.cs

@@ -13,8 +13,11 @@ namespace Volo.Abp.Permissions
         protected List<IPermissionDefinitionProvider> Providers => _lazyProviders.Value;
         private readonly Lazy<List<IPermissionDefinitionProvider>> _lazyProviders;
 
+        protected IDictionary<string, PermissionGroupDefinition> PermissionGroupDefinitions => _lazyPermissionGroupDefinitions.Value;
+        private readonly Lazy<Dictionary<string, PermissionGroupDefinition>> _lazyPermissionGroupDefinitions;
+
         protected IDictionary<string, PermissionDefinition> PermissionDefinitions => _lazyPermissionDefinitions.Value;
-        private readonly Lazy<IDictionary<string, PermissionDefinition>> _lazyPermissionDefinitions;
+        private readonly Lazy<Dictionary<string, PermissionDefinition>> _lazyPermissionDefinitions;
 
         protected PermissionOptions Options { get; }
 
@@ -28,7 +31,8 @@ namespace Volo.Abp.Permissions
             Options = options.Value;
 
             _lazyProviders = new Lazy<List<IPermissionDefinitionProvider>>(CreatePermissionProviders, true);
-            _lazyPermissionDefinitions = new Lazy<IDictionary<string, PermissionDefinition>>(CreatePermissionDefinitions, true);
+            _lazyPermissionDefinitions = new Lazy<Dictionary<string, PermissionDefinition>>(CreatePermissionDefinitions, true);
+            _lazyPermissionGroupDefinitions = new Lazy<Dictionary<string, PermissionGroupDefinition>>(CreatePermissionGroupDefinitions, true);
         }
 
         public virtual PermissionDefinition Get(string name)
@@ -45,11 +49,16 @@ namespace Volo.Abp.Permissions
             return permission;
         }
 
-        public virtual IReadOnlyList<PermissionDefinition> GetAll()
+        public virtual IReadOnlyList<PermissionDefinition> GetPermissions()
         {
             return PermissionDefinitions.Values.ToImmutableList();
         }
 
+        public IReadOnlyList<PermissionGroupDefinition> GetGroups()
+        {
+            return PermissionGroupDefinitions.Values.ToImmutableList();
+        }
+
         public virtual PermissionDefinition GetOrNull(string name)
         {
             return PermissionDefinitions.GetOrDefault(name);
@@ -63,17 +72,46 @@ namespace Volo.Abp.Permissions
                 .ToList();
         }
 
-        protected virtual IDictionary<string, PermissionDefinition> CreatePermissionDefinitions()
+        protected virtual Dictionary<string, PermissionDefinition> CreatePermissionDefinitions()
+        {
+            var permissions = new Dictionary<string, PermissionDefinition>();
+
+            foreach (var groupDefinition in PermissionGroupDefinitions.Values)
+            {
+                foreach (var permission in groupDefinition.Permissions)
+                {
+                    AddPermissionToDictionaryRecursively(permissions, permission);
+                }
+            }
+
+            return permissions;
+        }
+
+        protected virtual void AddPermissionToDictionaryRecursively(Dictionary<string, PermissionDefinition> permissions, PermissionDefinition permission)
+        {
+            if (permissions.ContainsKey(permission.Name))
+            {
+                throw new AbpException("Duplicate permission name: " + permission.Name);
+            }
+
+            permissions[permission.Name] = permission;
+
+            foreach (var child in permission.Children)
+            {
+                AddPermissionToDictionaryRecursively(permissions, child);
+            }
+        }
+
+        protected virtual Dictionary<string, PermissionGroupDefinition> CreatePermissionGroupDefinitions()
         {
             var context = new PermissionDefinitionContext();
 
             foreach (var provider in Providers)
             {
                 provider.Define(context);
-                context.HandleNewChildren();
             }
 
-            return context.Permissions;
+            return context.Groups;
         }
     }
 }

src/Volo.Abp.Permissions/Volo/Abp/Permissions/PermissionDefinitionProvider.cs

@@ -1,8 +1,6 @@
-using Volo.Abp.DependencyInjection;
-
-namespace Volo.Abp.Permissions
+namespace Volo.Abp.Permissions
 {
-    public abstract class PermissionDefinitionProvider : IPermissionDefinitionProvider, ISingletonDependency
+    public abstract class PermissionDefinitionProvider : IPermissionDefinitionProvider
     {
         public abstract void Define(IPermissionDefinitionContext context);
     }

src/Volo.Abp.Permissions/Volo/Abp/Permissions/PermissionGroupDefinition.cs

@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace Volo.Abp.Permissions
+{
+    public class PermissionGroupDefinition //TODO: Consider to make possible a group have sub groups
+    {
+        /// <summary>
+        /// Unique name of the group.
+        /// </summary>
+        public string Name { get; }
+
+        public Dictionary<string, object> Properties { get; }
+
+        public IReadOnlyList<PermissionDefinition> Permissions => _permissions.ToImmutableList();
+        private readonly List<PermissionDefinition> _permissions;
+
+        /// <summary>
+        /// Gets/sets a key-value on the <see cref="Properties"/>.
+        /// </summary>
+        /// <param name="name">Name of the property</param>
+        /// <returns>
+        /// Returns the value in the <see cref="Properties"/> dictionary by given <see cref="name"/>.
+        /// Returns null if given <see cref="name"/> is not present in the <see cref="Properties"/> dictionary.
+        /// </returns>
+        public object this[string name]
+        {
+            get => Properties.GetOrDefault(name);
+            set => Properties[name] = value;
+        }
+
+        protected internal PermissionGroupDefinition(string name)
+        {
+            Name = name;
+
+            Properties = new Dictionary<string, object>();
+            _permissions = new List<PermissionDefinition>();
+        }
+
+        public virtual PermissionDefinition AddPermission(string name)
+        {
+            var permission = new PermissionDefinition(name);
+
+            _permissions.Add(permission);
+
+            return permission;
+        }
+
+        public virtual List<PermissionDefinition> GetPermissionsWithChildren()
+        {
+            var permissions = new List<PermissionDefinition>();
+
+            foreach (var permission in _permissions)
+            {
+                AddPermissionToListRecursively(permissions, permission);
+            }
+
+            return permissions;
+        }
+
+        private void AddPermissionToListRecursively(List<PermissionDefinition> permissions, PermissionDefinition permission)
+        {
+            permissions.Add(permission);
+
+            foreach (var child in permission.Children)
+            {
+                AddPermissionToListRecursively(permissions, child);
+            }
+        }
+
+        public override string ToString()
+        {
+            return $"[{nameof(PermissionGroupDefinition)} {Name}]";
+        }
+    }
+}

test/Volo.Abp.Permissions.Tests/Volo/Abp/Permissions/TestPermissionDefinitionProvider.cs

@@ -4,9 +4,11 @@
     {
         public override void Define(IPermissionDefinitionContext context)
         {
-            context.Add("MyPermission1");
+            var testGroup = context.AddGroup("TestGroup");
 
-            var myPermission2 = context.Add("MyPermission2");
+            testGroup.AddPermission("MyPermission1");
+
+            var myPermission2 = testGroup.AddPermission("MyPermission2");
             myPermission2.AddChild("MyPermission2.ChildPermission1");
         }
     }