From 4f57d16b66f4cd048e83df607bd34da6beed9194 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?K=C3=A9vin=20Chalet?= <kevinchalet@gmail.com>
Date: Sun, 4 Feb 2018 20:58:37 +0100
Subject: [PATCH] Introduce new methods in the authorization manager

---
 .../OpenIddictAuthorizationManager.cs         | 150 ++++++++++++++----
 .../Stores/IOpenIddictAuthorizationStore.cs   |  16 --
 .../Stores/OpenIddictAuthorizationStore.cs    |  40 -----
 3 files changed, 121 insertions(+), 85 deletions(-)

diff --git a/src/OpenIddict.Core/Managers/OpenIddictAuthorizationManager.cs b/src/OpenIddict.Core/Managers/OpenIddictAuthorizationManager.cs
index 8e1bc2cb..340a38da 100644
--- a/src/OpenIddict.Core/Managers/OpenIddictAuthorizationManager.cs
+++ b/src/OpenIddict.Core/Managers/OpenIddictAuthorizationManager.cs
@@ -191,35 +191,6 @@ namespace OpenIddict.Core
             return Store.FindAsync(subject, client, cancellationToken);
         }
 
-        /// <summary>
-        /// Retrieves the authorizations corresponding to the specified subject, associated with
-        /// the application identifier and for which the specified scopes have been granted.
-        /// </summary>
-        /// <param name="subject">The subject associated with the authorization.</param>
-        /// <param name="client">The client associated with the authorization.</param>
-        /// <param name="scopes">The minimal scopes associated with the authorization.</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
-        /// <returns>
-        /// A <see cref="Task"/> that can be used to monitor the asynchronous operation, whose result
-        /// returns the authorizations corresponding to the specified subject/client/scopes.
-        /// </returns>
-        public virtual Task<ImmutableArray<TAuthorization>> FindAsync(
-            [NotNull] string subject, [NotNull] string client,
-            ImmutableArray<string> scopes, CancellationToken cancellationToken)
-        {
-            if (string.IsNullOrEmpty(subject))
-            {
-                throw new ArgumentException("The subject cannot be null or empty.", nameof(subject));
-            }
-
-            if (string.IsNullOrEmpty(client))
-            {
-                throw new ArgumentException("The client identifier cannot be null or empty.", nameof(client));
-            }
-
-            return Store.FindAsync(subject, client, scopes, cancellationToken);
-        }
-
         /// <summary>
         /// Retrieves an authorization using its unique identifier.
         /// </summary>
@@ -318,6 +289,25 @@ namespace OpenIddict.Core
             return Store.GetIdAsync(authorization, cancellationToken);
         }
 
+        /// <summary>
+        /// Retrieves the scopes associated with an authorization.
+        /// </summary>
+        /// <param name="authorization">The authorization.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
+        /// <returns>
+        /// A <see cref="Task"/> that can be used to monitor the asynchronous operation,
+        /// whose result returns the scopes associated with the specified authorization.
+        /// </returns>
+        public virtual Task<ImmutableArray<string>> GetScopesAsync([NotNull] TAuthorization authorization, CancellationToken cancellationToken = default)
+        {
+            if (authorization == null)
+            {
+                throw new ArgumentNullException(nameof(authorization));
+            }
+
+            return Store.GetScopesAsync(authorization, cancellationToken);
+        }
+
         /// <summary>
         /// Retrieves the status associated with an authorization.
         /// </summary>
@@ -337,6 +327,108 @@ namespace OpenIddict.Core
             return Store.GetStatusAsync(authorization, cancellationToken);
         }
 
