ProtectedMethod.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Networking.HTTP.JsonRpc.MetaData;
using Waher.Runtime.Collections;
using Waher.Script;
using Waher.Security;
using Waher.Things.Http;
 
namespace Waher.Networking.HTTP.JsonRpc
{
    public class ProtectedMethod
    {
        public ProtectedMethod(MethodInfo Method, bool CaseSensitive)
            : this(Method, CaseSensitive, JsonRpcWebService.GetRequiredPrivileges(Method))
        {
        }
 
        public ProtectedMethod(MethodInfo Method,
            bool CaseSensitive, string[]? RequiredPrivileges)
        {
            ParameterInfo[] Arguments = Method.GetParameters();
            bool IsSpecialArgument;
            bool IsMetaDataArgument;
            bool IsIdArgument;
            this.Method = Method;
            this.NrArguments = Arguments.Length;
            this.NrSpecialArguments = 0;
            this.RequiredPrivileges = RequiredPrivileges ?? Array.Empty<string>();
            this.RequiresAuthentication = (RequiredPrivileges?.Length ?? 0) > 0;
            this.Arguments = new ProtectedMethodArgumentInfo[this.NrArguments];
 
            if (CaseSensitive)
                this.NamedArguments = new Dictionary<string, int>(StringComparer.InvariantCulture);
            else
                this.NamedArguments = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase);
 
            foreach (ParameterInfo P in Arguments)
            {
                IsMetaDataArgument = false;
                IsIdArgument = false;
 
                if (P.ParameterType == typeof(HttpRequest))
                {
                    if (this.RequestArgument is null)
                    {
                        this.RequestArgument = P.Position;
                        this.NrSpecialArguments++;
                        IsSpecialArgument = true;
                    }
                    else
                        throw new ArgumentException("Only one argument of type HttpRequest is allowed.", nameof(Method));
                }
                else if (P.ParameterType == typeof(HttpResponse))
                {
                    if (this.ResponseArgument is null)
                    {
                        this.ResponseArgument = P.Position;
                        this.NrSpecialArguments++;
                        IsSpecialArgument = true;
                    }
                    else
                        throw new ArgumentException("Only one argument of type HttpResponse is allowed.", nameof(Method));
                }
                else if (P.ParameterType == typeof(Dictionary<string, object?>) &&
                    P.IsDefined(typeof(JsonRpcMetaDataArgumentAttribute), true))
                {
                    if (this.MetaDataArgument is null)
                    {
                        this.MetaDataArgument = P.Position;
                        this.NrSpecialArguments++;
                        IsSpecialArgument = true;
                        IsMetaDataArgument = true;
                    }
                    else
                        throw new ArgumentException("Only one meta-data argument is allowed.", nameof(Method));
                }
                else if (P.IsDefined(typeof(JsonRpcIdAttribute), true))
                {
                    if (this.IdArgument is null)
                    {
                        this.IdArgument = P.Position;
                        this.NrSpecialArguments++;
                        IsSpecialArgument = true;
                        IsIdArgument = true;
                    }
                    else
                        throw new ArgumentException("Only one ID argument is allowed.", nameof(Method));
                }
                else
                {
                    this.NamedArguments[P.Name] = P.Position;
                    IsSpecialArgument = false;
                }
 
                this.Arguments[P.Position] = new ProtectedMethodArgumentInfo(P, IsSpecialArgument,
                    P.HasDefaultValue, P.HasDefaultValue ? P.DefaultValue : null,
                    IsMetaDataArgument, IsIdArgument);
            }
 
            this.Documentation = GetDocumentation(Method);
 
            this.HasReturnValue = Method.ReturnType != typeof(Task) &&
                !Expression.IsVoid(Method.ReturnType);
 
            if (this.HasReturnValue)
                this.ReturnValueDocumentation = GetDocumentation(Method.ReturnParameter);
            else
                this.ReturnValueDocumentation = Array.Empty<KeyValuePair<bool, string>>();
 
            JsonRpcDocNameAttribute? DocName = Method.GetCustomAttribute<JsonRpcDocNameAttribute>(true);
            this.Name = DocName?.Name ?? this.Method.Name;
        }
 
        public static KeyValuePair<bool, string>[] GetDocumentation(ICustomAttributeProvider Object)
        {
            ChunkedList<KeyValuePair<bool, string>> Documentation = new ChunkedList<KeyValuePair<bool, string>>();
 
            foreach (object Attribute in Object.GetCustomAttributes(typeof(JsonRpcDocumentationAttribute), true))
            {
                if (Attribute is JsonRpcDocumentationAttribute DocAttribute)
                    Documentation.Add(new KeyValuePair<bool, string>(DocAttribute.IsMarkdown, DocAttribute.Documentation));
            }
 
            return Documentation.ToArray();
        }
 
        public HttpAuthenticationScheme[]? AuthenticationMechanisms { get; private set; }
 
        public MethodInfo Method { get; }
 
        public int NrArguments { get; }
 
        public int NrSpecialArguments { get; }
 
        public Dictionary<string, int> NamedArguments { get; }
 
        public int? RequestArgument { get; }
 
        public int? ResponseArgument { get; }
 
        public int? MetaDataArgument { get; }
 
        public int? IdArgument { get; }
 
        public ProtectedMethodArgumentInfo[] Arguments { get; }
 
