OAuthScopesSupportedAttribute.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Runtime.Collections;
using Waher.Script.Model;
 
namespace Waher.Networking.HTTP.OAuth.MetaData
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
    public class OAuthScopesSupportedAttribute : OAuthMetaDataAttribute
    {
        private static readonly SortedDictionary<string, bool> scopesAvailable = new SortedDictionary<string, bool>();
 
        public OAuthScopesSupportedAttribute(params string[] ScopesSupported)
            : this(false, ScopesSupported)
        {
        }
 
        public OAuthScopesSupportedAttribute(bool DynamicScopes, params string[] ScopesSupported)
        {
            this.DynamicScopes = DynamicScopes;
            this.ScopesSupported = ScopesSupported;
        }
 
        public bool DynamicScopes { get; }
 
        public string[] ScopesSupported { get; }
 
        public async Task<string[]> GetScopes(HttpResource Resource)
        {
            object Obj;
 
            if (this.DynamicScopes)
            {
                ChunkedList<string> ScopesList = new ChunkedList<string>();
                Type T = Resource.GetType();
 
                foreach (string Scope in this.ScopesSupported)
                {
                    PropertyInfo PI = T.GetProperty(Scope, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
                    if (PI is null)
                    {
                        FieldInfo FI = T.GetField(Scope, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
 
                        if (FI is null)
                        {
                            MethodInfo MI = T.GetMethod(Scope, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, null, new Type[0], null);
                            if (MI is null)
                                continue;
 
                            Obj = await ScriptNode.WaitPossibleTask(MI.Invoke(Resource, Array.Empty<object>()));
                        }
                        else
                            Obj = await ScriptNode.WaitPossibleTask(FI.GetValue(Resource));
                    }
                    else
                        Obj = await ScriptNode.WaitPossibleTask(PI.GetValue(Resource));
 
                    if (Obj is IEnumerable<string> DynamicScopes)
                        ScopesList.AddRange(DynamicScopes);
                    else if (Obj is string DynamicScope)
                        ScopesList.Add(DynamicScope);
                    else
                        Log.Warning("Dynamic scopes returned an object that was not of expected type: " + T.FullName, Resource.ResourceName);
                }
 
                return ScopesList.ToArray();
            }
            else
                return this.ScopesSupported;
        }
 
        public override async Task RegisterMetaData(HttpResource Resource)
        {
            string[] Scopes = await this.GetScopes(Resource);
 
            lock (scopesAvailable)
            {
                foreach (string Scope in Scopes)
                    scopesAvailable[Scope] = true;
            }
        }
 
        public static string[] RegisteredScopes
        {
            get
            {
                lock (scopesAvailable)
                {
                    int c = scopesAvailable.Count;
                    string[] Result = new string[c];
                    
                    scopesAvailable.Keys.CopyTo(Result, 0);
                
                    return Result;
                }
            }
        }
 
        public override async Task AddMetaData(HttpResource Resource,
            Dictionary<string, object> MetaData)
        {
            string[] Scopes = await this.GetScopes(Resource);
 
            if (MetaData.TryGetValue("scopes_supported", out object Obj) &&
                Obj is string[] Scopes2)
            {
                MetaData["scopes_supported"] = Scopes2.Join(Scopes);
            }
            else
                MetaData["scopes_supported"] = Scopes;
        }
    }
}