Update the package and pass the build.

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo.Abp.IdentityServer.Domain.csproj

@@ -25,8 +25,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="IdentityServer4" Version="3.1.3" />
+    <PackageReference Include="IdentityServer4" Version="4.0.1" />
-    <PackageReference Include="IdentityServer4.AspNetIdentity" Version="3.1.3" />
+    <PackageReference Include="IdentityServer4.AspNetIdentity" Version="4.0.1" />
   </ItemGroup>
 
 </Project>

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/ApiResources/ApiScope.cs

@@ -25,6 +25,8 @@ namespace Volo.Abp.IdentityServer.ApiResources
 
         public virtual List<ApiScopeClaim> UserClaims { get; protected set; }
 
+        public virtual Dictionary<string, string> Properties { get; protected set; }
+
         protected ApiScope()
         {
 
@@ -36,12 +38,12 @@ namespace Volo.Abp.IdentityServer.ApiResources
         }
 
         protected internal ApiScope(
-            Guid apiResourceId, 
+            Guid apiResourceId,
-            [NotNull] string name, 
+            [NotNull] string name,
-            string displayName = null, 
+            string displayName = null,
-            string description = null, 
+            string description = null,
-            bool required = false, 
+            bool required = false,
-            bool emphasize = false, 
+            bool emphasize = false,
             bool showInDiscoveryDocument = true)
         {
             Check.NotNull(name, nameof(name));
@@ -55,6 +57,7 @@ namespace Volo.Abp.IdentityServer.ApiResources
             ShowInDiscoveryDocument = showInDiscoveryDocument;
 
             UserClaims = new List<ApiScopeClaim>();
+            Properties = new Dictionary<string, string>();
         }
 
         public virtual void AddUserClaim([NotNull] string type)
@@ -82,4 +85,4 @@ namespace Volo.Abp.IdentityServer.ApiResources
             return new object[] { ApiResourceId, Name };
         }
     }
-}
+}

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/ApiResources/IApiResourceRepository.cs

@@ -8,8 +8,8 @@ namespace Volo.Abp.IdentityServer.ApiResources
 {
     public interface IApiResourceRepository : IBasicRepository<ApiResource, Guid>
     {
-        Task<ApiResource> FindByNameAsync(
+        Task<List<ApiResource>> FindByNameAsync(
-            string name,
+            string[] apiResourceNames,
             bool includeDetails = true,
             CancellationToken cancellationToken = default
         );
@@ -40,4 +40,4 @@ namespace Volo.Abp.IdentityServer.ApiResources
             CancellationToken cancellationToken = default
         );
     }
-}
+}

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/ApiResources/IApiScopeeRepository.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Repositories;
+
+namespace Volo.Abp.IdentityServer.ApiResources
+{
+    public interface IApiScopeRepository : IBasicRepository<ApiScope>
+    {
+        Task<List<ApiScope>> GetListByNameAsync(
+            string[] scopeNames,
+            bool includeDetails = false,
+            CancellationToken cancellationToken = default
+        );
+    }
+}

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/AspNetIdentity/AbpResourceOwnerPasswordValidator.cs

@@ -21,7 +21,6 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
     public class AbpResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
     {
         protected SignInManager<IdentityUser> SignInManager { get; }
-        protected IEventService Events { get; }
         protected UserManager<IdentityUser> UserManager { get; }
         protected ILogger<ResourceOwnerPasswordValidator<IdentityUser>> Logger { get; }
         protected IStringLocalizer<AbpIdentityServerResource> Localizer { get; }
@@ -29,13 +28,11 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
         public AbpResourceOwnerPasswordValidator(
             UserManager<IdentityUser> userManager,
             SignInManager<IdentityUser> signInManager,
-            IEventService events,
+            ILogger<ResourceOwnerPasswordValidator<IdentityUser>> logger,
-            ILogger<ResourceOwnerPasswordValidator<IdentityUser>> logger, 
             IStringLocalizer<AbpIdentityServerResource> localizer)
         {
             UserManager = userManager;
             SignInManager = signInManager;
-            Events = events;
             Logger = logger;
             Localizer = localizer;
         }
@@ -59,7 +56,6 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
                     var sub = await UserManager.GetUserIdAsync(user);
 
                     Logger.LogInformation("Credentials validated for username: {username}", context.UserName);
-                    await Events.RaiseAsync(new UserLoginSuccessEvent(context.UserName, sub, context.UserName, interactive: false));
 
                     var additionalClaims = new List<Claim>();
 
@@ -76,26 +72,22 @@ namespace Volo.Abp.IdentityServer.AspNetIdentity
                 else if (result.IsLockedOut)
                 {
                     Logger.LogInformation("Authentication failed for username: {username}, reason: locked out", context.UserName);
-                    await Events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "locked out", interactive: false));
                     errorDescription = Localizer["UserLockedOut"];
                 }
                 else if (result.IsNotAllowed)
                 {
                     Logger.LogInformation("Authentication failed for username: {username}, reason: not allowed", context.UserName);
-                    await Events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "not allowed", interactive: false));
                     errorDescription = Localizer["LoginIsNotAllowed"];
                 }
                 else
                 {
                     Logger.LogInformation("Authentication failed for username: {username}, reason: invalid credentials", context.UserName);
-                    await Events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "invalid credentials", interactive: false));
                     errorDescription = Localizer["InvalidUserNameOrPassword"];
                 }
             }
             else
             {
                 Logger.LogInformation("No user found matching username: {username}", context.UserName);
-                await Events.RaiseAsync(new UserLoginFailureEvent(context.UserName, "invalid username", interactive: false));
                 errorDescription = Localizer["InvalidUsername"];
             }
 

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/Grants/IPersistentGrantRepository.cs

