AuthorityBase.cs

Go to the documentation of this file.

using System;
using System.Globalization;
 
using Microsoft.Extensions.Logging;
 
using Octokit;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Response;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.Security.RightsEvaluation;
 
namespace Tgstation.Server.Host.Authority.Core
{
    abstract class AuthorityBase : IAuthority
    {
        protected IDatabaseContext DatabaseContext { get; }
 
        protected ILogger<AuthorityBase> Logger { get; }
 
        protected static AuthorityResponse<TResult> BadRequest<TResult>(ErrorCode errorCode)
            => new(
                new ErrorMessageResponse(errorCode),
                HttpFailureResponse.BadRequest);
 
        protected static AuthorityResponse<TResult> Unauthorized<TResult>()
            => new(
                new ErrorMessageResponse(),
                HttpFailureResponse.Unauthorized);
 
        protected static AuthorityResponse<TResult> Gone<TResult>()
            => new(
                new ErrorMessageResponse(ErrorCode.ResourceNotPresent),
                HttpFailureResponse.Gone);
 
        protected static AuthorityResponse<TResult> Forbid<TResult>()
            => new(
                new ErrorMessageResponse(),
                HttpFailureResponse.Forbidden);
 
        protected static AuthorityResponse<TResult> NotFound<TResult>()
            => new(
                new ErrorMessageResponse(ErrorCode.ResourceNeverPresent),
                HttpFailureResponse.NotFound);
 
        protected static AuthorityResponse<TResult> Conflict<TResult>(ErrorCode errorCode, string? additionalData = null)
            => new(
                new ErrorMessageResponse(errorCode)
                {
                    AdditionalData = additionalData,
                },
                HttpFailureResponse.Conflict);
 
        protected static FlagRightsConditional<TRights> Flag<TRights>(TRights flag)
            where TRights : Enum
            => new(flag);
 
        protected static OrRightsConditional<TRights> Or<TRights>(RightsConditional<TRights> lhs, RightsConditional<TRights> rhs)
            where TRights : Enum
            => new(lhs, rhs);
 
        protected static AndRightsConditional<TRights> And<TRights>(RightsConditional<TRights> lhs, RightsConditional<TRights> rhs)
            where TRights : Enum
            => new(lhs, rhs);
 
        protected AuthorityBase(
            IDatabaseContext databaseContext,
            ILogger<AuthorityBase> logger)
        {
            DatabaseContext = databaseContext ?? throw new ArgumentNullException(nameof(databaseContext));
            Logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }
 
        protected AuthorityResponse<TResult> RateLimit<TResult>(RateLimitExceededException rateLimitException)
        {
            Logger.LogWarning(rateLimitException, "Exceeded GitHub rate limit!");
            var secondsString = Math.Ceiling(rateLimitException.GetRetryAfterTimeSpan().TotalSeconds).ToString(CultureInfo.InvariantCulture);
            return new(
                new ErrorMessageResponse(ErrorCode.GitHubApiRateLimit)
                {
                    AdditionalData = $"Retry-After: {secondsString}s",
                },
                HttpFailureResponse.RateLimited);
        }
    }
}