Smarter message parsing

Future: make return params dynamic, not string
now requires type in message objects

MinecraftDiscordBot/Models/Message.cs

@@ -1,51 +1,89 @@
 using Discord.WebSocket;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace MinecraftDiscordBot.Models;
 
 public abstract class Message {
+    public static Message Deserialize(string strMessage) {
+        var obj = JObject.Parse(strMessage);
+        var typeName = GetKey<string>(obj, "type");
+        if (!Parsers.TryGetValue(typeName, out var type))
+            throw new FormatException($"Unknown message type '{typeName}'!");
+        if (obj.ToObject(type) is not Message message)
+            throw new FormatException($"Message cannot be casted to '{type}'!");
+        return message;
+    }
+
+    private static readonly Dictionary<string, Type> Parsers = GetMessageTypes();
+    private static Dictionary<string, Type> GetMessageTypes() {
+        var types = new Dictionary<string, Type>();
+        var messageTypes =
+            AppDomain.CurrentDomain.GetAssemblies().SelectMany(domainAssembly => domainAssembly.GetTypes())
+                .Where(typeof(Message).IsAssignableFrom);
+        foreach (var type in messageTypes)
+            if (GetTypeAttribute(type) is MessageTypeAttribute attr)
+                types.Add(attr.Name, type);
+        return types;
+    }
+
+    private static MessageTypeAttribute? GetTypeAttribute(Type type)
+        => type.GetCustomAttributes(typeof(MessageTypeAttribute), false).OfType<MessageTypeAttribute>().FirstOrDefault();
+
+    private static T GetKey<T>(JObject msg, string key)
+        => (msg.TryGetValue(key, out var type) ? type : throw new FormatException($"Message has no '{key}' param!"))
+            .ToObject<T>() ?? throw new FormatException($"'{key}' param is not of expected type '{typeof(T).Name}'!");
+
     [JsonProperty("type")]
     public abstract string Type { get; }
 }
 
+[MessageType(TYPE)]
 public class CapabilityMessage : Message {
-    public override string Type => "roles";
+    private const string TYPE = "roles";
+    public override string Type => TYPE;
     [JsonProperty("role", Required = Required.Always)]
     public string[] Role { get; set; } = default!;
 }
 
-public class TextMessage : Message {
-    public TextMessage(SocketMessage arg) : this(arg.Author.Username, arg.Content) { }
-    public TextMessage(string author, string content) {
-        Author = author;
-        Content = content;
-    }
-    public override string Type => "text";
-    [JsonProperty("author", Required = Required.Always)]
-    public string Author { get; set; }
-    [JsonProperty("message", Required = Required.Always)]
-    public string Content { get; set; }
-}
-
+[MessageType(TYPE)]
 public class ReplyMessage : Message {
-    public ReplyMessage(int answerId, string result) {
-        AnswerId = answerId;
-        Result = result;
-    }
+    private const string TYPE = "reply";
+    public override string Type => TYPE;
     [JsonProperty("id", Required = Required.Always)]
     public int AnswerId { get; set; }
     [JsonProperty("result", Required = Required.Always)]
-    public string Result { get; set; }
+    public string Result { get; set; } = default!;
     [JsonProperty("chunk", Required = Required.DisallowNull)]
     public int Chunk { get; set; } = 1;
     [JsonProperty("total", Required = Required.DisallowNull)]
     public int Total { get; set; } = 1;
     [JsonProperty("success", Required = Required.DisallowNull)]
     public ResultState State { get; set; } = ResultState.Successful;
-    public override string Type => "reply";
 }
 
+public abstract class EventMessage : Message { }
+
+[MessageType(TYPE)]
+public class ChatEvent : EventMessage {
+    private const string TYPE = "chat";
+    public override string Type => TYPE;
+    [JsonProperty("name", Required = Required.Always)]
+    public string Name { get; set; } = default!;
+    [JsonProperty("username", Required = Required.Always)]
+    public string Username { get; set; } = default!;
+    [JsonProperty("message", Required = Required.Always)]
+    public string Message { get; set; } = default!;
+    [JsonProperty("uuid", Required = Required.Always)]
+    public string UUID { get; set; } = default!;
+    [JsonProperty("hidden", Required = Required.Always)]
+    public bool IsHidden { get; set; }
+}
+
+[MessageType(TYPE)]
 public class RequestMessage : Message {
+    private const string TYPE = "request";
+    public override string Type => TYPE;
     public RequestMessage(int answerId, string method, Dictionary<string, object>? parameters = null) {
         AnswerId = answerId;
         Method = method;
@@ -58,11 +96,4 @@ public class RequestMessage : Message {
     public string Method { get; set; }
     [JsonProperty("params")]
     public Dictionary<string, object> Parameters { get; }
-    public override string Type => "request";
 }
-
-public enum ResultState {
-    Successful,
-    Unsuccessful,
-    Fatal
-}

MinecraftDiscordBot/Models/MessageTypeAttribute.cs

@@ -0,0 +1,7 @@
+namespace MinecraftDiscordBot.Models;
+
+[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
+public sealed class MessageTypeAttribute : Attribute {
+    public MessageTypeAttribute(string type) => Name = type;
+    public string Name { get; }
+}

MinecraftDiscordBot/Models/ResultState.cs

@@ -0,0 +1,7 @@
+namespace MinecraftDiscordBot.Models;
+
+public enum ResultState {
+    Successful,
+    Unsuccessful,
+    Fatal
+}