@@ -8,6 +8,12 @@ namespace Volo.Abp.IdentityServer.Grants
 {
     public interface IPersistentGrantRepository : IBasicRepository<PersistedGrant, Guid>
     {
+        Task<List<PersistedGrant>> GetListAsync(
+            string subjectId,
+            string sessionId,
+            string clientId,
+            string type, bool includeDetails = false, CancellationToken cancellationToken = default);
+
         Task<PersistedGrant> FindByKeyAsync(
             string key,
             CancellationToken cancellationToken = default
@@ -25,16 +31,11 @@ namespace Volo.Abp.IdentityServer.Grants
         );
 
         Task DeleteAsync(
-            string subjectId,
+            string subjectId = null,
-            string clientId,
+            string sessionId = null,
-            CancellationToken cancellationToken = default
+            string clientId = null,
-        );
+            string type = null,
-
-        Task DeleteAsync(
-            string subjectId,
-            string clientId,
-            string type,
             CancellationToken cancellationToken = default
         );
     }
-}
+}

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/Grants/PersistedGrantStore.cs

@@ -44,10 +44,10 @@ namespace Volo.Abp.IdentityServer.Grants
             return ObjectMapper.Map<PersistedGrant, IdentityServer4.Models.PersistedGrant>(persistedGrant);
         }
 
-        public virtual async Task<IEnumerable<IdentityServer4.Models.PersistedGrant>> GetAllAsync(string subjectId)
+        public virtual async Task<IEnumerable<IdentityServer4.Models.PersistedGrant>> GetAllAsync(PersistedGrantFilter filter)
         {
-            var persistedGrants = await PersistentGrantRepository.GetListBySubjectIdAsync(subjectId);
+            var persistedGrants = await PersistentGrantRepository.GetListAsync(filter.SubjectId, filter.SessionId, filter.ClientId, filter.Type);
-            return persistedGrants.Select(x => ObjectMapper.Map<PersistedGrant, IdentityServer4.Models.PersistedGrant>(x));
+            return ObjectMapper.Map<List<PersistedGrant>, List<IdentityServer4.Models.PersistedGrant>>(persistedGrants);
         }
 
         public virtual async Task RemoveAsync(string key)
@@ -61,14 +61,9 @@ namespace Volo.Abp.IdentityServer.Grants
             await PersistentGrantRepository.DeleteAsync(persistedGrant);
         }
 
-        public virtual async Task RemoveAllAsync(string subjectId, string clientId)
+        public virtual async Task RemoveAllAsync(PersistedGrantFilter filter)
         {
-            await PersistentGrantRepository.DeleteAsync(subjectId, clientId);
+            await PersistentGrantRepository.DeleteAsync(filter.SubjectId, filter.SessionId, filter.ClientId, filter.Type);
-        }
-
-        public virtual async Task RemoveAllAsync(string subjectId, string clientId, string type)
-        {
-            await PersistentGrantRepository.DeleteAsync(subjectId, clientId, type);
         }
     }
 }

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/IdentityResources/IIdentityResourceRepository.cs

