RestAuthorityInvoker{TAuthority}.cs

Go to the documentation of this file.

using System;
using System.Net;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Mvc;
 
using Tgstation.Server.Host.Controllers;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.Security;
 
namespace Tgstation.Server.Host.Authority.Core
{
    sealed class RestAuthorityInvoker<TAuthority> : AuthorityInvokerBase<TAuthority>, IRestAuthorityInvoker<TAuthority>
        where TAuthority : IAuthority
    {
        static IActionResult CreateSuccessfulActionResult<TResult, TApiModel>(
            ApiController controller,
            Func<TResult, TApiModel> resultTransformer,
            AuthorityResponse<TResult> authorityResponse)
            where TApiModel : notnull
        {
            if (authorityResponse.IsNoContent!.Value)
                return controller.NoContent();
 
            var successResponse = authorityResponse.SuccessResponse;
            var result = resultTransformer(authorityResponse.Result!);
            return successResponse switch
            {
                HttpSuccessResponse.Ok => controller.Json(result),
                HttpSuccessResponse.Created => controller.Created(result),
                HttpSuccessResponse.Accepted => controller.Accepted(result),
                _ => throw new InvalidOperationException($"Invalid {nameof(HttpSuccessResponse)}: {successResponse}"),
            };
        }
 
        static IActionResult? CreateErroredActionResult(
            ApiController controller,
            AuthorityResponse? authorityResponse)
        {
            if (authorityResponse == null)
                return controller.Forbid();
 
            if (authorityResponse.Success)
                return null;
 
            var errorMessage = authorityResponse.ErrorMessage;
            var failureResponse = authorityResponse.FailureResponse;
            return failureResponse switch
            {
                HttpFailureResponse.BadRequest => controller.BadRequest(errorMessage),
                HttpFailureResponse.Unauthorized => controller.Unauthorized(),
                HttpFailureResponse.Forbidden => controller.Forbid(),
                HttpFailureResponse.NotFound => controller.NotFound(errorMessage),
                HttpFailureResponse.NotAcceptable => controller.StatusCode(HttpStatusCode.NotAcceptable, errorMessage),
                HttpFailureResponse.Conflict => controller.Conflict(errorMessage),
                HttpFailureResponse.Gone => controller.StatusCode(HttpStatusCode.Gone, errorMessage),
                HttpFailureResponse.UnprocessableEntity => controller.UnprocessableEntity(errorMessage),
                HttpFailureResponse.FailedDependency => controller.StatusCode(HttpStatusCode.FailedDependency, errorMessage),
                HttpFailureResponse.RateLimited => controller.StatusCode(HttpStatusCode.TooManyRequests, errorMessage),
                HttpFailureResponse.NotImplemented => controller.StatusCode(HttpStatusCode.NotImplemented, errorMessage),
                HttpFailureResponse.ServiceUnavailable => controller.StatusCode(HttpStatusCode.ServiceUnavailable, errorMessage),
                _ => throw new InvalidOperationException($"Invalid {nameof(HttpFailureResponse)}: {failureResponse}"),
            };
        }
 
        public RestAuthorityInvoker(TAuthority authority, IAuthorizationService authorizationService)
            : base(authority, authorizationService)
        {
        }
 
        async ValueTask<IActionResult> IRestAuthorityInvoker<TAuthority>.Invoke(ApiController controller, Func<TAuthority, RequirementsGated<AuthorityResponse>> authorityInvoker)
        {
            ArgumentNullException.ThrowIfNull(controller);
            ArgumentNullException.ThrowIfNull(authorityInvoker);
 
            var requirementsGate = authorityInvoker(Authority);
            var authorityResponse = await ExecuteIfRequirementsSatisfied(requirementsGate);
            return CreateErroredActionResult(controller, authorityResponse) ?? controller.NoContent();
        }
 
        async ValueTask<IActionResult> IRestAuthorityInvoker<TAuthority>.Invoke<TResult, TApiModel>(ApiController controller, Func<TAuthority, RequirementsGated<AuthorityResponse<TResult>>> authorityInvoker)
        {
            ArgumentNullException.ThrowIfNull(controller);
            ArgumentNullException.ThrowIfNull(authorityInvoker);
 
            var requirementsGate = authorityInvoker(Authority);
            var authorityResponse = await ExecuteIfRequirementsSatisfied(requirementsGate);
            var erroredResult = CreateErroredActionResult(controller, authorityResponse);
            if (erroredResult != null)
                return erroredResult;
 
            return CreateSuccessfulActionResult(controller, result => result, authorityResponse!);
        }
 
        async ValueTask<IActionResult> IRestAuthorityInvoker<TAuthority>.InvokeTransformable<TResult, TApiModel>(ApiController controller, Func<TAuthority, RequirementsGated<AuthorityResponse<TResult>>> authorityInvoker)
        {
            ArgumentNullException.ThrowIfNull(controller);
            ArgumentNullException.ThrowIfNull(authorityInvoker);
 
            var requirementsGate = authorityInvoker(Authority);
            var authorityResponse = await ExecuteIfRequirementsSatisfied(requirementsGate);
            var erroredResult = CreateErroredActionResult(controller, authorityResponse);
            if (erroredResult != null)
                return erroredResult;
 
            return CreateSuccessfulActionResult(controller, result => result.ToApi(), authorityResponse!);
        }
    }
}