show engine version label to people with the permission (currently tied to legacy admin permission)

Author: pandinocoder

Framework/Intersect.Framework.Core/Intersect.Framework.Core.csproj

@@ -69,4 +69,8 @@
       </Compile>
     </ItemGroup>
 
+    <ItemGroup>
+      <Folder Include="Network\Handlers\" />
+    </ItemGroup>
+
 </Project>

Framework/Intersect.Framework.Core/Network/Handlers/Security/ActivePermissionSetPacketHandler.cs

@@ -0,0 +1,16 @@
+using Intersect.Framework.Core.Network.Packets.Security;
+using Intersect.Framework.Core.Security;
+using Intersect.Network;
+
+namespace Intersect.Framework.Core.Network.Handlers.Security;
+
+[PacketHandler(typeof(ActivePermissionSetPacket))]
+public class ActivePermissionSetPacketHandler : AbstractPacketHandler<ActivePermissionSetPacket>
+{
+    public override bool Handle(IPacketSender packetSender, ActivePermissionSetPacket packet)
+    {
+        PermissionSet.ActivePermissionSetName = packet.PermissionSetName;
+
+        return true;
+    }
+}

Framework/Intersect.Framework.Core/Network/Handlers/Security/PermissionSetPacketHandler.cs

@@ -0,0 +1,24 @@
+using Intersect.Core;
+using Intersect.Framework.Core.Network.Packets.Security;
+using Intersect.Framework.Core.Security;
+using Intersect.Network;
+using Microsoft.Extensions.Logging;
+
+namespace Intersect.Framework.Core.Network.Handlers.Security;
+
+[PacketHandler(typeof(PermissionSetPacket))]
+public class PermissionSetPacketHandler : AbstractPacketHandler<PermissionSetPacket>
+{
+    public override bool Handle(IPacketSender packetSender, PermissionSetPacket packet)
+    {
+        ApplicationContext.Context.Value?.Logger.LogInformation(
+            "Updated {PermissionSet} '{PermissionSetName}'",
+            nameof(PermissionSet),
+            packet.PermissionSet.Name
+        );
+
+        // The deserializer will update the known permission set lookup, no need to do it here
+
+        return true;
+    }
+}

Framework/Intersect.Framework.Core/Network/IntersectPacket.cs

@@ -10,14 +10,15 @@ namespace Intersect.Network;
 public abstract partial class IntersectPacket : IPacket
 {
     [IgnoreMember]
-    private byte[] mCachedData = null;
+    private byte[]? _cachedData;
 
     [IgnoreMember]
-    private byte[] mCachedCompresedData = null;
+    private byte[]? _cachedCompressedData = null;
 
     /// <inheritdoc />
     public virtual void Dispose()
     {
+        GC.SuppressFinalize(this);
     }
 
     /// <inheritdoc />
@@ -26,19 +27,19 @@ public virtual byte[] Data
     {
         get
         {
-            mCachedData ??= MessagePacker.Instance.Serialize(this) ??
+            _cachedData ??= MessagePacker.Instance.Serialize(this) ??
                                    throw new Exception($"Failed to serialize {this.GetFullishName()}");
 
 #if DIAGNOSTIC
             ApplicationContext.Context.Value?.Logger.LogDebug($"{GetType().FullName}({mCachedData.Length})={Convert.ToHexString(mCachedData)}");
 #endif
-            return mCachedData;
+            return _cachedData;
         }
     }
 
     public virtual void ClearCachedData()
     {
-        mCachedData = null;
+        _cachedData = null;
     }
 
     [IgnoreMember]

Framework/Intersect.Framework.Core/Network/PacketHandlerAttribute.cs

@@ -87,47 +87,56 @@ public static Type GetPacketType(MethodInfo methodInfo)
         return expectedPacketType;
     }
 