@@ -8,7 +8,7 @@ namespace Volo.Abp.IdentityServer.IdentityResources
 {
     public interface IIdentityResourceRepository : IBasicRepository<IdentityResource, Guid>
     {
-        Task<List<IdentityResource>> GetListByScopesAsync(
+        Task<List<IdentityResource>> GetListByScopeNameAsync(
             string[] scopeNames,
             bool includeDetails = false,
             CancellationToken cancellationToken = default
@@ -35,4 +35,4 @@ namespace Volo.Abp.IdentityServer.IdentityResources
             CancellationToken cancellationToken = default
          );
     }
-}
+}

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/IdentityServerAutoMapperProfile.cs

@@ -37,7 +37,7 @@ namespace Volo.Abp.IdentityServer
 
             CreateMap<ApiSecret, IdentityServer4.Models.Secret>();
 
-            CreateMap<ApiScope, IdentityServer4.Models.Scope>();
+            CreateMap<ApiScope, IdentityServer4.Models.ApiScope>();
 
             CreateMap<ClientProperty, KeyValuePair<string, string>>()
               .ReverseMap();

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/ResourceStore.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using IdentityServer4.Models;
@@ -6,8 +6,7 @@ using IdentityServer4.Stores;
 using Volo.Abp.IdentityServer.ApiResources;
 using Volo.Abp.IdentityServer.IdentityResources;
 using Volo.Abp.ObjectMapping;
-using ApiResource = IdentityServer4.Models.ApiResource;
+using ApiScope = Volo.Abp.IdentityServer.ApiResources.ApiScope;
-using IdentityResource = Volo.Abp.IdentityServer.IdentityResources.IdentityResource;
 
 namespace Volo.Abp.IdentityServer
 {
@@ -15,45 +14,70 @@ namespace Volo.Abp.IdentityServer
     {
         protected IIdentityResourceRepository IdentityResourceRepository { get; }
         protected IApiResourceRepository ApiResourceRepository { get; }
+        protected IApiScopeRepository ApiScopeRepository { get; }
         protected IObjectMapper<AbpIdentityServerDomainModule> ObjectMapper { get; }
 
         public ResourceStore(
-            IIdentityResourceRepository identityResourceRepository, 
+            IIdentityResourceRepository identityResourceRepository,
-            IObjectMapper<AbpIdentityServerDomainModule> objectMapper, 
+            IObjectMapper<AbpIdentityServerDomainModule> objectMapper,
-            IApiResourceRepository apiResourceRepository)
+            IApiResourceRepository apiResourceRepository,
+            IApiScopeRepository apiScopeRepository)
         {
             IdentityResourceRepository = identityResourceRepository;
             ObjectMapper = objectMapper;
             ApiResourceRepository = apiResourceRepository;
+            ApiScopeRepository = apiScopeRepository;
         }
 
-        public virtual async Task<IEnumerable<IdentityServer4.Models.IdentityResource>> FindIdentityResourcesByScopeAsync(IEnumerable<string> scopeNames)
+        /// <summary>
+        /// Gets identity resources by scope name.
+        /// </summary>
+        public virtual async Task<IEnumerable<IdentityServer4.Models.IdentityResource>> FindIdentityResourcesByScopeNameAsync(IEnumerable<string> scopeNames)
         {
-            var resource = await IdentityResourceRepository.GetListByScopesAsync(scopeNames.ToArray(), includeDetails: true);
+            var resource = await IdentityResourceRepository.GetListByScopeNameAsync(scopeNames.ToArray(), includeDetails: true);
-            return ObjectMapper.Map<List<IdentityResource>, List<IdentityServer4.Models.IdentityResource>>(resource);
+            return ObjectMapper.Map<List<Volo.Abp.IdentityServer.IdentityResources.IdentityResource>, List<IdentityServer4.Models.IdentityResource>>(resource);
         }
 
-        public virtual async Task<IEnumerable<ApiResource>> FindApiResourcesByScopeAsync(IEnumerable<string> scopeNames)
+        /// <summary>
+        /// Gets API scopes by scope name.
+        /// </summary>
+        public virtual async Task<IEnumerable<IdentityServer4.Models.ApiScope>> FindApiScopesByNameAsync(IEnumerable<string> scopeNames)
+        {
+            var scopes = await ApiScopeRepository.GetListByNameAsync(scopeNames.ToArray(), includeDetails: true);
+            return ObjectMapper.Map<List<Volo.Abp.IdentityServer.ApiResources.ApiScope>, List<IdentityServer4.Models.ApiScope>>(scopes);
+        }
+
+        /// <summary>
+        /// Gets API resources by scope name.
+        /// </summary>
+        public virtual async Task<IEnumerable<IdentityServer4.Models.ApiResource>> FindApiResourcesByScopeNameAsync(IEnumerable<string> scopeNames)
         {
             var resources = await ApiResourceRepository.GetListByScopesAsync(scopeNames.ToArray(), includeDetails: true);
-            return resources.Select(x => ObjectMapper.Map<ApiResources.ApiResource, ApiResource>(x));
+            return ObjectMapper.Map<List<Volo.Abp.IdentityServer.ApiResources.ApiResource>, List<IdentityServer4.Models.ApiResource>>(resources);
         }
 
-        public virtual async Task<ApiResource> FindApiResourceAsync(string name)
+        /// <summary>
+        /// Gets API resources by API resource name.
+        /// </summary>
+        public virtual async Task<IEnumerable<IdentityServer4.Models.ApiResource>> FindApiResourcesByNameAsync(IEnumerable<string> apiResourceNames)
         {
-            var resource = await ApiResourceRepository.FindByNameAsync(name);
+            var resources = await ApiResourceRepository.FindByNameAsync(apiResourceNames.ToArray(), includeDetails: true);
-            return ObjectMapper.Map<ApiResources.ApiResource, ApiResource>(resource);
+            return ObjectMapper.Map<List<Volo.Abp.IdentityServer.ApiResources.ApiResource>, List<IdentityServer4.Models.ApiResource>>(resources);
         }
 
-        public virtual async Task<Resources> GetAllResourcesAsync()
+        /// <summary>
+        /// Gets all resources.
+        /// </summary>
+        public virtual async Task<IdentityServer4.Models.Resources> GetAllResourcesAsync()
         {
             var identityResources = await IdentityResourceRepository.GetListAsync(includeDetails: true);
             var apiResources = await ApiResourceRepository.GetListAsync(includeDetails: true);
+            var apiScopes = await ApiScopeRepository.GetListAsync(includeDetails: true);
 
             return new Resources(
-                ObjectMapper.Map<List<IdentityResource>, IdentityServer4.Models.IdentityResource[]>(identityResources),
+                ObjectMapper.Map<List<Volo.Abp.IdentityServer.IdentityResources.IdentityResource>, List<IdentityServer4.Models.IdentityResource>>(identityResources),
-                ObjectMapper.Map<List<ApiResources.ApiResource>, ApiResource[]>(apiResources)
+                ObjectMapper.Map<List<Volo.Abp.IdentityServer.ApiResources.ApiResource>, List<IdentityServer4.Models.ApiResource>>(apiResources),
-            );
+                ObjectMapper.Map<List<Volo.Abp.IdentityServer.ApiResources.ApiScope>, List<IdentityServer4.Models.ApiScope>>(apiScopes));
         }
     }
 }

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/AbpIdentityServerEfCoreQueryableExtensions.cs

