about summary refs log tree commit diff
path: root/MatrixRoomUtils.Core/StateEvent.cs
blob: 18b4632211fa744e9e3522e04b3d58aeae9132d6 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
using System.Diagnostics;
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
using MatrixRoomUtils.Core.Extensions;
using MatrixRoomUtils.Core.Interfaces;
using MatrixRoomUtils.Core.Responses;
using MatrixRoomUtils.Core.StateEventTypes;

namespace MatrixRoomUtils.Core;

public class StateEvent {
    public static List<Type> KnownStateEventTypes =
        new ClassCollector<IStateEventType>().ResolveFromAllAccessibleAssemblies();

    public object TypedContent {
        get => RawContent.Deserialize(GetType)!;
        set => RawContent = JsonSerializer.Deserialize<JsonObject>(JsonSerializer.Serialize(value));
    }

    [JsonPropertyName("state_key")]
    public string StateKey { get; set; } = "";

    private string _type;

    [JsonPropertyName("type")]
    public string Type {
        get => _type;
        set {
            _type = value;
            if (RawContent is not null && this is StateEventResponse stateEventResponse) {
                if (File.Exists($"unknown_state_events/{Type}/{stateEventResponse.EventId}.json")) return;
                var x = GetType.Name;
            }
        }
    }

    [JsonPropertyName("replaces_state")]
    public string? ReplacesState { get; set; }

    private JsonObject? _rawContent;

    [JsonPropertyName("content")]
    public JsonObject? RawContent {
        get => _rawContent;
        set {
            _rawContent = value;
            if (Type is not null && this is StateEventResponse stateEventResponse) {
                if (File.Exists($"unknown_state_events/{Type}/{stateEventResponse.EventId}.json")) return;
                var x = GetType.Name;
            }
        }
    }

    public T1 GetContent<T1>() where T1 : IStateEventType {
        return RawContent.Deserialize<T1>();
    }

    [JsonIgnore]
    public Type GetType {
        get {
            if (Type == "m.receipt") {
                return typeof(Dictionary<string, JsonObject>);
            }

            var type = KnownStateEventTypes.FirstOrDefault(x =>
                x.GetCustomAttributes<MatrixEventAttribute>()?.Any(y => y.EventName == Type) ?? false);

            //special handling for some types
            // if (type == typeof(RoomEmotesEventData)) {
            //     RawContent["emote"] = RawContent["emote"]?.AsObject() ?? new JsonObject();
            // }

            if (this is StateEventResponse stateEventResponse) {
                if (type == null || type == typeof(object)) {
                    Console.WriteLine($"Warning: unknown event type '{Type}'!");
                    Console.WriteLine(RawContent.ToJson());
                    Directory.CreateDirectory($"unknown_state_events/{Type}");
                    File.WriteAllText($"unknown_state_events/{Type}/{stateEventResponse.EventId}.json",
                        RawContent.ToJson());
                    Console.WriteLine($"Saved to unknown_state_events/{Type}/{stateEventResponse.EventId}.json");
                }
                else if (RawContent.FindExtraJsonObjectFields(type)) {
                    Directory.CreateDirectory($"unknown_state_events/{Type}");
                    File.WriteAllText($"unknown_state_events/{Type}/{stateEventResponse.EventId}.json",
                        RawContent.ToJson());
                    Console.WriteLine($"Saved to unknown_state_events/{Type}/{stateEventResponse.EventId}.json");
                }
            }

            return type ?? typeof(object);
        }
    }

    //debug
    public string dtype {
        get {
            var res = GetType().Name switch {
                "StateEvent`1" => $"StateEvent",
                _ => GetType().Name
            };
            return res;
        }
    }

    public string cdtype => TypedContent.GetType().Name;
}