Fix openiddict cache problem.

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/AbpOpenIddictDomainModule.cs

@@ -71,6 +71,9 @@ public class AbpOpenIddictDomainModule : AbpModule
                     .AddTokenStore<AbpOpenIddictTokenStore>();
 
                 builder.ReplaceApplicationManager(typeof(AbpApplicationManager));
+                builder.ReplaceAuthorizationManager(typeof(AbpAuthorizationManager));
+                builder.ReplaceScopeManager(typeof(AbpScopeManager));
+                builder.ReplaceTokenManager(typeof(AbpTokenManager));
 
                 builder.Services.TryAddScoped(provider => (IAbpApplicationManager)provider.GetRequiredService<IOpenIddictApplicationManager>());
 

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/AbpOpenIddictIdentifierConverter.cs

@@ -0,0 +1,17 @@
+using System;
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.Abp.OpenIddict;
+
+public class AbpOpenIddictIdentifierConverter : ITransientDependency
+{
+    public virtual Guid FromString(string identifier)
+    {
+        return string.IsNullOrEmpty(identifier) ? default : Guid.Parse(identifier);
+    }
+
+    public virtual string ToString(Guid identifier)
+    {
+        return identifier.ToString("D");
+    }
+}

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/AbpOpenIddictStoreBase.cs

@@ -20,26 +20,28 @@ public abstract class AbpOpenIddictStoreBase<TRepository>
     protected TRepository Repository { get; }
     protected IUnitOfWorkManager UnitOfWorkManager { get; }
     protected IGuidGenerator GuidGenerator { get; }
+    protected AbpOpenIddictIdentifierConverter IdentifierConverter { get; }
 
-    protected AbpOpenIddictStoreBase(TRepository repository, IUnitOfWorkManager unitOfWorkManager, IGuidGenerator guidGenerator)
+    protected AbpOpenIddictStoreBase(TRepository repository, IUnitOfWorkManager unitOfWorkManager, IGuidGenerator guidGenerator, AbpOpenIddictIdentifierConverter identifierConverter)
     {
         Repository = repository;
         UnitOfWorkManager = unitOfWorkManager;
         GuidGenerator = guidGenerator;
+        IdentifierConverter = identifierConverter;
 
         Logger = NullLogger<AbpOpenIddictStoreBase<TRepository>>.Instance;
     }
 
     protected virtual Guid ConvertIdentifierFromString(string identifier)
     {
-        return string.IsNullOrEmpty(identifier) ? default : Guid.Parse(identifier);
+        return IdentifierConverter.FromString(identifier);
     }
 
     protected virtual string ConvertIdentifierToString(Guid identifier)
     {
-        return identifier.ToString("D");
+        return IdentifierConverter.ToString(identifier);
     }
-    
+
     protected virtual string WriteStream(Action<Utf8JsonWriter> action)
     {
         using (var stream = new MemoryStream())

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Applications/AbpApplicationManager.cs

@@ -11,14 +11,31 @@ namespace Volo.Abp.OpenIddict.Applications;
 
 public class AbpApplicationManager : OpenIddictApplicationManager<OpenIddictApplicationModel>, IAbpApplicationManager
 {
+    protected AbpOpenIddictIdentifierConverter IdentifierConverter { get; }
+
     public AbpApplicationManager(
         [NotNull] IOpenIddictApplicationCache<OpenIddictApplicationModel> cache,
         [NotNull] ILogger<AbpApplicationManager> logger,
         [NotNull] IOptionsMonitor<OpenIddictCoreOptions> options,
-        [NotNull] IOpenIddictApplicationStoreResolver resolver)
+        [NotNull] IOpenIddictApplicationStoreResolver resolver,
+        AbpOpenIddictIdentifierConverter identifierConverter)
         : base(cache, logger, options, resolver)
     {
+        IdentifierConverter = identifierConverter;
+    }
+
+    public async override ValueTask UpdateAsync(OpenIddictApplicationModel application, CancellationToken cancellationToken = default)
+    {
+        if (!Options.CurrentValue.DisableEntityCaching)
+        {
+            var entity = await Store.FindByIdAsync(IdentifierConverter.ToString(application.Id), cancellationToken);
+            if (entity != null)
+            {
+                await Cache.RemoveAsync(entity, cancellationToken);
+            }
+        }
 
+        await base.UpdateAsync(application, cancellationToken);
     }
 
     public async override ValueTask PopulateAsync(OpenIddictApplicationDescriptor descriptor, OpenIddictApplicationModel application, CancellationToken cancellationToken = default)

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Applications/AbpOpenIddictApplicationCache.cs

@@ -34,13 +34,13 @@ public class AbpOpenIddictApplicationCache : AbpOpenIddictCacheBase<OpenIddictAp
         }, token: cancellationToken);
     }
 