@@ -22,6 +22,18 @@ namespace Volo.Abp.IdentityServer
                 .ThenInclude(s => s.UserClaims);
         }
 
+        public static IQueryable<ApiScope> IncludeDetails(this IQueryable<ApiScope> queryable, bool include = true)
+        {
+            if (!include)
+            {
+                return queryable;
+            }
+
+            return queryable
+                .Include(x => x.UserClaims)
+                .Include(x => x.Properties);
+        }
+
         public static IQueryable<IdentityResource> IncludeDetails(this IQueryable<IdentityResource> queryable, bool include = true)
         {
             if (!include)
@@ -30,7 +42,8 @@ namespace Volo.Abp.IdentityServer
             }
 
             return queryable
-                .Include(x => x.UserClaims);
+                .Include(x => x.UserClaims)
+                .Include(x => x.Properties);
         }
 
         public static IQueryable<Client> IncludeDetails(this IQueryable<Client> queryable, bool include = true)
@@ -52,4 +65,4 @@ namespace Volo.Abp.IdentityServer
                 .Include(x => x.Properties);
         }
     }
-}
+}

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/ApiResources/ApiResourceRepository.cs

@@ -19,17 +19,14 @@ namespace Volo.Abp.IdentityServer.ApiResources
 
         }
 
-        public virtual async Task<ApiResource> FindByNameAsync(
+        public async Task<List<ApiResource>> FindByNameAsync(string[] apiResourceNames, bool includeDetails = true,
-            string name,
-            bool includeDetails = true,
             CancellationToken cancellationToken = default)
         {
             var query = from apiResource in DbSet.IncludeDetails(includeDetails)
-                        where apiResource.Name == name
+                where apiResourceNames.Contains(apiResource.Name)
-                        select apiResource;
+                select apiResource;
 
-            return await query
+            return await query.ToListAsync(GetCancellationToken(cancellationToken));
-                .FirstOrDefaultAsync(GetCancellationToken(cancellationToken));
         }
 
         public virtual async Task<List<ApiResource>> GetListByScopesAsync(
@@ -45,7 +42,10 @@ namespace Volo.Abp.IdentityServer.ApiResources
         }
 
         public virtual async Task<List<ApiResource>> GetListAsync(
-            string sorting, int skipCount, int maxResultCount, string filter, bool includeDetails = false,
+            string sorting, int skipCount,
+            int maxResultCount,
+            string filter,
+            bool includeDetails = false,
             CancellationToken cancellationToken = default)
         {
             return await DbSet
@@ -96,4 +96,4 @@ namespace Volo.Abp.IdentityServer.ApiResources
             return GetQueryable().IncludeDetails();
         }
     }
