RightsTypeInterceptor.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
 
using HotChocolate.Configuration;
using HotChocolate.Types;
using HotChocolate.Types.Descriptors.Definitions;
using Tgstation.Server.Api.Rights;
using Tgstation.Server.Host.GraphQL.Types;
 
namespace Tgstation.Server.Host.GraphQL.Interceptors
{
    sealed class RightsTypeInterceptor : TypeInterceptor
    {
        const string IsPrefix = "is";
 
        const string NoneFieldName = $"{IsPrefix}None";
 
        private readonly HashSet<string> objectNames;
 
        private readonly HashSet<string> inputNames;
 
        public RightsTypeInterceptor()
        {
            var rightTypes = Enum.GetValues<RightsType>();
            objectNames = new HashSet<string>(rightTypes.Length);
            inputNames = new HashSet<string>(rightTypes.Length);
 
            foreach (var rightType in rightTypes)
            {
                var rightName = rightType.ToString();
                var flagName = $"{rightName}RightsFlags";
 
                objectNames.Add(flagName);
                inputNames.Add($"{flagName}Input");
            }
        }
 
        static void FixFields<TField>(IBindableList<TField> fields)
            where TField : FieldDefinitionBase
        {
            TField? noneField = null;
 
            foreach (var field in fields)
            {
                var fieldName = field.Name;
                if (fieldName == NoneFieldName)
                {
                    noneField = field;
                    continue;
                }
 
                if (!fieldName.StartsWith(IsPrefix))
                    throw new InvalidOperationException("Expected flags enum type field to start with \"is\"!");
 
                field.Name = $"can{fieldName[IsPrefix.Length..]}";
            }
 
            if (noneField == null)
                throw new InvalidOperationException($"Expected flags enum type field to contain \"{NoneFieldName}\"!");
 
            fields.Remove(noneField);
        }
 
        static void FixFormatter(IInputValueFormatter inputValueFormatter)
        {
            // now we're hacking privates, but there's a dictionary with bad keys here that needs adjusting
            var dictionary = (Dictionary<string, object>)(inputValueFormatter
                .GetType()
                .GetField("_flags", BindingFlags.Instance | BindingFlags.NonPublic)
                ?.GetValue(inputValueFormatter)
                ?? throw new InvalidOperationException("Could not locate private enum mapping dictionary field!"));
 
            foreach (var key in dictionary.Keys.ToList())
            {
                if (key == NoneFieldName)
                {
                    dictionary.Remove(key);
                    continue;
                }
 
                var value = dictionary[key];
                var newKey = $"can{key.Substring(IsPrefix.Length)}";
                dictionary.Remove(key);
                dictionary.Add(newKey, value);
            }
        }
 
        public override void OnAfterRegisterDependencies(ITypeDiscoveryContext discoveryContext, DefinitionBase definition)
        {
            ArgumentNullException.ThrowIfNull(definition);
 
            if (definition is ObjectTypeDefinition objectTypeDef)
            {
                if (objectNames.Contains(objectTypeDef.Name))
                    FixFields(objectTypeDef.Fields);
            }
            else if (definition is InputObjectTypeDefinition inputTypeDef)
            {
                const string PermissionSetInputName = $"{nameof(PermissionSet)}Input";
                const string InstancePermissionSetInputName = $"{nameof(InstancePermissionSet)}Input";
 
                var name = inputTypeDef.Name;
                if (inputNames.Contains(name))
                    FixFields(inputTypeDef.Fields);
                else if (name == PermissionSetInputName || name == InstancePermissionSetInputName)
                    foreach (var field in inputTypeDef.Fields)
                        FixFormatter(field.Formatters.Single());
            }
        }
    }
}