-    public virtual async ValueTask<OpenIddictApplicationModel> FindByClientIdAsync(string identifier, CancellationToken cancellationToken)
+    public virtual async ValueTask<OpenIddictApplicationModel> FindByClientIdAsync(string clientId, CancellationToken cancellationToken)
     {
-        Check.NotNullOrEmpty(identifier, nameof(identifier));
+        Check.NotNullOrEmpty(clientId, nameof(clientId));
 
-        return await Cache.GetOrAddAsync($"{nameof(FindByClientIdAsync)}_{identifier}", async () =>
+        return await Cache.GetOrAddAsync($"{nameof(FindByClientIdAsync)}_{clientId}", async () =>
         {
-           var application = await Store.FindByClientIdAsync(identifier, cancellationToken);
+           var application = await Store.FindByClientIdAsync(clientId, cancellationToken);
            if (application != null)
            {
                await AddAsync(application, cancellationToken);
@@ -49,13 +49,13 @@ public class AbpOpenIddictApplicationCache : AbpOpenIddictCacheBase<OpenIddictAp
         }, token: cancellationToken);
     }
 
-    public virtual async ValueTask<OpenIddictApplicationModel> FindByIdAsync(string identifier, CancellationToken cancellationToken)
+    public virtual async ValueTask<OpenIddictApplicationModel> FindByIdAsync(string id, CancellationToken cancellationToken)
     {
-        Check.NotNullOrEmpty(identifier, nameof(identifier));
+        Check.NotNullOrEmpty(id, nameof(id));
 
-        return await Cache.GetOrAddAsync($"{nameof(FindByIdAsync)}_{identifier}", async () =>
+        return await Cache.GetOrAddAsync($"{nameof(FindByIdAsync)}_{id}", async () =>
         {
-            var application = await Store.FindByIdAsync(identifier, cancellationToken);
+            var application = await Store.FindByIdAsync(id, cancellationToken);
             if (application != null)
             {
                 await AddAsync(application, cancellationToken);

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Applications/AbpOpenIddictApplicationStore.cs

@@ -22,8 +22,9 @@ public class AbpOpenIddictApplicationStore : AbpOpenIddictStoreBase<IOpenIddictA
         IOpenIddictApplicationRepository repository,
         IUnitOfWorkManager unitOfWorkManager,
         IOpenIddictTokenRepository tokenRepository,
-        IGuidGenerator guidGenerator)
-        : base(repository, unitOfWorkManager, guidGenerator)
+        IGuidGenerator guidGenerator,
+        AbpOpenIddictIdentifierConverter identifierConverter)
+        : base(repository, unitOfWorkManager, guidGenerator, identifierConverter)
     {
         TokenRepository = tokenRepository;
     }

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Authorizations/AbpAuthorizationManager.cs

@@ -0,0 +1,39 @@
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using OpenIddict.Abstractions;
+using OpenIddict.Core;
+
+namespace Volo.Abp.OpenIddict.Authorizations;
+
+public class AbpAuthorizationManager : OpenIddictAuthorizationManager<OpenIddictAuthorizationModel>
+{
+    protected AbpOpenIddictIdentifierConverter IdentifierConverter { get; }
+
+    public AbpAuthorizationManager(
+        [NotNull] [ItemNotNull] IOpenIddictAuthorizationCache<OpenIddictAuthorizationModel> cache,
+        [NotNull] [ItemNotNull] ILogger<OpenIddictAuthorizationManager<OpenIddictAuthorizationModel>> logger,
+        [NotNull] [ItemNotNull] IOptionsMonitor<OpenIddictCoreOptions> options,
+        [NotNull] IOpenIddictAuthorizationStoreResolver resolver,
+        AbpOpenIddictIdentifierConverter identifierConverter)
+        : base(cache, logger, options, resolver)
+    {
+        IdentifierConverter = identifierConverter;
+    }
+
+    public async override ValueTask UpdateAsync(OpenIddictAuthorizationModel authorization, CancellationToken cancellationToken = default)
+    {
+        if (!Options.CurrentValue.DisableEntityCaching)
+        {
+            var entity = await Store.FindByIdAsync(IdentifierConverter.ToString(authorization.Id), cancellationToken);
+            if (entity != null)
+            {
+                await Cache.RemoveAsync(entity, cancellationToken);
+            }
+        }
+
+        await base.UpdateAsync(authorization, cancellationToken);
+    }
+}

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Authorizations/AbpOpenIddictAuthorizationCache.cs

@@ -114,14 +114,14 @@ public class AbpOpenIddictAuthorizationCache : AbpOpenIddictCacheBase<OpenIddict
         }
     }
 
-    public async IAsyncEnumerable<OpenIddictAuthorizationModel> FindByApplicationIdAsync(string identifier, [EnumeratorCancellation] CancellationToken cancellationToken)
+    public async IAsyncEnumerable<OpenIddictAuthorizationModel> FindByApplicationIdAsync(string applicationId, [EnumeratorCancellation] CancellationToken cancellationToken)
     {
-        Check.NotNullOrEmpty(identifier, nameof(identifier));
+        Check.NotNullOrEmpty(applicationId, nameof(applicationId));
 
-        var authorizations = await ArrayCache.GetOrAddAsync($"{nameof(FindByApplicationIdAsync)}_{identifier}", async () =>
+        var authorizations = await ArrayCache.GetOrAddAsync($"{nameof(FindByApplicationIdAsync)}_{applicationId}", async () =>
         {
             var applications = new List<OpenIddictAuthorizationModel>();
-            await foreach (var authorization in Store.FindByApplicationIdAsync(identifier, cancellationToken))
+            await foreach (var authorization in Store.FindByApplicationIdAsync(applicationId, cancellationToken))
             {
                 applications.Add(authorization);
                 await AddAsync(authorization, cancellationToken);
@@ -135,12 +135,12 @@ public class AbpOpenIddictAuthorizationCache : AbpOpenIddictCacheBase<OpenIddict
         }
     }
 
-    public async ValueTask<OpenIddictAuthorizationModel> FindByIdAsync(string identifier, CancellationToken cancellationToken)
+    public async ValueTask<OpenIddictAuthorizationModel> FindByIdAsync(string id, CancellationToken cancellationToken)
     {
-        Check.NotNullOrEmpty(identifier, nameof(identifier));
+        Check.NotNullOrEmpty(id, nameof(id));
 
-        return await Cache.GetOrAddAsync($"{nameof(FindByIdAsync)}_{identifier}",
-            async () => await Store.FindByIdAsync(identifier, cancellationToken), token: cancellationToken);
+        return await Cache.GetOrAddAsync($"{nameof(FindByIdAsync)}_{id}",
+            async () => await Store.FindByIdAsync(id, cancellationToken), token: cancellationToken);
     }
 
     public async IAsyncEnumerable<OpenIddictAuthorizationModel> FindBySubjectAsync(string subject, [EnumeratorCancellation] CancellationToken cancellationToken)

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Authorizations/AbpOpenIddictAuthorizationStore.cs

@@ -25,8 +25,9 @@ public class AbpOpenIddictAuthorizationStore : AbpOpenIddictStoreBase<IOpenIddic
         IUnitOfWorkManager unitOfWorkManager,
         IGuidGenerator guidGenerator,
         IOpenIddictApplicationRepository applicationRepository,
-        IOpenIddictTokenRepository tokenRepository)
-        : base(repository, unitOfWorkManager, guidGenerator)
+        IOpenIddictTokenRepository tokenRepository,
+        AbpOpenIddictIdentifierConverter identifierConverter)
+        : base(repository, unitOfWorkManager, guidGenerator, identifierConverter)
     {
         ApplicationRepository = applicationRepository;
         TokenRepository = tokenRepository;

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Scopes/AbpOpenIddictScopeCache.cs

@@ -31,13 +31,13 @@ public class AbpOpenIddictScopeCache : AbpOpenIddictCacheBase<OpenIddictScope, O
         await Cache.SetAsync($"{nameof(FindByNameAsync)}_{await Store.GetNameAsync(scope, cancellationToken)}", scope, token: cancellationToken);
     }
 
-    public virtual async ValueTask<OpenIddictScopeModel> FindByIdAsync(string identifier, CancellationToken cancellationToken)
+    public virtual async ValueTask<OpenIddictScopeModel> FindByIdAsync(string id, CancellationToken cancellationToken)
     {
-        Check.NotNullOrEmpty(identifier, nameof(identifier));
+        Check.NotNullOrEmpty(id, nameof(id));
 
-        return await Cache.GetOrAddAsync($"{nameof(FindByIdAsync)}_{identifier}",  async () =>
+        return await Cache.GetOrAddAsync($"{nameof(FindByIdAsync)}_{id}",  async () =>
         {
-            var scope = await Store.FindByIdAsync(identifier, cancellationToken);
+            var scope = await Store.FindByIdAsync(id, cancellationToken);
             if (scope != null)
             {
                 await AddAsync(scope, cancellationToken);

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Scopes/AbpOpenIddictScopeStore.cs

@@ -18,8 +18,9 @@ public class AbpOpenIddictScopeStore : AbpOpenIddictStoreBase<IOpenIddictScopeRe
     public AbpOpenIddictScopeStore(
         IOpenIddictScopeRepository repository,
         IUnitOfWorkManager unitOfWorkManager,
-        IGuidGenerator guidGenerator)
-        : base(repository, unitOfWorkManager, guidGenerator)
+        IGuidGenerator guidGenerator,
+        AbpOpenIddictIdentifierConverter identifierConverter)
+        : base(repository, unitOfWorkManager, guidGenerator, identifierConverter)
     {
 
     }

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Scopes/AbpScopeManager.cs

@@ -0,0 +1,39 @@
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using OpenIddict.Abstractions;
+using OpenIddict.Core;
+
+namespace Volo.Abp.OpenIddict.Scopes;
+
+public class AbpScopeManager : OpenIddictScopeManager<OpenIddictScopeModel>
+{
+    protected AbpOpenIddictIdentifierConverter IdentifierConverter { get; }
+
+    public AbpScopeManager(
+        [NotNull] [ItemNotNull] IOpenIddictScopeCache<OpenIddictScopeModel> cache,
+        [NotNull] [ItemNotNull] ILogger<OpenIddictScopeManager<OpenIddictScopeModel>> logger,
+        [NotNull] [ItemNotNull] IOptionsMonitor<OpenIddictCoreOptions> options,
+        [NotNull] IOpenIddictScopeStoreResolver resolver,
+        AbpOpenIddictIdentifierConverter identifierConverter)
+        : base(cache, logger, options, resolver)
+    {
+        IdentifierConverter = identifierConverter;
+    }
+
+    public async override ValueTask UpdateAsync(OpenIddictScopeModel scope, CancellationToken cancellationToken = default)
+    {
+        if (!Options.CurrentValue.DisableEntityCaching)
+        {
+            var entity = await Store.FindByIdAsync(IdentifierConverter.ToString(scope.Id), cancellationToken);
+            if (entity != null)
+            {
+                await Cache.RemoveAsync(entity, cancellationToken);
+            }
+        }
+
+        await base.UpdateAsync(scope, cancellationToken);
+    }
+}

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Tokens/AbpOpenIddictTokenStore.cs

@@ -25,8 +25,9 @@ public class AbpOpenIddictTokenStore : AbpOpenIddictStoreBase<IOpenIddictTokenRe
         IUnitOfWorkManager unitOfWorkManager,
         IGuidGenerator guidGenerator,
         IOpenIddictApplicationRepository applicationRepository,
-        IOpenIddictAuthorizationRepository authorizationRepository)
-        : base(repository, unitOfWorkManager, guidGenerator)
+        IOpenIddictAuthorizationRepository authorizationRepository,
+        AbpOpenIddictIdentifierConverter identifierConverter)
+        : base(repository, unitOfWorkManager, guidGenerator, identifierConverter)
     {
         ApplicationRepository = applicationRepository;
         AuthorizationRepository = authorizationRepository;
@@ -47,7 +48,7 @@ public class AbpOpenIddictTokenStore : AbpOpenIddictStoreBase<IOpenIddictTokenRe
         Check.NotNull(token, nameof(token));
 
         await Repository.InsertAsync(token.ToEntity(), autoSave: true, cancellationToken: cancellationToken);
-        
+
         token = (await Repository.FindAsync(token.Id, cancellationToken: cancellationToken)).ToModel();
     }
 
@@ -444,7 +445,7 @@ public class AbpOpenIddictTokenStore : AbpOpenIddictStoreBase<IOpenIddictTokenRe
         var entity = await Repository.GetAsync(token.Id, cancellationToken: cancellationToken);
 
         await Repository.UpdateAsync(token.ToEntity(entity), autoSave: true, cancellationToken: cancellationToken);
-        
+
         token = (await Repository.FindAsync(entity.Id, cancellationToken: cancellationToken)).ToModel();
     }
 }

modules/openiddict/src/Volo.Abp.OpenIddict.Domain/Volo/Abp/OpenIddict/Tokens/AbpTokenManager.cs

@@ -0,0 +1,39 @@
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using OpenIddict.Abstractions;
+using OpenIddict.Core;
+
+namespace Volo.Abp.OpenIddict.Tokens;
+
+public class AbpTokenManager : OpenIddictTokenManager<OpenIddictTokenModel>
+{
+    protected AbpOpenIddictIdentifierConverter IdentifierConverter { get; }
+
+    public AbpTokenManager(
+        [NotNull] [ItemNotNull] IOpenIddictTokenCache<OpenIddictTokenModel> cache,
+        [NotNull] [ItemNotNull] ILogger<OpenIddictTokenManager<OpenIddictTokenModel>> logger,
+        [NotNull] [ItemNotNull] IOptionsMonitor<OpenIddictCoreOptions> options,
+        [NotNull] IOpenIddictTokenStoreResolver resolver,
+        AbpOpenIddictIdentifierConverter identifierConverter)
+        : base(cache, logger, options, resolver)
+    {
+        IdentifierConverter = identifierConverter;
+    }
+
+    public async override ValueTask UpdateAsync(OpenIddictTokenModel token, CancellationToken cancellationToken = default)
+    {
+        if (!Options.CurrentValue.DisableEntityCaching)
+        {
+            var entity = await Store.FindByIdAsync(IdentifierConverter.ToString(token.Id), cancellationToken);
+            if (entity != null)
+            {
+                await Cache.RemoveAsync(entity, cancellationToken);
+            }
+        }
+
+        await base.UpdateAsync(token, cancellationToken);
+    }
+}