-    public static Type GetHandlerInterface(Type implementationType)
+    public static Type[] GetHandlerInterfaces(Type implementationType)
     {
-        if (implementationType == null)
-        {
-            throw new ArgumentNullException(nameof(implementationType));
-        }
+        ArgumentNullException.ThrowIfNull(implementationType, nameof(implementationType));
 
-        return implementationType.GetInterfaces()
-            .FirstOrDefault(
+        var interfaces = implementationType.GetInterfaces()
+            .Where(
                 interfaceType => interfaceType.IsGenericType &&
                                  interfaceType.GetGenericTypeDefinition() == TypeIPacketHandlerInterface_1
+            )
+            .ToArray();
+
+        if (interfaces.Length < 1)
+        {
+            throw new ArgumentException(
+                $"{implementationType.GetName(qualified: true)} does not directly implement {TypeIPacketHandlerInterface_1.GetName(qualified: true)}",
+                nameof(implementationType)
             );
+        }
+
+        return interfaces;
     }
 
-    public static Type GetPacketType<THandler>() where THandler : IPacketHandler =>
-        GetPacketType(typeof(THandler));
+    public static Type[] GetPacketTypes<THandler>() where THandler : IPacketHandler =>
+        GetPacketTypes(typeof(THandler));
 
-    public static Type GetPacketType(Type packetHandlerType)
+    public static Type[] GetPacketTypes(Type packetHandlerType)
     {
-        if (packetHandlerType == default)
-        {
-            throw new ArgumentNullException(nameof(packetHandlerType));
-        }
+        ArgumentNullException.ThrowIfNull(packetHandlerType, nameof(packetHandlerType));
 
-        var interfaceType = GetHandlerInterface(packetHandlerType);
-        if (interfaceType == null)
+        var interfaceTypes = GetHandlerInterfaces(packetHandlerType);
+        if (interfaceTypes.Length < 1)
         {
             throw new ArgumentException(
-                $"{packetHandlerType.FullName} does not implement {TypeIPacketHandlerInterface_1.FullName}.",
+                $"{packetHandlerType.GetName(qualified: true)} does not implement {TypeIPacketHandlerInterface_1.GetName(qualified: true)}.",
                 nameof(packetHandlerType)
             );
         }
 
-        var packetTypeFromType = interfaceType.GenericTypeArguments.FirstOrDefault();
-        if (packetTypeFromType.IsInterface ||
-            packetTypeFromType.IsAbstract ||
-            packetTypeFromType.IsGenericType ||
-            !TypeIPacket.IsAssignableFrom(packetTypeFromType))
+        var genericTypeArguments = interfaceTypes.SelectMany(interfaceType => interfaceType.GenericTypeArguments).Distinct().ToArray();
+        var packetTypesFromType = genericTypeArguments.Where(
+                packetTypeFromType =>
+                    packetTypeFromType is { IsInterface: false, IsAbstract: false, IsGenericType: false } &&
+                    packetTypeFromType.Extends(TypeIPacket)
+            )
+            .ToArray();
+
+        if (packetTypesFromType.Length < 1)
         {
             throw new ArgumentException(
-                $"Invalid packet generic type ({packetTypeFromType.FullName}) in handler declaration '{packetHandlerType.FullName}'.",
+                $"{packetHandlerType.GetName(qualified: true)} handles no packet types",
                 nameof(packetHandlerType)
             );
         }
@@ -136,17 +145,20 @@ public static Type GetPacketType(Type packetHandlerType)
             GetCustomAttribute(packetHandlerType, typeof(PacketHandlerAttribute)) as PacketHandlerAttribute;
 
         var packetTypeFromAttribute = packetHandlerAttribute?.PacketType;
-        var expectedPacketType = packetTypeFromAttribute ?? packetTypeFromType;
+        var expectedPacketTypes = packetTypeFromAttribute == null ? packetTypesFromType : [packetTypeFromAttribute];
 
-        if (packetTypeFromType != expectedPacketType)
+        if (!packetTypesFromType.SequenceEqual(expectedPacketTypes))
         {
+            var packetHandlerTypeName = packetHandlerType.GetName(qualified: true);
+            var packetTypeNames = string.Join(", ", packetTypesFromType.Select(type => type.GetName(qualified: true)));
+            var expectedPacketTypeNames = string.Join(", ", expectedPacketTypes.Select(type => type.GetName(qualified: true)));
             throw new ArgumentException(
-                $"{packetHandlerType.FullName} is a packet handler for {packetTypeFromType.FullName} but is marked with an attribute for {packetTypeFromAttribute.FullName}.",
+                $"{packetHandlerTypeName} is a packet handler for {packetTypeNames} but is marked with an attribute for {expectedPacketTypeNames}.",
                 nameof(packetHandlerType)
             );
         }
 
-        return expectedPacketType;
+        return expectedPacketTypes;
     }
 
     public static bool IsValidHandler(MethodInfo methodInfo)
@@ -186,7 +198,7 @@ public static bool IsValidHandler(Type type)
 
         try
         {
-            return GetPacketType(type) != default;
+            return GetPacketTypes(type).Length > 0;
         }
         catch (ArgumentNullException)
         {