/// <summary>
        /// Returns new result filted by the scope values.
        /// </summary>
        /// <param name="scopeValues"></param>
        /// <returns></returns>
        public ResourceValidationResult Filter(IEnumerable <string> scopeValues)
        {
            scopeValues ??= Enumerable.Empty <string>();

            var offline = scopeValues.Contains(IdentityServerConstants.StandardScopes.OfflineAccess);

            var parsedScopesToKeep     = ParsedScopes.Where(x => scopeValues.Contains(x.RawValue)).ToArray();
            var parsedScopeNamesToKeep = parsedScopesToKeep.Select(x => x.ParsedName).ToArray();

            var identityToKeep  = Resources.IdentityResources.Where(x => parsedScopeNamesToKeep.Contains(x.Name));
            var apiScopesToKeep = Resources.ApiScopes.Where(x => parsedScopeNamesToKeep.Contains(x.Name));

            var apiScopesNamesToKeep = apiScopesToKeep.Select(x => x.Name).ToArray();
            var apiResourcesToKeep   = Resources.ApiResources.Where(x => x.Scopes.Any(y => apiScopesNamesToKeep.Contains(y)));

            var resources = new Resources(identityToKeep, apiResourcesToKeep, apiScopesToKeep)
            {
                OfflineAccess = offline
            };

            return(new ResourceValidationResult()
            {
                Resources = resources,
                ParsedScopes = parsedScopesToKeep
            });
        }
Пример #2
0
        /// <summary>
        /// Filters the result by the resource indicator for issuing access tokens.
        /// </summary>
        public ResourceValidationResult FilterByResourceIndicator(string resourceIndicator)
        {
            // filter ApiResources to only the ones allowed by the resource indicator requested
            var apiResourcesToKeep = (String.IsNullOrWhiteSpace(resourceIndicator) ?
                                      Resources.ApiResources.Where(x => !x.RequireResourceIndicator) :
                                      Resources.ApiResources.Where(x => x.Name == resourceIndicator)).ToArray();

            var apiScopesToKeep    = Resources.ApiScopes.AsEnumerable();
            var parsedScopesToKeep = ParsedScopes;

            if (!String.IsNullOrWhiteSpace(resourceIndicator))
            {
                // filter ApiScopes to only the ones allowed by the ApiResource requested
                var scopeNamesToKeep = apiResourcesToKeep.SelectMany(x => x.Scopes).ToArray();
                apiScopesToKeep = Resources.ApiScopes.Where(x => scopeNamesToKeep.Contains(x.Name)).ToArray();

                // filter ParsedScopes to those matching the apiScopesToKeep
                var parsedScopesToKeepList = ParsedScopes.Where(x => scopeNamesToKeep.Contains(x.ParsedName)).ToHashSet();
                if (Resources.OfflineAccess)
                {
                    parsedScopesToKeepList.Add(new ParsedScopeValue(IdentityServerConstants.StandardScopes.OfflineAccess));
                }
                parsedScopesToKeep = parsedScopesToKeepList;
            }

            var resources = new Resources(Resources.IdentityResources, apiResourcesToKeep, apiScopesToKeep)
            {
                OfflineAccess = Resources.OfflineAccess,
            };

            return(new ResourceValidationResult()
            {
                Resources = resources,
                ParsedScopes = parsedScopesToKeep
            });
        }