GatewayInformation.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
 
using HotChocolate;
using HotChocolate.Authorization;
 
using Microsoft.Extensions.Options;
 
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Rights;
using Tgstation.Server.Host.Components.Interop;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.GraphQL.Types.OAuth;
using Tgstation.Server.Host.Properties;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.Security.OAuth;
using Tgstation.Server.Host.Security.RightsEvaluation;
using Tgstation.Server.Host.System;
 
namespace Tgstation.Server.Host.GraphQL.Types
{
    public sealed class GatewayInformation
    {
        static Version GraphQLApiVersionNoAuth { get; } = global::System.Version.Parse(MasterVersionsAttribute.Instance.RawGraphQLVersion);
 
        public int MajorGraphQLApiVersion => GraphQLApiVersionNoAuth.Major;
 
        [Authorize]
        public async ValueTask<uint> MinimumPasswordLength(
            [Service] IAuthorizationService authorizationService,
            [Service] IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions)
        {
            ArgumentNullException.ThrowIfNull(authorizationService);
            ArgumentNullException.ThrowIfNull(generalConfigurationOptions);
 
            await authorizationService.CheckGraphQLAuthorized(
                [new OrRightsConditional<AdministrationRights>(
                    new FlagRightsConditional<AdministrationRights>(AdministrationRights.WriteUsers),
                    new FlagRightsConditional<AdministrationRights>(AdministrationRights.EditOwnPassword))],
                null);
 
            return generalConfigurationOptions.Value.MinimumPasswordLength;
        }
 
        [Authorize]
        public async ValueTask<uint> InstanceLimit(
            [Service] IAuthorizationService authorizationService,
            [Service] IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions)
        {
            ArgumentNullException.ThrowIfNull(authorizationService);
            ArgumentNullException.ThrowIfNull(generalConfigurationOptions);
 
            await authorizationService.CheckGraphQLAuthorized(
                [new FlagRightsConditional<InstanceManagerRights>(InstanceManagerRights.Create)],
                null);
 
            return generalConfigurationOptions.Value.InstanceLimit;
        }
 
        [Authorize]
        public async ValueTask<uint> UserLimit(
            [Service] IAuthorizationService authorizationService,
            [Service] IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions)
        {
            ArgumentNullException.ThrowIfNull(authorizationService);
            ArgumentNullException.ThrowIfNull(generalConfigurationOptions);
 
            await authorizationService.CheckGraphQLAuthorized(
                [new FlagRightsConditional<AdministrationRights>(AdministrationRights.WriteUsers)],
                null);
 
            return generalConfigurationOptions.Value.UserLimit;
        }
 
        [Authorize]
        public async ValueTask<uint> UserGroupLimit(
            [Service] IAuthorizationService authorizationService,
            [Service] IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions)
        {
            ArgumentNullException.ThrowIfNull(authorizationService);
            ArgumentNullException.ThrowIfNull(generalConfigurationOptions);
 
            await authorizationService.CheckGraphQLAuthorized(
                [new FlagRightsConditional<AdministrationRights>(AdministrationRights.WriteUsers)],
                null);
            return generalConfigurationOptions.Value.UserGroupLimit;
        }
 
        [Authorize]
        public async ValueTask<IReadOnlyCollection<string>?> ValidInstancePaths(
            [Service] IAuthorizationService authorizationService,
            [Service] IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions)
        {
            ArgumentNullException.ThrowIfNull(authorizationService);
            ArgumentNullException.ThrowIfNull(generalConfigurationOptions);
 
            await authorizationService.CheckGraphQLAuthorized(
                [new OrRightsConditional<InstanceManagerRights>(
                    new FlagRightsConditional<InstanceManagerRights>(InstanceManagerRights.Create),
                    new FlagRightsConditional<InstanceManagerRights>(InstanceManagerRights.Relocate))],
                null);
            return generalConfigurationOptions.Value.ValidInstancePaths;
        }
 
        [Authorize]
        public bool WindowsHost(
            [Service] IPlatformIdentifier platformIdentifier)
        {
            ArgumentNullException.ThrowIfNull(platformIdentifier);
 
            return platformIdentifier.IsWindows;
        }
 
        [Authorize]
        public Version SwarmProtocolVersion()
            => global::System.Version.Parse(MasterVersionsAttribute.Instance.RawSwarmProtocolVersion);
 
        [Authorize]
        public Version Version(
            [Service] IAssemblyInformationProvider assemblyInformationProvider)
        {
            ArgumentNullException.ThrowIfNull(assemblyInformationProvider);
            return assemblyInformationProvider.Version;
        }
 
        [Authorize]
        public Version GraphQLApiVersion()
            => GraphQLApiVersionNoAuth;
 
        [Authorize]
        public Version ApiVersion() => ApiHeaders.Version;
 
        [Authorize]
        public Version DMApiVersion()
            => DMApiConstants.InteropVersion;
 
        public OAuthProviderInfos OAuthProviderInfos(
            [Service] IOAuthProviders oAuthProviders)
        {
            ArgumentNullException.ThrowIfNull(oAuthProviders);
            return new OAuthProviderInfos(oAuthProviders);
        }
    }
}