-}
+}

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/ApiResources/ApiScopeRepository.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+using Volo.Abp.IdentityServer.EntityFrameworkCore;
+
+namespace Volo.Abp.IdentityServer.ApiResources
+{
+    public class ApiScopeRepository : EfCoreRepository<IIdentityServerDbContext, ApiScope>, IApiScopeRepository
+    {
+        public ApiScopeRepository(IDbContextProvider<IIdentityServerDbContext> dbContextProvider) : base(
+            dbContextProvider)
+        {
+        }
+
+        public async Task<List<ApiScope>> GetListByNameAsync(string[] scopeNames, bool includeDetails = false,
+            CancellationToken cancellationToken = default)
+        {
+            var query = from scope in DbSet.IncludeDetails(includeDetails)
+                where scopeNames.Contains(scope.Name)
+                select scope;
+
+            return await query.ToListAsync(GetCancellationToken(cancellationToken));
+        }
+    }
+}

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/Grants/PersistedGrantRepository.cs

@@ -12,19 +12,24 @@ namespace Volo.Abp.IdentityServer.Grants
 {
     public class PersistentGrantRepository : EfCoreRepository<IIdentityServerDbContext, PersistedGrant, Guid>, IPersistentGrantRepository
     {
-        public PersistentGrantRepository(IDbContextProvider<IIdentityServerDbContext> dbContextProvider) 
+        public PersistentGrantRepository(IDbContextProvider<IIdentityServerDbContext> dbContextProvider)
             : base(dbContextProvider)
         {
 
         }
 
+        public async Task<List<PersistedGrant>> GetListAsync(string subjectId, string sessionId, string clientId, string type, bool includeDetails = false,
+            CancellationToken cancellationToken = default)
+        {
+            return await Filter(subjectId, sessionId, clientId, type)
+                .ToListAsync(GetCancellationToken(cancellationToken));
+        }
+
         public virtual async Task<PersistedGrant> FindByKeyAsync(
             string key,
             CancellationToken cancellationToken = default)
         {
-            return await DbSet
+            return await DbSet.FirstOrDefaultAsync(x => x.Key == key, GetCancellationToken(cancellationToken));
-                .FirstOrDefaultAsync(x => x.Key == key, GetCancellationToken(cancellationToken))
-                ;
         }
 
         public virtual async Task<List<PersistedGrant>> GetListBySubjectIdAsync(
@@ -37,7 +42,7 @@ namespace Volo.Abp.IdentityServer.Grants
         }
 
         public virtual async Task<List<PersistedGrant>> GetListByExpirationAsync(
-            DateTime maxExpirationDate, 
+            DateTime maxExpirationDate,
             int maxResultCount,
             CancellationToken cancellationToken = default)
         {
@@ -48,27 +53,33 @@ namespace Volo.Abp.IdentityServer.Grants
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
-        public virtual async Task DeleteAsync(
+        public async Task DeleteAsync(
-            string subjectId, 
+            string subjectId = null,
-            string clientId,
+            string sessionId = null,
+            string clientId = null,
+            string type = null,
             CancellationToken cancellationToken = default)
         {
-            await DeleteAsync(
+            var persistedGrants = await Filter(subjectId, sessionId, clientId, type).ToListAsync(GetCancellationToken(cancellationToken));
-                x => x.SubjectId == subjectId && x.ClientId == clientId,
+
-                cancellationToken: GetCancellationToken(cancellationToken)
+            foreach (var persistedGrant in persistedGrants)
-            );
+            {
+                DbSet.Remove(persistedGrant);
+            }
         }
 
-        public virtual async Task DeleteAsync(
+        private IQueryable<PersistedGrant> Filter(
-            string subjectId, 
+            string subjectId,
-            string clientId, 
+            string sessionId,
-            string type,
+            string clientId,
-            CancellationToken cancellationToken = default)
+            string type)
         {
-            await DeleteAsync(
+            //IDS TODO: add SessionId to entity
-                x => x.SubjectId == subjectId && x.ClientId == clientId && x.Type == type,
+            return DbSet
-                cancellationToken: GetCancellationToken(cancellationToken)
+                .WhereIf(!subjectId.IsNullOrWhiteSpace(), x => x.SubjectId == subjectId)
-            );
+                // .WhereIf(!sessionId.IsNullOrWhiteSpace(), x => x.SessionId == sessionId)
+                .WhereIf(!clientId.IsNullOrWhiteSpace(), x => x.ClientId == clientId)
+                .WhereIf(!type.IsNullOrWhiteSpace(), x => x.Type == type);
         }
     }
 }

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/IdentityResources/IdentityResourceRepository.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -19,7 +19,7 @@ namespace Volo.Abp.IdentityServer.IdentityResources
 
         }
 
-        public virtual async Task<List<IdentityResource>> GetListByScopesAsync(
+        public virtual async Task<List<IdentityResource>> GetListByScopeNameAsync(
             string[] scopeNames,
             bool includeDetails = false,
             CancellationToken cancellationToken = default)

modules/identityserver/src/Volo.Abp.IdentityServer.MongoDB/Volo/Abp/IdentityServer/MongoDB/MongoApiResourceRepository.cs

@@ -18,11 +18,12 @@ namespace Volo.Abp.IdentityServer.MongoDB
         {
         }
 
-        public virtual async Task<ApiResource> FindByNameAsync(string name, bool includeDetails = true, CancellationToken cancellationToken = default)
+        public async Task<List<ApiResource>> FindByNameAsync(string[] apiResourceNames, bool includeDetails = true,
+            CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable()
-                .Where(ar => ar.Name == name)
+                .Where(ar => apiResourceNames.Contains(ar.Name))
-                .FirstOrDefaultAsync(GetCancellationToken(cancellationToken));
+                .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
         public virtual async Task<List<ApiResource>> GetListByScopesAsync(string[] scopeNames, bool includeDetails = false,

modules/identityserver/src/Volo.Abp.IdentityServer.MongoDB/Volo/Abp/IdentityServer/MongoDB/MongoIdentityResourceRepository.cs

@@ -40,7 +40,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 .FirstOrDefaultAsync(GetCancellationToken(cancellationToken));
         }
 
-        public virtual async Task<List<IdentityResource>> GetListByScopesAsync(string[] scopeNames, bool includeDetails = false,
+        public virtual async Task<List<IdentityResource>> GetListByScopeNameAsync(string[] scopeNames, bool includeDetails = false,
             CancellationToken cancellationToken = default)
         {
             return await GetMongoQueryable()

modules/identityserver/src/Volo.Abp.IdentityServer.MongoDB/Volo/Abp/IdentityServer/MongoDB/MongoPersistedGrantRepository.cs

@@ -16,6 +16,13 @@ namespace Volo.Abp.IdentityServer.MongoDB
         {
         }
 
+        public async Task<List<PersistedGrant>> GetListAsync(string subjectId, string sessionId, string clientId, string type, bool includeDetails = false,
+            CancellationToken cancellationToken = default)
+        {
+            return await Filter(subjectId, sessionId, clientId, type)
+                .ToListAsync(GetCancellationToken(cancellationToken));
+        }
+
         public virtual async Task<PersistedGrant> FindByKeyAsync(string key, CancellationToken cancellationToken = default)
         {
 
@@ -27,8 +34,7 @@ namespace Volo.Abp.IdentityServer.MongoDB
         {
             return await GetMongoQueryable()
                 .Where(x => x.SubjectId == subjectId)
-                .ToListAsync(GetCancellationToken(cancellationToken))
+                .ToListAsync(GetCancellationToken(cancellationToken));
-                ;
         }
 
         public virtual async Task<List<PersistedGrant>> GetListByExpirationAsync(DateTime maxExpirationDate, int maxResultCount,
@@ -41,6 +47,22 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 .ToListAsync(GetCancellationToken(cancellationToken));
         }
 
+        public async Task DeleteAsync(
+            string subjectId = null,
+            string sessionId = null,
+            string clientId = null,
+            string type = null,
+            CancellationToken cancellationToken = default)
+        {
+            var persistedGrants = await Filter(subjectId, sessionId, clientId, type)
+                .ToListAsync(GetCancellationToken(cancellationToken));
+
+            foreach (var persistedGrant in persistedGrants)
+            {
+                await DeleteAsync(persistedGrant, false, GetCancellationToken(cancellationToken));
+            }
+        }
+
         public virtual async Task DeleteAsync(string subjectId, string clientId, CancellationToken cancellationToken = default)
         {
             await DeleteAsync(
@@ -56,5 +78,20 @@ namespace Volo.Abp.IdentityServer.MongoDB
                 cancellationToken: GetCancellationToken(cancellationToken)
             );
         }
+
+        private IMongoQueryable<PersistedGrant> Filter(
+            string subjectId,
+            string sessionId,
+            string clientId,
+            string type)
+        {
+            //IDS TODO: add SessionId to entity
+            return GetMongoQueryable()
+                .WhereIf(!subjectId.IsNullOrWhiteSpace(), x => x.SubjectId == subjectId)
+                // .WhereIf(!sessionId.IsNullOrWhiteSpace(), x => x.SessionId == sessionId)
+                .WhereIf(!clientId.IsNullOrWhiteSpace(), x => x.ClientId == clientId)
+                .WhereIf(!type.IsNullOrWhiteSpace(), x => x.Type == type)
+                .As<IMongoQueryable<PersistedGrant>>();
+        }
     }
 }

modules/identityserver/test/Volo.Abp.IdentityServer.Domain.Tests/Volo/Abp/IdentityServer/Clients/IdentityResourceStore_Tests.cs

@@ -22,7 +22,7 @@ namespace Volo.Abp.IdentityServer.Clients
         public async Task FindApiResourceAsync_Should_Return_Null_If_Not_Found()
         {
             //Act
-            var resource = await _resourceStore.FindApiResourceAsync("non-existing-name");
+            var resource = await _resourceStore.FindApiResourcesByNameAsync(new []{"non-existing-name"});
 
             //Assert
             resource.ShouldBeNull();
@@ -32,7 +32,7 @@ namespace Volo.Abp.IdentityServer.Clients
         public async Task FindApiResourceAsync_Should_Return_If_Found()
         {
             //Act
-            var apiResource = await _resourceStore.FindApiResourceAsync("Test-ApiResource-Name-1");
+            var apiResource = (await _resourceStore.FindApiResourcesByNameAsync(new []{"Test-ApiResource-Name-1"})).FirstOrDefault();
 
             //Assert
             apiResource.ShouldNotBe(null);
@@ -45,7 +45,7 @@ namespace Volo.Abp.IdentityServer.Clients
         public async Task FindApiResourcesByScopeAsync_Should_Return_If_Found()
         {
             //Act
-            var apiResources = (await _resourceStore.FindApiResourcesByScopeAsync(new List<string>
+            var apiResources = (await _resourceStore.FindApiResourcesByScopeNameAsync(new List<string>
             {
                 "Test-ApiResource-ApiScope-Name-1"
             })).ToList();
@@ -60,17 +60,18 @@ namespace Volo.Abp.IdentityServer.Clients
         public async Task FindIdentityResourcesByScopeAsync_Should_Return_For_Given_Scopes()
         {
             //Act
-            var identityResourcesByScope = await _resourceStore.FindIdentityResourcesByScopeAsync(new List<string>
+            var identityResourcesByScope = (await _resourceStore.FindApiResourcesByScopeNameAsync(new List<string>
             {
                 "Test-Identity-Resource-Name-1"
-            });
+            })).ToArray();
 
             //Assert
-            var resourcesByScope = identityResourcesByScope as IdentityResource[] ?? identityResourcesByScope.ToArray();
+            identityResourcesByScope.Length.ShouldBe(1);
-            resourcesByScope.Length.ShouldBe(1);
+            identityResourcesByScope.First().DisplayName.ShouldBe("Test-Identity-Resource-DisplayName-1");
-            resourcesByScope.First().DisplayName.ShouldBe("Test-Identity-Resource-DisplayName-1");
+            identityResourcesByScope.First().Description.ShouldBe("Test-Identity-Resource-Description-1");
-            resourcesByScope.First().Description.ShouldBe("Test-Identity-Resource-Description-1");
+
-            resourcesByScope.First().Required.ShouldBe(true);
+            //IDS TODO:
+            //identityResourcesByScope.First().Required.ShouldBe(true);
         }
 
         [Fact]

modules/identityserver/test/Volo.Abp.IdentityServer.Domain.Tests/Volo/Abp/IdentityServer/Clients/PersistentGrant_Tests.cs

@@ -122,7 +122,10 @@ namespace Volo.Abp.IdentityServer.Clients
         public async Task GetAllAsync_Should_Get_All_PersistedGrants_For_A_Given_SubjectId()
         {
             //Act
-            var persistentGrants = await _persistedGrantStore.GetAllAsync("TestSubject");
+            var persistentGrants = await _persistedGrantStore.GetAllAsync(new PersistedGrantFilter()
+            {
+                SubjectId = "TestSubject"
+            });
 
             //Assert
             var persistedGrants = persistentGrants as PersistedGrant[] ?? persistentGrants.ToArray();
@@ -156,16 +159,27 @@ namespace Volo.Abp.IdentityServer.Clients
         public async Task RemoveAllAsync_Should_RemoveAll_PeristedGrants_For_A_Given_Subject_And_ClientId()
         {
             //Arrange
-            var persistedGrantsWithTestSubjectX = await _persistedGrantStore.GetAllAsync("TestSubject-X");
+            var persistedGrantsWithTestSubjectX = await _persistedGrantStore.GetAllAsync(new PersistedGrantFilter()
+            {
+                SubjectId = "TestSubject-X"
+            });
             var persistedGrantsWithTestSubjectXBeforeLength = persistedGrantsWithTestSubjectX.ToArray().Length;
 
             //Act
-            await _persistedGrantStore.RemoveAllAsync("TestSubject-X", "TestClientId-X");
+            await _persistedGrantStore.RemoveAllAsync(new PersistedGrantFilter()
+            {
+                SubjectId = "TestSubject-X",
+                ClientId =  "TestClientId-X"
+            });
 
             //Assert
             persistedGrantsWithTestSubjectXBeforeLength.ShouldBe(2);
 
-            var persistedGrants = (await _persistedGrantStore.GetAllAsync("TestClientId-37")).ToArray();
+            var persistedGrants = (await _persistedGrantStore.GetAllAsync(new PersistedGrantFilter()
+            {
+                SubjectId = "TestClientId-37"
+            })).ToArray();
+
             persistedGrants.ShouldNotBe(null);
             persistedGrants.Length.ShouldBe(0);
         }

modules/identityserver/test/Volo.Abp.IdentityServer.TestBase/Volo/Abp/IdentityServer/ApiResourceRepository_Tests.cs

@@ -20,7 +20,7 @@ namespace Volo.Abp.IdentityServer
         [Fact]
         public async Task FindByNormalizedNameAsync()
         {
-            (await apiResourceRepository.FindByNameAsync("NewApiResource2")).ShouldNotBeNull();
+            (await apiResourceRepository.FindByNameAsync(new []{"NewApiResource2"})).ShouldNotBeNull();
         }
 
         [Fact]

modules/identityserver/test/Volo.Abp.IdentityServer.TestBase/Volo/Abp/IdentityServer/IdentityResourceRepository_Tests.cs

@@ -23,7 +23,7 @@ namespace Volo.Abp.IdentityServer
         [Fact]
         public async Task GetListByScopesAsync()
         {
-            (await identityResourceRepository.GetListByScopesAsync(new[] { "", "NewIdentityResource2" })).Count.ShouldBe(1);
+            (await identityResourceRepository.GetListByScopeNameAsync(new[] { "", "NewIdentityResource2" })).Count.ShouldBe(1);
         }
     }
 }

modules/identityserver/test/Volo.Abp.IdentityServer.TestBase/Volo/Abp/IdentityServer/PersistentGrantRepository_Tests.cs

@@ -48,7 +48,7 @@ namespace Volo.Abp.IdentityServer
         [Fact]
         public async Task DeleteBySubjectIdAndClientIdAndType()
         {
-            await _persistentGrantRepository.DeleteAsync("PersistedGrantSubjectId1", "PersistedGrantClientId1",
+            await _persistentGrantRepository.DeleteAsync("PersistedGrantSubjectId1", "PersistedGrantSessionId1", "PersistedGrantClientId1",
                 "PersistedGrantClientId1");
 
             var persistedGrants = await _persistentGrantRepository.GetListAsync();