+        /// <summary>
+        /// Retrieves the subject associated with an authorization.
+        /// </summary>
+        /// <param name="authorization">The authorization.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
+        /// <returns>
+        /// A <see cref="Task"/> that can be used to monitor the asynchronous operation,
+        /// whose result returns the subject associated with the specified authorization.
+        /// </returns>
+        public virtual Task<string> GetSubjectAsync([NotNull] TAuthorization authorization, CancellationToken cancellationToken = default)
+        {
+            if (authorization == null)
+            {
+                throw new ArgumentNullException(nameof(authorization));
+            }
+
+            return Store.GetSubjectAsync(authorization, cancellationToken);
+        }
+
+        /// <summary>
+        /// Retrieves the type associated with an authorization.
+        /// </summary>
+        /// <param name="authorization">The authorization.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
+        /// <returns>
+        /// A <see cref="Task"/> that can be used to monitor the asynchronous operation,
+        /// whose result returns the type associated with the specified authorization.
+        /// </returns>
+        public virtual Task<string> GetTypeAsync([NotNull] TAuthorization authorization, CancellationToken cancellationToken = default)
+        {
+            if (authorization == null)
+            {
+                throw new ArgumentNullException(nameof(authorization));
+            }
+
+            return Store.GetTypeAsync(authorization, cancellationToken);
+        }
+
+        /// <summary>
+        /// Determines whether the specified scopes are included in the authorization.
+        /// </summary>
+        /// <param name="authorization">The authorization.</param>
+        /// <param name="scopes">The scopes.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
+        /// <returns><c>true</c> if the scopes are included in the authorization, <c>false</c> otherwise.</returns>
+        public virtual async Task<bool> HasScopesAsync([NotNull] TAuthorization authorization,
+            ImmutableArray<string> scopes, CancellationToken cancellationToken = default)
+        {
+            if (authorization == null)
+            {
+                throw new ArgumentNullException(nameof(authorization));
+            }
+
+            return (await Store.GetScopesAsync(authorization, cancellationToken))
+                .ToImmutableHashSet(StringComparer.Ordinal)
+                .IsSupersetOf(scopes);
+        }
+
+        /// <summary>
+        /// Determines whether a given authorization is ad hoc.
+        /// </summary>
+        /// <param name="authorization">The authorization.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
+        /// <returns><c>true</c> if the authorization is ad hoc, <c>false</c> otherwise.</returns>
+        public async Task<bool> IsAdHocAsync([NotNull] TAuthorization authorization, CancellationToken cancellationToken = default)
+        {
+            if (authorization == null)
+            {
+                throw new ArgumentNullException(nameof(authorization));
+            }
+
+            var type = await GetTypeAsync(authorization, cancellationToken);
+            if (string.IsNullOrEmpty(type))
+            {
+                return false;
+            }
+
+            return string.Equals(type, OpenIddictConstants.AuthorizationTypes.AdHoc, StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Determines whether a given authorization is permanent.
+        /// </summary>
+        /// <param name="authorization">The authorization.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
+        /// <returns><c>true</c> if the authorization is permanent, <c>false</c> otherwise.</returns>
+        public async Task<bool> IsPermanentAsync([NotNull] TAuthorization authorization, CancellationToken cancellationToken = default)
+        {
+            if (authorization == null)
+            {
+                throw new ArgumentNullException(nameof(authorization));
+            }
+
+            var type = await GetTypeAsync(authorization, cancellationToken);
+            if (string.IsNullOrEmpty(type))
+            {
+                return false;
+            }
+
+            return string.Equals(type, OpenIddictConstants.AuthorizationTypes.Permanent, StringComparison.OrdinalIgnoreCase);
+        }
+
         /// <summary>
         /// Determines whether a given authorization has been revoked.
         /// </summary>
diff --git a/src/OpenIddict.Core/Stores/IOpenIddictAuthorizationStore.cs b/src/OpenIddict.Core/Stores/IOpenIddictAuthorizationStore.cs
index 2f792847..7c97cac9 100644
--- a/src/OpenIddict.Core/Stores/IOpenIddictAuthorizationStore.cs
+++ b/src/OpenIddict.Core/Stores/IOpenIddictAuthorizationStore.cs
@@ -75,22 +75,6 @@ namespace OpenIddict.Core
         /// </returns>
         Task<ImmutableArray<TAuthorization>> FindAsync([NotNull] string subject, [NotNull] string client, CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Retrieves the authorizations corresponding to the specified subject, associated with
-        /// the application identifier and for which the specified scopes have been granted.
-        /// </summary>
-        /// <param name="subject">The subject associated with the authorization.</param>
-        /// <param name="client">The client associated with the authorization.</param>
-        /// <param name="scopes">The minimal scopes associated with the authorization.</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
-        /// <returns>
-        /// A <see cref="Task"/> that can be used to monitor the asynchronous operation, whose result
-        /// returns the authorizations corresponding to the specified subject/client/scopes.
-        /// </returns>
-        Task<ImmutableArray<TAuthorization>> FindAsync(
-            [NotNull] string subject, [NotNull] string client,
-            ImmutableArray<string> scopes, CancellationToken cancellationToken);
-
         /// <summary>
         /// Retrieves an authorization using its unique identifier.
         /// </summary>
diff --git a/src/OpenIddict.Core/Stores/OpenIddictAuthorizationStore.cs b/src/OpenIddict.Core/Stores/OpenIddictAuthorizationStore.cs
index be3934c5..1b1e7fb2 100644
--- a/src/OpenIddict.Core/Stores/OpenIddictAuthorizationStore.cs
+++ b/src/OpenIddict.Core/Stores/OpenIddictAuthorizationStore.cs
@@ -112,46 +112,6 @@ namespace OpenIddict.Core
                 (key: ConvertIdentifierFromString(client), principal: subject), cancellationToken);
         }
 
-        /// <summary>
-        /// Retrieves the authorizations corresponding to the specified subject, associated with
-        /// the application identifier and for which the specified scopes have been granted.
-        /// </summary>
-        /// <param name="subject">The subject associated with the authorization.</param>
-        /// <param name="client">The client associated with the authorization.</param>
-        /// <param name="scopes">The minimal scopes associated with the authorization.</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that can be used to abort the operation.</param>
-        /// <returns>
-        /// A <see cref="Task"/> that can be used to monitor the asynchronous operation, whose result
-        /// returns the authorizations corresponding to the specified subject/client/scopes.
-        /// </returns>
-        public virtual async Task<ImmutableArray<TAuthorization>> FindAsync(
-            [NotNull] string subject, [NotNull] string client,
-            ImmutableArray<string> scopes, CancellationToken cancellationToken)
-        {
-            if (string.IsNullOrEmpty(subject))
-            {
-                throw new ArgumentException("The subject cannot be null or empty.", nameof(subject));
-            }
-
-            if (string.IsNullOrEmpty(client))
-            {
-                throw new ArgumentException("The client cannot be null or empty.", nameof(client));
-            }
-
-            var builder = ImmutableArray.CreateBuilder<TAuthorization>();
-
-            foreach (var authorization in await FindAsync(subject, client, cancellationToken))
-            {
-                var set = new HashSet<string>(await GetScopesAsync(authorization, cancellationToken), StringComparer.Ordinal);
-                if (set.IsSupersetOf(scopes))
-                {
-                    builder.Add(authorization);
-                }
-            }
-
-            return builder.ToImmutable();
-        }
-
         /// <summary>
         /// Retrieves an authorization using its unique identifier.
         /// </summary>