        public bool RequiresAuthentication { get; }
 
        public string[] RequiredPrivileges { get; }
 
        public KeyValuePair<bool, string>[] Documentation { get; }
 
        public KeyValuePair<bool, string>[] ReturnValueDocumentation { get; }
 
        public bool HasReturnValue { get; }
 
        public string Name { get; }
 
        public bool IsAuthorized(IUser? User)
        {
            return this.IsAuthorized(User, out _);
        }
 
        public bool IsAuthorized(IUser? User, out string? MissingPrivilege)
        {
            MissingPrivilege = null;
 
            if (!this.RequiresAuthentication)
                return true;
 
            if (User is null)
                return false;
 
            foreach (string Privilege in this.RequiredPrivileges)
            {
                if (!User.HasPrivilege(Privilege))
                {
                    MissingPrivilege = Privilege;
                    return false;
                }
            }
 
            return true;
        }
 
        public void AssertAuthorized(string ObjectId, IUser? User)
        {
            if (!this.IsAuthorized(User, out string? MissingPrivilege))
            {
                throw ForbiddenException.AccessDenied(ObjectId,
                    User?.UserName ?? string.Empty,
                    MissingPrivilege ?? string.Empty);
            }
        }
 
        public bool TryBuildRequest(object? Id, Dictionary<string, object?> Parameters,
            Dictionary<string, object?>? MetaData,
            [NotNullWhen(false)] out string? Reason,
            [NotNullWhen(true)] out object?[]? Arguments)
        {
            int c = this.NrArguments;
            int NrParametersSet = 0;
 
            Arguments = new object?[c];
 
            foreach (KeyValuePair<string, object?> P in Parameters)
            {
                if (!this.NamedArguments.TryGetValue(P.Key, out int i))
                {
                    if (this.MetaDataArgument.HasValue &&
                        (P.Key == this.Arguments[this.MetaDataArgument.Value].Parameter.Name ||
                        P.Key == "_meta"))
                    {
                        i = this.MetaDataArgument.Value;
                    }
                    else if (P.Key == "_meta")
                        continue;
                    else
                    {
                        Reason = "Invalid parameter name: " + P.Key;
                        Arguments = null;
                        return false;
                    }
                }
 
                object? Value = P.Value;
                ProtectedMethodArgumentInfo ArgumentInfo = this.Arguments[i];
                Type ExpectedType = ArgumentInfo.Parameter.ParameterType;
                Type ParameterType = Value?.GetType() ?? typeof(object);
 
                if (ArgumentInfo.IsMetaDataArgument && !(MetaData is null))
                {
                    Dictionary<string, object?>? MetaDataValue = Value as Dictionary<string, object?>;
 
                    if (Value is null || !(MetaDataValue is null))
                    {
                        if (MetaDataValue is null)
                            MetaDataValue = MetaData;
                        else
                        {
                            foreach (KeyValuePair<string, object?> P2 in MetaData)
                            {
                                if (!MetaDataValue.ContainsKey(P2.Key))
                                    MetaDataValue[P2.Key] = P2.Value;
                            }
                        }
 
                        Value = MetaDataValue;
                    }
                }
                else if (ArgumentInfo.IsIdArgument)
                    Value = Id;
 
                if (ParameterType == ExpectedType)
                    Arguments[i] = Value;
                else if (Expression.TryConvert(Value, ExpectedType, true, out object Converted))
                    Arguments[i] = Converted;
                else if (ArgumentInfo.HasDefaultValue &&
                    Value is Dictionary<string, object?> Dictionary &&
                    Dictionary.Count == 0)
                {
                    Arguments[i] = ArgumentInfo.DefaultValue;
                }
                else
                {
                    Arguments = null;
                    Reason = "Parameter " + P.Key +
                        " has incorrect type: " + ParameterType.FullName +
                        ", Expected: " + ExpectedType.FullName;
                    return false;
                }
 
                NrParametersSet++;
            }
 
            if (NrParametersSet != c - this.NrSpecialArguments)
            {
                foreach (ProtectedMethodArgumentInfo Argument in this.Arguments)
                {
                    if (!Argument.IsSpecialArgument &&
                        Argument.HasDefaultValue &&
                        !Parameters.ContainsKey(Argument.Parameter.Name))
                    {
                        Arguments[Argument.Parameter.Position] = Argument.DefaultValue;
                        NrParametersSet++;
                    }
                }
            }
 
            if (NrParametersSet < c - this.NrSpecialArguments)
            {
                Reason = "Missing required parameters.";
                Arguments = null;
                return false;
            }
 
            Reason = null;
 
            return true;
        }
 
        public void UpdateAuthenticationMechanisms()
        {
            this.UpdateAuthenticationMechanisms(null);
        }
 
        public void UpdateAuthenticationMechanisms(string? ResourceMetaDataUri)
        {
            if (this.RequiresAuthentication)
            {
                if (string.IsNullOrEmpty(ResourceMetaDataUri))
                {
                    this.AuthenticationMechanisms = HttpModule.GetAuthenticationSchemes(
                        this.RequiredPrivileges);
                }
                else
                {
                    this.AuthenticationMechanisms = HttpModule.GetAuthenticationSchemes(
                        new Uri(ResourceMetaDataUri), this.RequiredPrivileges);
                }
            }
        }
    }
}