RequirementsGated{TResult}.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Authorization;
 
using Tgstation.Server.Host.Security;
 
namespace Tgstation.Server.Host.Authority.Core
{
    public sealed class RequirementsGated<TResult>
    {
        readonly Func<ValueTask<IEnumerable<IAuthorizationRequirement>>> getRequirements;
 
        readonly Func<Security.IAuthorizationService, ValueTask<TResult>> getResponse;
 
        readonly bool doNotAddUserSessionValidRequirement;
 
#pragma warning disable CA1000 // Do not declare static members on generic types
        public static RequirementsGated<TResult> FromResult(TResult result)
#pragma warning restore CA1000 // Do not declare static members on generic types
            => new(
                () => (IAuthorizationRequirement?)null,
                () => ValueTask.FromResult(result));
 
        public RequirementsGated(
            Func<ValueTask<IAuthorizationRequirement?>> getRequirement,
            Func<ValueTask<TResult>> getResponse)
        {
            ArgumentNullException.ThrowIfNull(getRequirement);
            ArgumentNullException.ThrowIfNull(getResponse);
            getRequirements = async () =>
            {
                var requirement = await getRequirement();
                if (requirement == null)
                    return Enumerable.Empty<IAuthorizationRequirement>();
 
                return new List<IAuthorizationRequirement>
                {
                    requirement,
                };
            };
            this.getResponse = _ => getResponse();
        }
 
        public RequirementsGated(
            Func<IEnumerable<IAuthorizationRequirement>> getRequirements,
            Func<ValueTask<TResult>> getResponse)
        {
            ArgumentNullException.ThrowIfNull(getRequirements);
            ArgumentNullException.ThrowIfNull(getResponse);
            this.getRequirements = () => ValueTask.FromResult(getRequirements());
            this.getResponse = _ => getResponse();
        }
 
        public RequirementsGated(
            Func<IAuthorizationRequirement?> getRequirement,
            Func<ValueTask<TResult>> getResponse,
            bool doNotAddUserSessionValidRequirement = false)
        {
            ArgumentNullException.ThrowIfNull(getRequirement);
            ArgumentNullException.ThrowIfNull(getResponse);
            getRequirements = () =>
            {
                var requirement = getRequirement();
                if (requirement == null)
                    return ValueTask.FromResult(Enumerable.Empty<IAuthorizationRequirement>());
 
                return ValueTask.FromResult<IEnumerable<IAuthorizationRequirement>>(
                    new List<IAuthorizationRequirement>
                    {
                        requirement,
                    });
            };
 
            this.getResponse = _ => getResponse();
 
            this.doNotAddUserSessionValidRequirement = doNotAddUserSessionValidRequirement;
        }
 
        public RequirementsGated(
            Func<IAuthorizationRequirement?> getRequirement,
            Func<Security.IAuthorizationService, ValueTask<TResult>> getResponse)
        {
            ArgumentNullException.ThrowIfNull(getRequirement);
            getRequirements = () =>
            {
                var requirement = getRequirement();
                if (requirement == null)
                    return ValueTask.FromResult(Enumerable.Empty<IAuthorizationRequirement>());
 
                return ValueTask.FromResult<IEnumerable<IAuthorizationRequirement>>(
                    new List<IAuthorizationRequirement>
                    {
                        requirement,
                    });
            };
 
            this.getResponse = getResponse ?? throw new ArgumentNullException(nameof(getResponse));
        }
 
        public async ValueTask<IEnumerable<IAuthorizationRequirement>> GetRequirements()
        {
            var requirements = await getRequirements();
            if (!doNotAddUserSessionValidRequirement)
                requirements = UserSessionValidRequirement.InstanceAsEnumerable.Concat(requirements);
 
            return requirements;
        }
 
        public ValueTask<TResult> Execute(Security.IAuthorizationService authorizationService)
            => getResponse(authorizationService);
    }
}