diff --git a/ModerationBot/AccountData/BotData.cs b/ModerationBot/AccountData/BotData.cs
new file mode 100644
index 0000000..de52679
--- /dev/null
+++ b/ModerationBot/AccountData/BotData.cs
@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+using LibMatrix.EventTypes;
+
+namespace ModerationBot.AccountData;
+
+[MatrixEvent(EventName = EventId)]
+public class BotData {
+ public const string EventId = "gay.rory.moderation_bot_data";
+
+ [JsonPropertyName("control_room")]
+ public string? ControlRoom { get; set; } = "";
+
+ [JsonPropertyName("log_room")]
+ public string? LogRoom { get; set; } = "";
+
+ [JsonPropertyName("default_policy_room")]
+ public string? DefaultPolicyRoom { get; set; }
+}
\ No newline at end of file
diff --git a/ModerationBot/Commands/BanMediaCommand.cs b/ModerationBot/Commands/BanMediaCommand.cs
new file mode 100644
index 0000000..07c9858
--- /dev/null
+++ b/ModerationBot/Commands/BanMediaCommand.cs
@@ -0,0 +1,112 @@
+using System.Security.Cryptography;
+using ArcaneLibs.Extensions;
+using LibMatrix;
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.Helpers;
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot.Interfaces;
+using ModerationBot.AccountData;
+using ModerationBot.Services;
+using ModerationBot.StateEventTypes.Policies.Implementations;
+
+namespace ModerationBot.Commands;
+
+public class BanMediaCommand(HomeserverResolverService hsResolver, PolicyEngine engine, ModerationBotRoomProvider roomProvider) : ICommand {
+ public string Name { get; } = "banmedia";
+ public string[]? Aliases { get; }
+ public string Description { get; } = "Create a policy banning a piece of media, must be used in reply to a message";
+ public bool Unlisted { get; }
+
+ public async Task<bool> CanInvoke(CommandContext ctx) {
+ //check if user is admin in control room
+ var controlRoom = await roomProvider.GetControlRoomAsync();
+ var logRoom = await roomProvider.GetLogRoomAsync();
+ var isAdmin = (await controlRoom.GetPowerLevelsAsync())!.UserHasStatePermission(ctx.MessageEvent.Sender, "m.room.ban");
+ if (!isAdmin) {
+ // await ctx.Reply("You do not have permission to use this command!");
+ await logRoom.SendMessageEventAsync(
+ new RoomMessageEventContent(body: $"User {ctx.MessageEvent.Sender} tried to use command {Name} but does not have permission!", messageType: "m.text"));
+ }
+
+ return isAdmin;
+ }
+
+ public async Task Invoke(CommandContext ctx) {
+ var policyRoom = await roomProvider.GetDefaultPolicyRoomAsync();
+ var logRoom = await roomProvider.GetLogRoomAsync();
+
+ //check if reply
+ var messageContent = ctx.MessageEvent.TypedContent as RoomMessageEventContent;
+ if (messageContent?.RelatesTo is { InReplyTo: not null }) {
+ try {
+ await logRoom.SendMessageEventAsync(
+ new RoomMessageEventContent(
+ body: $"User {MessageFormatter.HtmlFormatMention(ctx.MessageEvent.Sender)} is trying to ban media {messageContent!.RelatesTo!.InReplyTo!.EventId}",
+ messageType: "m.text"));
+
+ //get replied message
+ var repliedMessage = await ctx.Room.GetEventAsync(messageContent.RelatesTo!.InReplyTo!.EventId);
+
+ //check if recommendation is in list
+ if (ctx.Args.Length < 2) {
+ await ctx.Room.SendMessageEventAsync(MessageFormatter.FormatError("You must specify a recommendation type and reason!"));
+ return;
+ }
+
+ var recommendation = ctx.Args[0];
+
+ if (recommendation is not ("ban" or "kick" or "mute" or "redact" or "spoiler" or "warn" or "warn_admins")) {
+ await ctx.Room.SendMessageEventAsync(
+ MessageFormatter.FormatError(
+ $"Invalid recommendation type {recommendation}, must be `warn_admins`, `warn`, `spoiler`, `redact`, `mute`, `kick` or `ban`!"));
+ return;
+ }
+
+ //hash file
+ var mxcUri = (repliedMessage.TypedContent as RoomMessageEventContent).Url!;
+ var resolvedUri = await hsResolver.ResolveMediaUri(mxcUri.Split('/')[2], mxcUri);
+ var hashAlgo = SHA3_256.Create();
+ var uriHash = hashAlgo.ComputeHash(mxcUri.AsBytes().ToArray());
+ byte[]? fileHash = null;
+
+ try {
+ fileHash = await hashAlgo.ComputeHashAsync(await ctx.Homeserver.ClientHttpClient.GetStreamAsync(resolvedUri));
+ }
+ catch (Exception ex) {
+ await logRoom.SendMessageEventAsync(
+ MessageFormatter.FormatException($"Error calculating file hash for {mxcUri} via {mxcUri.Split('/')[2]}, retrying via {ctx.Homeserver.BaseUrl}...",
+ ex));
+ try {
+ resolvedUri = await hsResolver.ResolveMediaUri(ctx.Homeserver.BaseUrl, mxcUri);
+ fileHash = await hashAlgo.ComputeHashAsync(await ctx.Homeserver.ClientHttpClient.GetStreamAsync(resolvedUri));
+ }
+ catch (Exception ex2) {
+ await ctx.Room.SendMessageEventAsync(MessageFormatter.FormatException("Error calculating file hash", ex2));
+ await logRoom.SendMessageEventAsync(
+ MessageFormatter.FormatException($"Error calculating file hash via {ctx.Homeserver.BaseUrl}!", ex2));
+ }
+ }
+
+ MediaPolicyFile policy;
+ await policyRoom.SendStateEventAsync("gay.rory.moderation.rule.media", Guid.NewGuid().ToString(), policy = new MediaPolicyFile {
+ Entity = Convert.ToBase64String(uriHash),
+ FileHash = Convert.ToBase64String(fileHash),
+ Reason = string.Join(' ', ctx.Args[1..]),
+ Recommendation = recommendation,
+ });
+
+ await ctx.Room.SendMessageEventAsync(MessageFormatter.FormatSuccessJson("Media policy created", policy));
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccessJson("Media policy created", policy));
+ }
+ catch (Exception e) {
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatException("Error creating policy", e));
+ await ctx.Room.SendMessageEventAsync(MessageFormatter.FormatException("Error creating policy", e));
+ await using var stream = new MemoryStream(e.ToString().AsBytes().ToArray());
+ await logRoom.SendFileAsync("error.log.cs", stream);
+ }
+ }
+ else {
+ await ctx.Room.SendMessageEventAsync(MessageFormatter.FormatError("This command must be used in reply to a message!"));
+ }
+ }
+}
diff --git a/ModerationBot/Commands/DbgAllRoomsArePolicyListsCommand.cs b/ModerationBot/Commands/DbgAllRoomsArePolicyListsCommand.cs
new file mode 100644
index 0000000..78e1979
--- /dev/null
+++ b/ModerationBot/Commands/DbgAllRoomsArePolicyListsCommand.cs
@@ -0,0 +1,60 @@
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.Helpers;
+using LibMatrix.RoomTypes;
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot.Interfaces;
+using ModerationBot.AccountData;
+
+namespace ModerationBot.Commands;
+
+public class DbgAllRoomsArePolicyListsCommand
+ (IServiceProvider services, HomeserverProviderService hsProvider, HomeserverResolverService hsResolver, PolicyEngine engine) : ICommand {
+ public string Name { get; } = "dbg-allroomsarepolicy";
+ public string[]? Aliases { get; }
+ public string Description { get; } = "[Debug] mark all rooms as trusted policy rooms";
+ public bool Unlisted { get; }
+ private GenericRoom logRoom { get; set; }
+
+ public async Task<bool> CanInvoke(CommandContext ctx) {
+// #if !DEBUG
+// return false;
+// #endif
+
+ //check if user is admin in control room
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ var controlRoom = ctx.Homeserver.GetRoom(botData.ControlRoom);
+ var isAdmin = (await controlRoom.GetPowerLevelsAsync())!.UserHasStatePermission(ctx.MessageEvent.Sender, "m.room.ban");
+ if (!isAdmin) {
+ // await ctx.Reply("You do not have permission to use this command!");
+ await ctx.Homeserver.GetRoom(botData.LogRoom!).SendMessageEventAsync(
+ new RoomMessageEventContent(body: $"User {ctx.MessageEvent.Sender} tried to use command {Name} but does not have permission!", messageType: "m.text"));
+ }
+
+ return isAdmin;
+ }
+
+ public async Task Invoke(CommandContext ctx) {
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ logRoom = ctx.Homeserver.GetRoom(botData.LogRoom ?? botData.ControlRoom);
+
+ var joinedRooms = await ctx.Homeserver.GetJoinedRooms();
+
+ await ctx.Homeserver.SetAccountDataAsync("gay.rory.moderation_bot.policy_lists", joinedRooms.ToDictionary(x => x.RoomId, x => new PolicyList() {
+ Trusted = true
+ }));
+
+ await engine.ReloadActivePolicyLists();
+ }
+
+ private async Task<bool> JoinRoom(GenericRoom memberRoom, string reason, List<string> servers) {
+ try {
+ await memberRoom.JoinAsync(servers.ToArray(), reason);
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Joined room {memberRoom.RoomId}"));
+ }
+ catch (Exception e) {
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatException($"Failed to join {memberRoom.RoomId}", e));
+ }
+
+ return true;
+ }
+}
diff --git a/ModerationBot/Commands/DbgAniRainbowTest.cs b/ModerationBot/Commands/DbgAniRainbowTest.cs
new file mode 100644
index 0000000..eed6fa5
--- /dev/null
+++ b/ModerationBot/Commands/DbgAniRainbowTest.cs
@@ -0,0 +1,50 @@
+using System.Diagnostics;
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.Helpers;
+using LibMatrix.RoomTypes;
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot.Interfaces;
+using ModerationBot.AccountData;
+
+namespace ModerationBot.Commands;
+
+public class DbgAniRainbowTest(IServiceProvider services, HomeserverProviderService hsProvider, HomeserverResolverService hsResolver, PolicyEngine engine) : ICommand {
+ public string Name { get; } = "dbg-ani-rainbow";
+ public string[]? Aliases { get; }
+ public string Description { get; } = "[Debug] animated rainbow :)";
+ public bool Unlisted { get; }
+ private GenericRoom logRoom { get; set; }
+
+ public async Task<bool> CanInvoke(CommandContext ctx) {
+ return ctx.Room.RoomId == "!DoHEdFablOLjddKWIp:rory.gay";
+ }
+
+ public async Task Invoke(CommandContext ctx) {
+ //255 long string
+ // var rainbow = "🟥🟧🟨🟩🟦🟪";
+ var rainbow = "M";
+ var chars = rainbow;
+ for (var i = 0; i < 76; i++) {
+ chars += rainbow[i%rainbow.Length];
+ }
+
+ var msg = new MessageBuilder(msgType: "m.notice").WithRainbowString(chars).Build();
+ var msgEvent = await ctx.Room.SendMessageEventAsync(msg);
+
+ Task.Run(async () => {
+
+ int i = 0;
+ while (true) {
+ msg = new MessageBuilder(msgType: "m.notice").WithRainbowString(chars, offset: i+=5).Build();
+ // .SetReplaceRelation<RoomMessageEventContent>(msgEvent.EventId);
+ // msg.Body = "";
+ // msg.FormattedBody = "";
+ var sw = Stopwatch.StartNew();
+ await ctx.Room.SendMessageEventAsync(msg);
+ await Task.Delay(sw.Elapsed);
+ }
+
+ });
+
+ }
+}
\ No newline at end of file
diff --git a/ModerationBot/Commands/DbgDumpActivePoliciesCommand.cs b/ModerationBot/Commands/DbgDumpActivePoliciesCommand.cs
new file mode 100644
index 0000000..81e81a0
--- /dev/null
+++ b/ModerationBot/Commands/DbgDumpActivePoliciesCommand.cs
@@ -0,0 +1,39 @@
+using ArcaneLibs.Extensions;
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.RoomTypes;
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot.Interfaces;
+using ModerationBot.AccountData;
+
+namespace ModerationBot.Commands;
+
+public class DbgDumpActivePoliciesCommand(IServiceProvider services, HomeserverProviderService hsProvider, HomeserverResolverService hsResolver, PolicyEngine engine) : ICommand {
+ public string Name { get; } = "dbg-dumppolicies";
+ public string[]? Aliases { get; }
+ public string Description { get; } = "[Debug] Dump all active policies";
+ public bool Unlisted { get; }
+ private GenericRoom logRoom { get; set; }
+
+ public async Task<bool> CanInvoke(CommandContext ctx) {
+#if !DEBUG
+ return false;
+#endif
+
+ //check if user is admin in control room
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ var controlRoom = ctx.Homeserver.GetRoom(botData.ControlRoom);
+ var isAdmin = (await controlRoom.GetPowerLevelsAsync())!.UserHasStatePermission(ctx.MessageEvent.Sender, "m.room.ban");
+ if (!isAdmin) {
+ // await ctx.Reply("You do not have permission to use this command!");
+ await ctx.Homeserver.GetRoom(botData.LogRoom!).SendMessageEventAsync(
+ new RoomMessageEventContent(body: $"User {ctx.MessageEvent.Sender} tried to use command {Name} but does not have permission!", messageType: "m.text"));
+ }
+
+ return isAdmin;
+ }
+
+ public async Task Invoke(CommandContext ctx) {
+ await ctx.Room.SendFileAsync("all.json", new MemoryStream(engine.ActivePolicies.ToJson().AsBytes().ToArray()), contentType: "application/json");
+ await ctx.Room.SendFileAsync("by-type.json", new MemoryStream(engine.ActivePoliciesByType.ToJson().AsBytes().ToArray()), contentType: "application/json");
+ }
+}
\ No newline at end of file
diff --git a/ModerationBot/Commands/DbgDumpAllStateTypesCommand.cs b/ModerationBot/Commands/DbgDumpAllStateTypesCommand.cs
new file mode 100644
index 0000000..ac2036a
--- /dev/null
+++ b/ModerationBot/Commands/DbgDumpAllStateTypesCommand.cs
@@ -0,0 +1,69 @@
+using ArcaneLibs.Extensions;
+using LibMatrix;
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.RoomTypes;
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot.Interfaces;
+using ModerationBot.AccountData;
+
+namespace ModerationBot.Commands;
+
+public class DbgDumpAllStateTypesCommand(IServiceProvider services, HomeserverProviderService hsProvider, HomeserverResolverService hsResolver, PolicyEngine engine) : ICommand {
+ public string Name { get; } = "dbg-dumpstatetypes";
+ public string[]? Aliases { get; }
+ public string Description { get; } = "[Debug] Dump all state types we can find";
+ public bool Unlisted { get; }
+ private GenericRoom logRoom { get; set; }
+
+ public async Task<bool> CanInvoke(CommandContext ctx) {
+#if !DEBUG
+ return false;
+#endif
+
+ //check if user is admin in control room
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ var controlRoom = ctx.Homeserver.GetRoom(botData.ControlRoom);
+ var isAdmin = (await controlRoom.GetPowerLevelsAsync())!.UserHasStatePermission(ctx.MessageEvent.Sender, "m.room.ban");
+ if (!isAdmin) {
+ // await ctx.Reply("You do not have permission to use this command!");
+ await ctx.Homeserver.GetRoom(botData.LogRoom!).SendMessageEventAsync(
+ new RoomMessageEventContent(body: $"User {ctx.MessageEvent.Sender} tried to use command {Name} but does not have permission!", messageType: "m.text"));
+ }
+
+ return isAdmin;
+ }
+
+ public async Task Invoke(CommandContext ctx) {
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ logRoom = ctx.Homeserver.GetRoom(botData.LogRoom ?? botData.ControlRoom);
+
+ var joinedRooms = await ctx.Homeserver.GetJoinedRooms();
+
+ var tasks = joinedRooms.Select(GetStateTypes).ToAsyncEnumerable();
+ await foreach (var (room, (raw, html)) in tasks) {
+ await ctx.Room.SendMessageEventAsync(new RoomMessageEventContent("m.text") {
+ Body = $"States for {room.RoomId}:\n{raw}",
+ FormattedBody = $"States for {room.RoomId}:\n{html}",
+ Format = "org.matrix.custom.html"
+ });
+ }
+ }
+
+ private async Task<(GenericRoom room, (string raw, string html))> GetStateTypes(GenericRoom memberRoom) {
+ var states = await memberRoom.GetFullStateAsListAsync();
+
+ return (memberRoom, SummariseStateTypeCounts(states));
+ }
+
+ private static (string Raw, string Html) SummariseStateTypeCounts(IList<StateEventResponse> states) {
+ string raw = "Count | State type | Mapped type", html = "<table><tr><th>Count</th><th>State type</th><th>Mapped type</th></tr>";
+ var groupedStates = states.GroupBy(x => x.Type).ToDictionary(x => x.Key, x => x.ToList()).OrderByDescending(x => x.Value.Count);
+ foreach (var (type, stateGroup) in groupedStates) {
+ raw += $"{stateGroup.Count} | {type} | {StateEvent.GetStateEventType(stateGroup[0].Type).Name}";
+ html += $"<tr><td>{stateGroup.Count}</td><td>{type}</td><td>{StateEvent.GetStateEventType(stateGroup[0].Type).Name}</td></tr>";
+ }
+
+ html += "</table>";
+ return (raw, html);
+ }
+}
\ No newline at end of file
diff --git a/ModerationBot/Commands/JoinRoomCommand.cs b/ModerationBot/Commands/JoinRoomCommand.cs
new file mode 100644
index 0000000..e604a4e
--- /dev/null
+++ b/ModerationBot/Commands/JoinRoomCommand.cs
@@ -0,0 +1,48 @@
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.Helpers;
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot.Interfaces;
+using ModerationBot.AccountData;
+
+namespace ModerationBot.Commands;
+
+public class JoinRoomCommand(IServiceProvider services, HomeserverProviderService hsProvider, HomeserverResolverService hsResolver, PolicyEngine engine) : ICommand {
+ public string Name { get; } = "join";
+ public string[]? Aliases { get; }
+ public string Description { get; } = "Join arbitrary rooms";
+ public bool Unlisted { get; }
+
+ public async Task<bool> CanInvoke(CommandContext ctx) {
+ //check if user is admin in control room
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ var controlRoom = ctx.Homeserver.GetRoom(botData.ControlRoom);
+ var isAdmin = (await controlRoom.GetPowerLevelsAsync())!.UserHasStatePermission(ctx.MessageEvent.Sender, "m.room.ban");
+ if (!isAdmin) {
+ // await ctx.Reply("You do not have permission to use this command!");
+ await ctx.Homeserver.GetRoom(botData.LogRoom!).SendMessageEventAsync(
+ new RoomMessageEventContent(body: $"User {ctx.MessageEvent.Sender} tried to use command {Name} but does not have permission!", messageType: "m.text"));
+ }
+
+ return isAdmin;
+ }
+
+ public async Task Invoke(CommandContext ctx) {
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ var policyRoom = ctx.Homeserver.GetRoom(botData.DefaultPolicyRoom ?? botData.ControlRoom);
+ var logRoom = ctx.Homeserver.GetRoom(botData.LogRoom ?? botData.ControlRoom);
+
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Joining room {ctx.Args[0]} with reason: {string.Join(' ', ctx.Args[1..])}"));
+ var roomId = ctx.Args[0];
+ var servers = new List<string>() { ctx.Homeserver.ServerName };
+ if (roomId.StartsWith('[')) { }
+
+ if (roomId.StartsWith('#')) {
+ var res = await ctx.Homeserver.ResolveRoomAliasAsync(roomId);
+ roomId = res.RoomId;
+ servers.AddRange(servers);
+ }
+
+ await ctx.Homeserver.JoinRoomAsync(roomId, servers, string.Join(' ', ctx.Args[1..]));
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Resolved room {ctx.Args[0]} to {roomId} with servers: {string.Join(", ", servers)}"));
+ }
+}
\ No newline at end of file
diff --git a/ModerationBot/Commands/JoinSpaceMembersCommand.cs b/ModerationBot/Commands/JoinSpaceMembersCommand.cs
new file mode 100644
index 0000000..86ecf7e
--- /dev/null
+++ b/ModerationBot/Commands/JoinSpaceMembersCommand.cs
@@ -0,0 +1,73 @@
+using ArcaneLibs.Extensions;
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.Helpers;
+using LibMatrix.RoomTypes;
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot.Interfaces;
+using ModerationBot.AccountData;
+
+namespace ModerationBot.Commands;
+
+public class JoinSpaceMembersCommand(IServiceProvider services, HomeserverProviderService hsProvider, HomeserverResolverService hsResolver, PolicyEngine engine) : ICommand {
+ public string Name { get; } = "joinspacemembers";
+ public string[]? Aliases { get; }
+ public string Description { get; } = "Join all rooms in space";
+ public bool Unlisted { get; }
+ private GenericRoom logRoom { get; set; }
+
+ public async Task<bool> CanInvoke(CommandContext ctx) {
+ //check if user is admin in control room
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ var controlRoom = ctx.Homeserver.GetRoom(botData.ControlRoom);
+ var isAdmin = (await controlRoom.GetPowerLevelsAsync())!.UserHasStatePermission(ctx.MessageEvent.Sender, "m.room.ban");
+ if (!isAdmin) {
+ // await ctx.Reply("You do not have permission to use this command!");
+ await ctx.Homeserver.GetRoom(botData.LogRoom!).SendMessageEventAsync(
+ new RoomMessageEventContent(body: $"User {ctx.MessageEvent.Sender} tried to use command {Name} but does not have permission!", messageType: "m.text"));
+ }
+
+ return isAdmin;
+ }
+
+ public async Task Invoke(CommandContext ctx) {
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ logRoom = ctx.Homeserver.GetRoom(botData.LogRoom ?? botData.ControlRoom);
+ var currentRooms = (await ctx.Homeserver.GetJoinedRooms()).Select(x => x.RoomId).ToList();
+
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Joining space children of {ctx.Args[0]} with reason: {string.Join(' ', ctx.Args[1..])}"));
+ var roomId = ctx.Args[0];
+ var servers = new List<string>() { ctx.Homeserver.ServerName };
+ if (roomId.StartsWith('[')) { }
+
+ if (roomId.StartsWith('#')) {
+ var res = await ctx.Homeserver.ResolveRoomAliasAsync(roomId);
+ roomId = res.RoomId;
+ servers.AddRange(servers);
+ }
+
+ var room = ctx.Homeserver.GetRoom(roomId);
+ var tasks = new List<Task<bool>>();
+ await foreach (var memberRoom in room.AsSpace.GetChildrenAsync()) {
+ if (currentRooms.Contains(memberRoom.RoomId)) continue;
+ servers.Add(room.RoomId.Split(':', 2)[1]);
+ servers = servers.Distinct().ToList();
+ tasks.Add(JoinRoom(memberRoom, string.Join(' ', ctx.Args[1..]), servers));
+ }
+
+ await foreach (var b in tasks.ToAsyncEnumerable()) {
+ await Task.Delay(50);
+ }
+ }
+
+ private async Task<bool> JoinRoom(GenericRoom memberRoom, string reason, List<string> servers) {
+ try {
+ var resp = await memberRoom.JoinAsync(servers.ToArray(), reason, checkIfAlreadyMember: false);
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Joined room {memberRoom.RoomId} (resp={resp.RoomId})"));
+ }
+ catch (Exception e) {
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatException($"Failed to join {memberRoom.RoomId}", e));
+ }
+
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/ModerationBot/Commands/ReloadPoliciesCommand.cs b/ModerationBot/Commands/ReloadPoliciesCommand.cs
new file mode 100644
index 0000000..2934185
--- /dev/null
+++ b/ModerationBot/Commands/ReloadPoliciesCommand.cs
@@ -0,0 +1,38 @@
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.Helpers;
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot.Interfaces;
+using ModerationBot.AccountData;
+
+namespace ModerationBot.Commands;
+
+public class ReloadPoliciesCommand(IServiceProvider services, HomeserverProviderService hsProvider, HomeserverResolverService hsResolver, PolicyEngine engine) : ICommand {
+ public string Name { get; } = "reloadpolicies";
+ public string[]? Aliases { get; }
+ public string Description { get; } = "Reload policies";
+ public bool Unlisted { get; }
+
+ public async Task<bool> CanInvoke(CommandContext ctx) {
+ if (ctx.MessageEvent.Sender == "@cadence:cadence.moe") return true;
+ //check if user is admin in control room
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ var controlRoom = ctx.Homeserver.GetRoom(botData.ControlRoom);
+ var isAdmin = (await controlRoom.GetPowerLevelsAsync())!.UserHasStatePermission(ctx.MessageEvent.Sender, "m.room.ban");
+ if (!isAdmin) {
+ // await ctx.Reply("You do not have permission to use this command!");
+ await ctx.Homeserver.GetRoom(botData.LogRoom!).SendMessageEventAsync(
+ new RoomMessageEventContent(body: $"User {ctx.MessageEvent.Sender} tried to use command {Name} but does not have permission!", messageType: "m.text"));
+ }
+
+ return isAdmin;
+ }
+
+ public async Task Invoke(CommandContext ctx) {
+ var botData = await ctx.Homeserver.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ var policyRoom = ctx.Homeserver.GetRoom(botData.DefaultPolicyRoom ?? botData.ControlRoom);
+ var logRoom = ctx.Homeserver.GetRoom(botData.LogRoom ?? botData.ControlRoom);
+
+ await logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Reloading policy lists due to manual invocation!!!!"));
+ await engine.ReloadActivePolicyLists();
+ }
+}
\ No newline at end of file
diff --git a/ModerationBot/FirstRunTasks.cs b/ModerationBot/FirstRunTasks.cs
new file mode 100644
index 0000000..9dece1d
--- /dev/null
+++ b/ModerationBot/FirstRunTasks.cs
@@ -0,0 +1,83 @@
+using LibMatrix;
+using LibMatrix.Homeservers;
+using LibMatrix.Responses;
+using ModerationBot.AccountData;
+
+namespace ModerationBot;
+
+public class FirstRunTasks {
+ public static async Task<BotData> ConstructBotData(AuthenticatedHomeserverGeneric hs, ModerationBotConfiguration configuration, BotData? botdata) {
+ botdata ??= new BotData();
+ var creationContent = CreateRoomRequest.CreatePrivate(hs, name: "Rory&::ModerationBot - Control room", roomAliasName: "moderation-bot-control-room");
+ creationContent.Invite = configuration.Admins;
+ creationContent.CreationContent["type"] = "gay.rory.moderation_bot.control_room";
+
+ if (botdata.ControlRoom is null)
+ try {
+ botdata.ControlRoom = (await hs.CreateRoom(creationContent)).RoomId;
+ }
+ catch (Exception e) {
+ if (e is not MatrixException { ErrorCode: "M_ROOM_IN_USE" }) {
+ Console.WriteLine(e);
+ throw;
+ }
+
+ creationContent.RoomAliasName += $"-{Guid.NewGuid()}";
+ botdata.ControlRoom = (await hs.CreateRoom(creationContent)).RoomId;
+ }
+ //set access rules to allow joining via control room
+ // creationContent.InitialState.Add(new StateEvent {
+ // Type = "m.room.join_rules",
+ // StateKey = "",
+ // TypedContent = new RoomJoinRulesEventContent {
+ // JoinRule = "knock_restricted",
+ // Allow = new() {
+ // new RoomJoinRulesEventContent.AllowEntry {
+ // Type = "m.room_membership",
+ // RoomId = botdata.ControlRoom
+ // }
+ // }
+ // }
+ // });
+
+ creationContent.Name = "Rory&::ModerationBot - Log room";
+ creationContent.RoomAliasName = "moderation-bot-log-room";
+ creationContent.CreationContent["type"] = "gay.rory.moderation_bot.log_room";
+
+ if (botdata.LogRoom is null)
+ try {
+ botdata.LogRoom = (await hs.CreateRoom(creationContent)).RoomId;
+ }
+ catch (Exception e) {
+ if (e is not MatrixException { ErrorCode: "M_ROOM_IN_USE" }) {
+ Console.WriteLine(e);
+ throw;
+ }
+
+ creationContent.RoomAliasName += $"-{Guid.NewGuid()}";
+ botdata.LogRoom = (await hs.CreateRoom(creationContent)).RoomId;
+ }
+
+ creationContent.Name = "Rory&::ModerationBot - Policy room";
+ creationContent.RoomAliasName = "moderation-bot-policy-room";
+ creationContent.CreationContent["type"] = "gay.rory.moderation_bot.policy_room";
+
+ if (botdata.DefaultPolicyRoom is null)
+ try {
+ botdata.DefaultPolicyRoom = (await hs.CreateRoom(creationContent)).RoomId;
+ }
+ catch (Exception e) {
+ if (e is not MatrixException { ErrorCode: "M_ROOM_IN_USE" }) {
+ Console.WriteLine(e);
+ throw;
+ }
+
+ creationContent.RoomAliasName += $"-{Guid.NewGuid()}";
+ botdata.DefaultPolicyRoom = (await hs.CreateRoom(creationContent)).RoomId;
+ }
+
+ await hs.SetAccountDataAsync("gay.rory.moderation_bot_data", botdata);
+
+ return botdata;
+ }
+}
diff --git a/ModerationBot/ModerationBot.cs b/ModerationBot/ModerationBot.cs
new file mode 100644
index 0000000..791d3b5
--- /dev/null
+++ b/ModerationBot/ModerationBot.cs
@@ -0,0 +1,302 @@
+using ArcaneLibs.Extensions;
+using LibMatrix;
+using LibMatrix.EventTypes;
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.EventTypes.Spec.State;
+using LibMatrix.EventTypes.Spec.State.Policy;
+using LibMatrix.Helpers;
+using LibMatrix.Homeservers;
+using LibMatrix.RoomTypes;
+using LibMatrix.Services;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using ModerationBot.AccountData;
+using ModerationBot.StateEventTypes.Policies;
+
+namespace ModerationBot;
+
+public class ModerationBot(AuthenticatedHomeserverGeneric hs, ILogger<ModerationBot> logger, ModerationBotConfiguration configuration, PolicyEngine engine) : IHostedService {
+ private Task _listenerTask;
+
+ // private GenericRoom _policyRoom;
+ private GenericRoom? _logRoom;
+ private GenericRoom? _controlRoom;
+
+ /// <summary>Triggered when the application host is ready to start the service.</summary>
+ /// <param name="cancellationToken">Indicates that the start process has been aborted.</param>
+ public async Task StartAsync(CancellationToken cancellationToken) {
+ _listenerTask = Run(cancellationToken);
+ logger.LogInformation("Bot started!");
+ }
+
+ private async Task Run(CancellationToken cancellationToken) {
+ if (Directory.Exists("bot_data/cache"))
+ Directory.GetFiles("bot_data/cache").ToList().ForEach(File.Delete);
+
+ BotData botData;
+
+ try {
+ logger.LogInformation("Fetching bot account data...");
+ botData = await hs.GetAccountDataAsync<BotData>("gay.rory.moderation_bot_data");
+ logger.LogInformation("Got bot account data...");
+ }
+ catch (Exception e) {
+ logger.LogInformation("Could not fetch bot account data... {}", e.Message);
+ if (e is not MatrixException { ErrorCode: "M_NOT_FOUND" }) {
+ logger.LogError("{}", e.ToString());
+ throw;
+ }
+
+ botData = null;
+ }
+
+ botData = await FirstRunTasks.ConstructBotData(hs, configuration, botData);
+
+ // _policyRoom = hs.GetRoom(botData.PolicyRoom ?? botData.ControlRoom);
+ _logRoom = hs.GetRoom(botData.LogRoom ?? botData.ControlRoom);
+ _controlRoom = hs.GetRoom(botData.ControlRoom);
+ foreach (var configurationAdmin in configuration.Admins) {
+ var pls = await _controlRoom.GetPowerLevelsAsync();
+ if (pls is null) {
+ await _logRoom?.SendMessageEventAsync(MessageFormatter.FormatWarning($"Control room has no m.room.power_levels?"));
+ continue;
+ }
+ pls.SetUserPowerLevel(configurationAdmin, pls.GetUserPowerLevel(hs.UserId));
+ await _controlRoom.SendStateEventAsync(RoomPowerLevelEventContent.EventId, pls);
+ }
+ var syncHelper = new SyncHelper(hs);
+
+ List<string> admins = new();
+
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+ Task.Run(async () => {
+ while (!cancellationToken.IsCancellationRequested) {
+ var controlRoomMembers = _controlRoom.GetMembersEnumerableAsync();
+ var pls = await _controlRoom.GetPowerLevelsAsync();
+ await foreach (var member in controlRoomMembers) {
+ if ((member.TypedContent as RoomMemberEventContent)?
+ .Membership == "join" && pls.UserHasTimelinePermission(member.Sender, RoomMessageEventContent.EventId)) admins.Add(member.StateKey);
+ }
+
+ await Task.Delay(TimeSpan.FromMinutes(5), cancellationToken);
+ }
+ }, cancellationToken);
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
+ syncHelper.InviteReceivedHandlers.Add(async Task (args) => {
+ var inviteEvent =
+ args.Value.InviteState.Events.FirstOrDefault(x =>
+ x.Type == "m.room.member" && x.StateKey == hs.UserId);
+ logger.LogInformation("Got invite to {RoomId} by {Sender} with reason: {Reason}", args.Key, inviteEvent!.Sender,
+ (inviteEvent.TypedContent as RoomMemberEventContent)!.Reason);
+ await _logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Bot invited to {MessageFormatter.HtmlFormatMention(args.Key)} by {MessageFormatter.HtmlFormatMention(inviteEvent.Sender)}"));
+ if (admins.Contains(inviteEvent.Sender)) {
+ try {
+ await _logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Joining {MessageFormatter.HtmlFormatMention(args.Key)}..."));
+ var senderProfile = await hs.GetProfileAsync(inviteEvent.Sender);
+ await hs.GetRoom(args.Key).JoinAsync(reason: $"I was invited by {senderProfile.DisplayName ?? inviteEvent.Sender}!");
+ }
+ catch (Exception e) {
+ logger.LogError("{}", e.ToString());
+ await _logRoom.SendMessageEventAsync(MessageFormatter.FormatException("Could not join room", e));
+ await hs.GetRoom(args.Key).LeaveAsync(reason: "I was unable to join the room: " + e);
+ }
+ }
+ });
+
+ syncHelper.TimelineEventHandlers.Add(async @event => {
+ var room = hs.GetRoom(@event.RoomId);
+ try {
+ logger.LogInformation(
+ "Got timeline event in {}: {}", @event.RoomId, @event.ToJson(indent: true, ignoreNull: true));
+
+ if (@event != null && (
+ @event.MappedType.IsAssignableTo(typeof(BasePolicy))
+ || @event.MappedType.IsAssignableTo(typeof(PolicyRuleEventContent))
+ )) {
+ await LogPolicyChange(@event);
+ await engine.ReloadActivePolicyListById(@event.RoomId);
+ }
+
+ var rules = await engine.GetMatchingPolicies(@event);
+ foreach (var matchedRule in rules) {
+ await _logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccessJson(
+ $"{MessageFormatter.HtmlFormatMessageLink(eventId: @event.EventId, roomId: room.RoomId, displayName: "Event")} matched {MessageFormatter.HtmlFormatMessageLink(eventId: @matchedRule.OriginalEvent.EventId, roomId: matchedRule.PolicyList.Room.RoomId, displayName: "rule")}", @matchedRule.OriginalEvent.RawContent));
+ }
+
+ if (configuration.DemoMode) {
+ // foreach (var matchedRule in rules) {
+ // await room.SendMessageEventAsync(MessageFormatter.FormatSuccessJson(
+ // $"{MessageFormatter.HtmlFormatMessageLink(eventId: @event.EventId, roomId: room.RoomId, displayName: "Event")} matched {MessageFormatter.HtmlFormatMessageLink(eventId: @matchedRule.EventId, roomId: matchedRule.RoomId, displayName: "rule")}", @matchedRule.RawContent));
+ // }
+ return;
+ }
+ //
+ // if (@event is { Type: "m.room.message", TypedContent: RoomMessageEventContent message }) {
+ // if (message is { MessageType: "m.image" }) {
+ // //check media
+ // // var matchedPolicy = await CheckMedia(@event);
+ // var matchedPolicy = rules.FirstOrDefault();
+ // if (matchedPolicy is null) return;
+ // var matchedpolicyData = matchedPolicy.TypedContent as MediaPolicyEventContent;
+ // await _logRoom.SendMessageEventAsync(
+ // new RoomMessageEventContent(
+ // body:
+ // $"User {MessageFormatter.HtmlFormatMention(@event.Sender)} posted an image in {MessageFormatter.HtmlFormatMention(room.RoomId)} that matched rule {matchedPolicy.StateKey}, applying action {matchedpolicyData.Recommendation}, as described in rule: {matchedPolicy.RawContent!.ToJson(ignoreNull: true)}",
+ // messageType: "m.text") {
+ // Format = "org.matrix.custom.html",
+ // FormattedBody =
+ // $"<font color=\"#FFFF00\">User {MessageFormatter.HtmlFormatMention(@event.Sender)} posted an image in {MessageFormatter.HtmlFormatMention(room.RoomId)} that matched rule {matchedPolicy.StateKey}, applying action {matchedpolicyData.Recommendation}, as described in rule: <pre>{matchedPolicy.RawContent!.ToJson(ignoreNull: true)}</pre></font>"
+ // });
+ // switch (matchedpolicyData.Recommendation) {
+ // case "warn_admins": {
+ // await _controlRoom.SendMessageEventAsync(
+ // new RoomMessageEventContent(
+ // body: $"{string.Join(' ', admins)}\nUser {MessageFormatter.HtmlFormatMention(@event.Sender)} posted a banned image {message.Url}",
+ // messageType: "m.text") {
+ // Format = "org.matrix.custom.html",
+ // FormattedBody = $"{string.Join(' ', admins.Select(u => MessageFormatter.HtmlFormatMention(u)))}\n" +
+ // $"<font color=\"#FF0000\">User {MessageFormatter.HtmlFormatMention(@event.Sender)} posted a banned image <a href=\"{message.Url}\">{message.Url}</a></font>"
+ // });
+ // break;
+ // }
+ // case "warn": {
+ // await room.SendMessageEventAsync(
+ // new RoomMessageEventContent(
+ // body: $"Please be careful when posting this image: {matchedpolicyData.Reason ?? "No reason specified"}",
+ // messageType: "m.text") {
+ // Format = "org.matrix.custom.html",
+ // FormattedBody =
+ // $"<font color=\"#FFFF00\">Please be careful when posting this image: {matchedpolicyData.Reason ?? "No reason specified"}</a></font>"
+ // });
+ // break;
+ // }
+ // case "redact": {
+ // await room.RedactEventAsync(@event.EventId, matchedpolicyData.Reason ?? "No reason specified");
+ // break;
+ // }
+ // case "spoiler": {
+ // // <blockquote>
+ // // <a href=\"https://matrix.to/#/@emma:rory.gay\">@emma:rory.gay</a><br>
+ // // <a href=\"https://codeberg.org/crimsonfork/CN\"></a>
+ // // <font color=\"#dc143c\" data-mx-color=\"#dc143c\">
+ // // <b>CN</b>
+ // // </font>:
+ // // <a href=\"https://the-apothecary.club/_matrix/media/v3/download/rory.gay/sLkdxUhipiQaFwRkXcPSRwdg\">test</a><br>
+ // // <span data-mx-spoiler=\"\"><a href=\"https://the-apothecary.club/_matrix/media/v3/download/rory.gay/sLkdxUhipiQaFwRkXcPSRwdg\">
+ // // <img src=\"mxc://rory.gay/sLkdxUhipiQaFwRkXcPSRwdg\" height=\"69\"></a>
+ // // </span>
+ // // </blockquote>
+ // await room.SendMessageEventAsync(
+ // new RoomMessageEventContent(
+ // body:
+ // $"Please be careful when posting this image: {matchedpolicyData.Reason}, I have spoilered it for you:",
+ // messageType: "m.text") {
+ // Format = "org.matrix.custom.html",
+ // FormattedBody =
+ // $"<font color=\"#FFFF00\">Please be careful when posting this image: {matchedpolicyData.Reason}, I have spoilered it for you:</a></font>"
+ // });
+ // var imageUrl = message.Url;
+ // await room.SendMessageEventAsync(
+ // new RoomMessageEventContent(body: $"CN: {imageUrl}",
+ // messageType: "m.text") {
+ // Format = "org.matrix.custom.html",
+ // FormattedBody = $"""
+ // <blockquote>
+ // <font color=\"#dc143c\" data-mx-color=\"#dc143c\">
+ // <b>CN</b>
+ // </font>:
+ // <a href=\"{imageUrl}\">{matchedpolicyData.Reason}</a><br>
+ // <span data-mx-spoiler=\"\">
+ // <a href=\"{imageUrl}\">
+ // <img src=\"{imageUrl}\" height=\"69\">
+ // </a>
+ // </span>
+ // </blockquote>
+ // """
+ // });
+ // await room.RedactEventAsync(@event.EventId, "Automatically spoilered: " + matchedpolicyData.Reason);
+ // break;
+ // }
+ // case "mute": {
+ // await room.RedactEventAsync(@event.EventId, matchedpolicyData.Reason);
+ // //change powerlevel to -1
+ // var currentPls = await room.GetPowerLevelsAsync();
+ // if (currentPls is null) {
+ // logger.LogWarning("Unable to get power levels for {room}", room.RoomId);
+ // await _logRoom.SendMessageEventAsync(
+ // MessageFormatter.FormatError($"Unable to get power levels for {MessageFormatter.HtmlFormatMention(room.RoomId)}"));
+ // return;
+ // }
+ //
+ // currentPls.Users ??= new();
+ // currentPls.Users[@event.Sender] = -1;
+ // await room.SendStateEventAsync("m.room.power_levels", currentPls);
+ // break;
+ // }
+ // case "kick": {
+ // await room.RedactEventAsync(@event.EventId, matchedpolicyData.Reason);
+ // await room.KickAsync(@event.Sender, matchedpolicyData.Reason);
+ // break;
+ // }
+ // case "ban": {
+ // await room.RedactEventAsync(@event.EventId, matchedpolicyData.Reason);
+ // await room.BanAsync(@event.Sender, matchedpolicyData.Reason);
+ // break;
+ // }
+ // default: {
+ // throw new ArgumentOutOfRangeException("recommendation",
+ // $"Unknown response type {matchedpolicyData.Recommendation}!");
+ // }
+ // }
+ // }
+ // }
+ }
+ catch (Exception e) {
+ logger.LogError("{}", e.ToString());
+ await _controlRoom.SendMessageEventAsync(
+ MessageFormatter.FormatException($"Unable to process event in {MessageFormatter.HtmlFormatMention(room.RoomId)}", e));
+ await _logRoom.SendMessageEventAsync(
+ MessageFormatter.FormatException($"Unable to process event in {MessageFormatter.HtmlFormatMention(room.RoomId)}", e));
+ await using var stream = new MemoryStream(e.ToString().AsBytes().ToArray());
+ await _controlRoom.SendFileAsync("error.log.cs", stream);
+ await _logRoom.SendFileAsync("error.log.cs", stream);
+ }
+ });
+ await engine.ReloadActivePolicyLists();
+ await syncHelper.RunSyncLoopAsync();
+ }
+
+ private async Task LogPolicyChange(StateEventResponse changeEvent) {
+ var room = hs.GetRoom(changeEvent.RoomId!);
+ var message = MessageFormatter.FormatWarning($"Policy change detected in {MessageFormatter.HtmlFormatMessageLink(changeEvent.RoomId, changeEvent.EventId, [hs.ServerName], await room.GetNameOrFallbackAsync())}!");
+ message = message.ConcatLine(new RoomMessageEventContent(body: $"Policy type: {changeEvent.Type} -> {changeEvent.MappedType.Name}") {
+ FormattedBody = $"Policy type: {changeEvent.Type} -> {changeEvent.MappedType.Name}"
+ });
+ var isUpdated = changeEvent.Unsigned.PrevContent is { Count: > 0 };
+ var isRemoved = changeEvent.RawContent is not { Count: > 0 };
+ // if (isUpdated) {
+ // message = message.ConcatLine(MessageFormatter.FormatSuccess("Rule updated!"));
+ // message = message.ConcatLine(MessageFormatter.FormatSuccessJson("Old rule:", changeEvent.Unsigned.PrevContent!));
+ // }
+ // else if (isRemoved) {
+ // message = message.ConcatLine(MessageFormatter.FormatWarningJson("Rule removed!", changeEvent.Unsigned.PrevContent!));
+ // }
+ // else {
+ // message = message.ConcatLine(MessageFormatter.FormatSuccess("New rule added!"));
+ // }
+ message = message.ConcatLine(MessageFormatter.FormatSuccessJson($"{(isUpdated ? "Updated" : isRemoved ? "Removed" : "New")} rule: {changeEvent.StateKey}", changeEvent.RawContent!));
+ if (isRemoved || isUpdated) {
+ message = message.ConcatLine(MessageFormatter.FormatSuccessJson("Old content: ", changeEvent.Unsigned.PrevContent!));
+ }
+
+ await _logRoom.SendMessageEventAsync(message);
+ }
+
+ /// <summary>Triggered when the application host is performing a graceful shutdown.</summary>
+ /// <param name="cancellationToken">Indicates that the shutdown process should no longer be graceful.</param>
+ public async Task StopAsync(CancellationToken cancellationToken) {
+ logger.LogInformation("Shutting down bot!");
+ }
+
+}
diff --git a/ModerationBot/ModerationBot.csproj b/ModerationBot/ModerationBot.csproj
new file mode 100644
index 0000000..009ace0
--- /dev/null
+++ b/ModerationBot/ModerationBot.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <TargetFramework>net8.0</TargetFramework>
+ <LangVersion>preview</LangVersion>
+ <ImplicitUsings>enable</ImplicitUsings>
+ <Nullable>enable</Nullable>
+ <PublishAot>false</PublishAot>
+ <InvariantGlobalization>true</InvariantGlobalization>
+<!-- <PublishTrimmed>true</PublishTrimmed>-->
+<!-- <PublishReadyToRun>true</PublishReadyToRun>-->
+<!-- <PublishSingleFile>true</PublishSingleFile>-->
+<!-- <PublishReadyToRunShowWarnings>true</PublishReadyToRunShowWarnings>-->
+<!-- <PublishTrimmedShowLinkerSizeComparison>true</PublishTrimmedShowLinkerSizeComparison>-->
+<!-- <PublishTrimmedShowLinkerSizeComparisonWarnings>true</PublishTrimmedShowLinkerSizeComparisonWarnings>-->
+ </PropertyGroup>
+
+ <ItemGroup>
+ <ProjectReference Include="..\LibMatrix\LibMatrix\LibMatrix.csproj" />
+ <ProjectReference Include="..\LibMatrix\Utilities\LibMatrix.Utilities.Bot\LibMatrix.Utilities.Bot.csproj" />
+ </ItemGroup>
+
+ <ItemGroup>
+ <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
+ </ItemGroup>
+ <ItemGroup>
+ <Content Include="appsettings*.json">
+ <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+ </Content>
+ </ItemGroup>
+</Project>
diff --git a/ModerationBot/ModerationBotConfiguration.cs b/ModerationBot/ModerationBotConfiguration.cs
new file mode 100644
index 0000000..415b581
--- /dev/null
+++ b/ModerationBot/ModerationBotConfiguration.cs
@@ -0,0 +1,10 @@
+using Microsoft.Extensions.Configuration;
+
+namespace ModerationBot;
+
+public class ModerationBotConfiguration {
+ public ModerationBotConfiguration(IConfiguration config) => config.GetRequiredSection("ModerationBot").Bind(this);
+
+ public List<string> Admins { get; set; } = new();
+ public bool DemoMode { get; set; } = false;
+}
diff --git a/ModerationBot/PolicyEngine.cs b/ModerationBot/PolicyEngine.cs
new file mode 100644
index 0000000..7556fc5
--- /dev/null
+++ b/ModerationBot/PolicyEngine.cs
@@ -0,0 +1,268 @@
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using ArcaneLibs.Extensions;
+using LibMatrix;
+using LibMatrix.EventTypes.Spec;
+using LibMatrix.EventTypes.Spec.State.Policy;
+using LibMatrix.Helpers;
+using LibMatrix.Homeservers;
+using LibMatrix.RoomTypes;
+using LibMatrix.Services;
+using Microsoft.Extensions.Logging;
+using ModerationBot.AccountData;
+using ModerationBot.Services;
+using ModerationBot.StateEventTypes.Policies;
+using ModerationBot.StateEventTypes.Policies.Implementations;
+
+namespace ModerationBot;
+
+public class PolicyEngine(AuthenticatedHomeserverGeneric hs, ILogger<ModerationBot> logger, ModerationBotConfiguration configuration, HomeserverResolverService hsResolver, ModerationBotRoomProvider roomProvider) {
+ private Dictionary<string, PolicyList> PolicyListAccountData { get; set; } = new();
+
+ // ReSharper disable once MemberCanBePrivate.Global
+ public List<PolicyList> ActivePolicyLists { get; set; } = new();
+ public List<BasePolicy> ActivePolicies { get; set; } = new();
+ public Dictionary<string, List<BasePolicy>> ActivePoliciesByType { get; set; } = new();
+ private GenericRoom? _logRoom;
+ private GenericRoom? _controlRoom;
+
+ public async Task ReloadActivePolicyLists() {
+ var sw = Stopwatch.StartNew();
+
+ _logRoom = await roomProvider.GetLogRoomAsync();
+ _controlRoom = await roomProvider.GetControlRoomAsync();
+
+ await _controlRoom?.SendMessageEventAsync(MessageFormatter.FormatSuccess("Reloading policy lists!"))!;
+ await _logRoom?.SendMessageEventAsync(MessageFormatter.FormatSuccess("Reloading policy lists!"))!;
+
+ var progressMessage = await _logRoom?.SendMessageEventAsync(MessageFormatter.FormatSuccess("0/? policy lists loaded"))!;
+
+ var policyLists = new List<PolicyList>();
+ try {
+ PolicyListAccountData = await hs.GetAccountDataAsync<Dictionary<string, PolicyList>>("gay.rory.moderation_bot.policy_lists");
+ }
+ catch (MatrixException e) {
+ if (e is not { ErrorCode: "M_NOT_FOUND" }) throw;
+ }
+
+ // if (!PolicyListAccountData.ContainsKey(botData.DefaultPolicyRoom!)) {
+ // PolicyListAccountData.Add(botData.DefaultPolicyRoom!, new PolicyList() {
+ // Trusted = true
+ // });
+ // await hs.SetAccountDataAsync("gay.rory.moderation_bot.policy_lists", PolicyListAccountData);
+ // }
+
+ var loadTasks = new List<Task<PolicyList>>();
+ foreach (var (roomId, policyList) in PolicyListAccountData) {
+ var room = hs.GetRoom(roomId);
+ loadTasks.Add(LoadPolicyListAsync(room, policyList));
+ }
+
+ await foreach (var policyList in loadTasks.ToAsyncEnumerable()) {
+ policyLists.Add(policyList);
+
+ if (true || policyList.Policies.Count >= 256 || policyLists.Count == PolicyListAccountData.Count) {
+ var progressMsgContent = MessageFormatter.FormatSuccess($"{policyLists.Count}/{PolicyListAccountData.Count} policy lists loaded, " +
+ $"{policyLists.Sum(x => x.Policies.Count)} policies total, {sw.Elapsed} elapsed.")
+ .SetReplaceRelation<RoomMessageEventContent>(progressMessage.EventId);
+
+ await _logRoom?.SendMessageEventAsync(progressMsgContent);
+ }
+ }
+
+ // Console.WriteLine($"Reloaded policy list data in {sw.Elapsed}");
+ // await _logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Done fetching {policyLists.Count} policy lists in {sw.Elapsed}!"));
+
+ ActivePolicyLists = policyLists;
+ ActivePolicies = await GetActivePolicies();
+ }
+
+ private async Task<PolicyList> LoadPolicyListAsync(GenericRoom room, PolicyList policyList) {
+ policyList.Room = room;
+ policyList.Policies.Clear();
+
+ var stateEvents = room.GetFullStateAsync();
+ await foreach (var stateEvent in stateEvents) {
+ if (stateEvent != null && (
+ stateEvent.MappedType.IsAssignableTo(typeof(BasePolicy))
+ || stateEvent.MappedType.IsAssignableTo(typeof(PolicyRuleEventContent))
+ )) {
+ policyList.Policies.Add(stateEvent);
+ }
+ }
+
+ // if (policyList.Policies.Count >= 1)
+ // await _logRoom?.SendMessageEventAsync(
+ // MessageFormatter.FormatSuccess($"Loaded {policyList.Policies.Count} policies for {MessageFormatter.HtmlFormatMention(room.RoomId)}!"))!;
+
+ return policyList;
+ }
+
+ public async Task ReloadActivePolicyListById(string roomId) {
+ if (!ActivePolicyLists.Any(x => x.Room.RoomId == roomId)) return;
+ await LoadPolicyListAsync(hs.GetRoom(roomId), ActivePolicyLists.Single(x => x.Room.RoomId == roomId));
+ ActivePolicies = await GetActivePolicies();
+ }
+
+ public async Task<List<BasePolicy>> GetActivePolicies() {
+ var sw = Stopwatch.StartNew();
+ List<BasePolicy> activePolicies = new();
+
+ foreach (var activePolicyList in ActivePolicyLists) {
+ foreach (var policyEntry in activePolicyList.Policies) {
+ // TODO: implement rule translation
+ var policy = policyEntry.TypedContent is BasePolicy ? policyEntry.TypedContent as BasePolicy : policyEntry.RawContent.Deserialize<UnknownPolicy>();
+ if (policy?.Entity is null) continue;
+ policy.PolicyList = activePolicyList;
+ policy.OriginalEvent = policyEntry;
+ activePolicies.Add(policy);
+ }
+ }
+
+ Console.WriteLine($"Translated policy list data in {sw.Elapsed}");
+ ActivePoliciesByType = activePolicies.GroupBy(x => x.GetType().Name).ToDictionary(x => x.Key, x => x.ToList());
+ await _logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Translated policy list data in {sw.GetElapsedAndRestart()}"));
+ // await _logRoom.SendMessageEventAsync(MessageFormatter.FormatSuccess($"Built policy type map in {sw.GetElapsedAndRestart()}"));
+
+ var summary = SummariseStateTypeCounts(activePolicies.Select(x => x.OriginalEvent).ToList());
+ await _logRoom?.SendMessageEventAsync(new RoomMessageEventContent() {
+ Body = summary.Raw,
+ FormattedBody = summary.Html,
+ Format = "org.matrix.custom.html"
+ })!;
+
+ return activePolicies;
+ }
+
+ public async Task<List<BasePolicy>> GetMatchingPolicies(StateEventResponse @event) {
+ List<BasePolicy> matchingPolicies = new();
+ if (@event.Sender == @hs.UserId) return matchingPolicies; //ignore self at all costs
+
+ if (ActivePoliciesByType.TryGetValue(nameof(ServerPolicyRuleEventContent), out var serverPolicies)) {
+ var userServer = @event.Sender.Split(':', 2)[1];
+ matchingPolicies.AddRange(serverPolicies.Where(x => x.Entity == userServer));
+ }
+
+ if (ActivePoliciesByType.TryGetValue(nameof(UserPolicyRuleEventContent), out var userPolicies)) {
+ matchingPolicies.AddRange(userPolicies.Where(x => x.Entity == @event.Sender));
+ }
+
+ if (@event.TypedContent is RoomMessageEventContent msgContent) {
+ matchingPolicies.AddRange(await CheckMessageContent(@event));
+ // if (msgContent.MessageType == "m.text" || msgContent.MessageType == "m.notice") ; //TODO: implement word etc. filters
+ if (msgContent.MessageType == "m.image" || msgContent.MessageType == "m.file" || msgContent.MessageType == "m.audio" || msgContent.MessageType == "m.video")
+ matchingPolicies.AddRange(await CheckMedia(@event));
+ }
+
+ return matchingPolicies;
+ }
+
+#region Policy matching
+
+ private async Task<List<BasePolicy>> CheckMessageContent(StateEventResponse @event) {
+ var matchedRules = new List<BasePolicy>();
+ var msgContent = @event.TypedContent as RoomMessageEventContent;
+
+ if (ActivePoliciesByType.TryGetValue(nameof(MessagePolicyContainsText), out var messageContainsPolicies))
+ foreach (var policy in messageContainsPolicies) {
+ if ((@msgContent?.Body?.ToLowerInvariant().Contains(policy.Entity.ToLowerInvariant()) ?? false) ||
+ (@msgContent?.FormattedBody?.ToLowerInvariant().Contains(policy.Entity.ToLowerInvariant()) ?? false))
+ matchedRules.Add(policy);
+ }
+
+ return matchedRules;
+ }
+
+ private async Task<List<BasePolicy>> CheckMedia(StateEventResponse @event) {
+ var matchedRules = new List<BasePolicy>();
+ var hashAlgo = SHA3_256.Create();
+
+ var mxcUri = @event.RawContent["url"].GetValue<string>();
+
+ //check server policies before bothering with hashes
+ if (ActivePoliciesByType.TryGetValue(nameof(MediaPolicyHomeserver), out var mediaHomeserverPolicies))
+ foreach (var policy in mediaHomeserverPolicies) {
+ logger.LogInformation("Checking rule {rule}: {data}", policy.OriginalEvent.StateKey, policy.OriginalEvent.TypedContent.ToJson(ignoreNull: true, indent: false));
+ policy.Entity = policy.Entity.Replace("\\*", ".*").Replace("\\?", ".");
+ var regex = new Regex($"mxc://({policy.Entity})/.*", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+ if (regex.IsMatch(@event.RawContent["url"]!.GetValue<string>())) {
+ logger.LogInformation("{url} matched rule {rule}", @event.RawContent["url"], policy.ToJson(ignoreNull: true));
+ matchedRules.Add(policy);
+ // continue;
+ }
+ }
+
+ var resolvedUri = await hsResolver.ResolveMediaUri(mxcUri.Split('/')[2], mxcUri);
+ var uriHash = hashAlgo.ComputeHash(mxcUri.AsBytes().ToArray());
+ byte[]? fileHash = null;
+
+ try {
+ fileHash = await hashAlgo.ComputeHashAsync(await hs.ClientHttpClient.GetStreamAsync(resolvedUri));
+ }
+ catch (Exception ex) {
+ await _logRoom.SendMessageEventAsync(
+ MessageFormatter.FormatException($"Error calculating file hash for {mxcUri} via {mxcUri.Split('/')[2]} ({resolvedUri}), retrying via {hs.BaseUrl}...",
+ ex));
+ try {
+ resolvedUri = await hsResolver.ResolveMediaUri(hs.BaseUrl, mxcUri);
+ fileHash = await hashAlgo.ComputeHashAsync(await hs.ClientHttpClient.GetStreamAsync(resolvedUri));
+ }
+ catch (Exception ex2) {
+ await _logRoom.SendMessageEventAsync(
+ MessageFormatter.FormatException($"Error calculating file hash via {hs.BaseUrl} ({resolvedUri})!", ex2));
+ }
+ }
+
+ logger.LogInformation("Checking media {url} with hash {hash}", resolvedUri, fileHash);
+
+ if (ActivePoliciesByType.ContainsKey(nameof(MediaPolicyFile)))
+ foreach (MediaPolicyFile policy in ActivePoliciesByType[nameof(MediaPolicyFile)]) {
+ logger.LogInformation("Checking rule {rule}: {data}", policy.OriginalEvent.StateKey, policy.OriginalEvent.TypedContent.ToJson(ignoreNull: true, indent: false));
+ if (policy.Entity is not null && Convert.ToBase64String(uriHash).SequenceEqual(policy.Entity)) {
+ logger.LogInformation("{url} matched rule {rule} by uri hash", @event.RawContent["url"], policy.ToJson(ignoreNull: true));
+ matchedRules.Add(policy);
+ // continue;
+ }
+ else logger.LogInformation("uri hash {uriHash} did not match rule's {ruleUriHash}", Convert.ToHexString(uriHash), policy.Entity);
+
+ if (policy.FileHash is not null && fileHash is not null && policy.FileHash == Convert.ToBase64String(fileHash)) {
+ logger.LogInformation("{url} matched rule {rule} by file hash", @event.RawContent["url"], policy.ToJson(ignoreNull: true));
+ matchedRules.Add(policy);
+ // continue;
+ }
+ else logger.LogInformation("file hash {fileHash} did not match rule's {ruleFileHash}", Convert.ToBase64String(fileHash), policy.FileHash);
+
+ //check pixels every 10% of the way through the image using ImageSharp
+ // var image = Image.Load(await _hs._httpClient.GetStreamAsync(resolvedUri));
+ }
+ else logger.LogInformation("No active media file policies");
+ // logger.LogInformation("{url} did not match any rules", @event.RawContent["url"]);
+
+ return matchedRules;
+ }
+
+#endregion
+
+#region Internal code
+
+#region Summarisation
+
+ private static (string Raw, string Html) SummariseStateTypeCounts(IList<StateEventResponse> states) {
+ string raw = "Count | State type | Mapped type", html = "<table><tr><th>Count</th><th>State type</th><th>Mapped type</th></tr>";
+ var groupedStates = states.GroupBy(x => x.Type).ToDictionary(x => x.Key, x => x.ToList()).OrderByDescending(x => x.Value.Count);
+ foreach (var (type, stateGroup) in groupedStates) {
+ raw += $"\n{stateGroup.Count} | {type} | {stateGroup[0].MappedType.Name}";
+ html += $"<tr><td>{stateGroup.Count}</td><td>{type}</td><td>{stateGroup[0].MappedType.Name}</td></tr>";
+ }
+
+ html += "</table>";
+ return (raw, html);
+ }
+
+#endregion
+
+#endregion
+}
\ No newline at end of file
diff --git a/ModerationBot/PolicyList.cs b/ModerationBot/PolicyList.cs
new file mode 100644
index 0000000..f291c7b
--- /dev/null
+++ b/ModerationBot/PolicyList.cs
@@ -0,0 +1,16 @@
+using System.Text.Json.Serialization;
+using LibMatrix;
+using LibMatrix.RoomTypes;
+
+namespace ModerationBot;
+
+public class PolicyList {
+ [JsonIgnore]
+ public GenericRoom Room { get; set; }
+
+ [JsonPropertyName("trusted")]
+ public bool Trusted { get; set; } = false;
+
+ [JsonIgnore]
+ public List<StateEventResponse> Policies { get; set; } = new();
+}
diff --git a/ModerationBot/Program.cs b/ModerationBot/Program.cs
new file mode 100644
index 0000000..67403c1
--- /dev/null
+++ b/ModerationBot/Program.cs
@@ -0,0 +1,42 @@
+// See https://aka.ms/new-console-template for more information
+
+using LibMatrix.Services;
+using LibMatrix.Utilities.Bot;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using ModerationBot;
+using ModerationBot.Services;
+
+Console.WriteLine("Hello, World!");
+
+var builder = Host.CreateDefaultBuilder(args);
+
+builder.ConfigureHostOptions(host => {
+ host.ServicesStartConcurrently = true;
+ host.ServicesStopConcurrently = true;
+ host.ShutdownTimeout = TimeSpan.FromSeconds(5);
+});
+
+if (Environment.GetEnvironmentVariable("MODERATIONBOT_APPSETTINGS_PATH") is string path)
+ builder.ConfigureAppConfiguration(x => x.AddJsonFile(path));
+
+var host = builder.ConfigureServices((_, services) => {
+ services.AddScoped<TieredStorageService>(x =>
+ new TieredStorageService(
+ cacheStorageProvider: new FileStorageProvider("bot_data/cache/"),
+ dataStorageProvider: new FileStorageProvider("bot_data/data/")
+ )
+ );
+ services.AddSingleton<ModerationBotConfiguration>();
+
+ services.AddRoryLibMatrixServices();
+ services.AddMatrixBot().AddCommandHandler().DiscoverAllCommands();
+
+ services.AddSingleton<PolicyEngine>();
+ services.AddSingleton<ModerationBotRoomProvider>();
+
+ services.AddHostedService<ModerationBot.ModerationBot>();
+}).UseConsoleLifetime().Build();
+
+await host.RunAsync();
\ No newline at end of file
diff --git a/ModerationBot/Properties/launchSettings.json b/ModerationBot/Properties/launchSettings.json
new file mode 100644
index 0000000..997e294
--- /dev/null
+++ b/ModerationBot/Properties/launchSettings.json
@@ -0,0 +1,26 @@
+{
+ "$schema": "http://json.schemastore.org/launchsettings.json",
+ "profiles": {
+ "Default": {
+ "commandName": "Project",
+ "dotnetRunMessages": true,
+ "environmentVariables": {
+
+ }
+ },
+ "Development": {
+ "commandName": "Project",
+ "dotnetRunMessages": true,
+ "environmentVariables": {
+ "DOTNET_ENVIRONMENT": "Development"
+ }
+ },
+ "Local config": {
+ "commandName": "Project",
+ "dotnetRunMessages": true,
+ "environmentVariables": {
+ "DOTNET_ENVIRONMENT": "Local"
+ }
+ }
+ }
+}
diff --git a/ModerationBot/Services/ModerationBotRoomProvider.cs b/ModerationBot/Services/ModerationBotRoomProvider.cs
new file mode 100644
index 0000000..d4a200f
--- /dev/null
+++ b/ModerationBot/Services/ModerationBotRoomProvider.cs
@@ -0,0 +1,76 @@
+using System.Diagnostics.CodeAnalysis;
+using LibMatrix.Homeservers;
+using LibMatrix.Responses;
+using LibMatrix.RoomTypes;
+using ModerationBot.AccountData;
+
+namespace ModerationBot.Services;
+
+public class ModerationBotRoomProvider(AuthenticatedHomeserverGeneric hs, ModerationBotConfiguration cfg) {
+ private BotData? _botData;
+
+ public BotData? BotData {
+ get {
+ if (BotDataExpiry >= DateTime.UtcNow) return _botData;
+ Console.WriteLine("BotData expired!");
+ return null;
+ }
+ set {
+ _botData = value;
+ Console.WriteLine("BotData updated!");
+ BotDataExpiry = DateTime.UtcNow.AddMinutes(5);
+ }
+ }
+
+ private DateTime BotDataExpiry { get; set; }
+
+ [MemberNotNull(nameof(BotData))]
+ private async Task<BotData> GetBotDataAsync() {
+ try {
+ BotData ??= await hs.GetAccountDataAsync<BotData>(BotData.EventId);
+ }
+ catch (Exception e) {
+ Console.WriteLine(e);
+ await hs.SetAccountDataAsync(BotData.EventId, new BotData());
+ return await GetBotDataAsync();
+ }
+
+ if (BotData == null)
+ throw new NullReferenceException("BotData is null!");
+
+ return BotData;
+ }
+
+ public async Task<GenericRoom> GetControlRoomAsync() {
+ var botData = await GetBotDataAsync();
+ if (botData.ControlRoom == null) {
+ var createRoomRequest = CreateRoomRequest.CreatePrivate(hs, "Rory&::ModerationBot - Control Room");
+ createRoomRequest.Invite = cfg.Admins;
+ var newRoom = await hs.CreateRoom(createRoomRequest, true, true, true);
+ BotData.ControlRoom = newRoom.RoomId;
+ await hs.SetAccountDataAsync(BotData.EventId, BotData);
+ }
+
+ return hs.GetRoom(BotData.ControlRoom!);
+ }
+
+ public async Task<GenericRoom> GetLogRoomAsync() {
+ var botData = await GetBotDataAsync();
+ if (botData.LogRoom == null) {
+ var controlRoom = await GetControlRoomAsync();
+ var createRoomRequest = CreateRoomRequest.CreatePrivate(hs, "Rory&::ModerationBot - Log Room");
+ createRoomRequest.Invite = (await controlRoom.GetMembersListAsync()).Select(x=>x.StateKey).ToList();
+ var newRoom = await hs.CreateRoom(createRoomRequest, true, true, true);
+ BotData.LogRoom = newRoom.RoomId;
+ await hs.SetAccountDataAsync(BotData.EventId, BotData);
+ }
+
+ return hs.GetRoom(BotData.LogRoom!);
+ }
+
+ public async Task<GenericRoom?> GetDefaultPolicyRoomAsync() {
+ var botData = await GetBotDataAsync();
+
+ return string.IsNullOrWhiteSpace(botData.DefaultPolicyRoom) ? null : hs.GetRoom(BotData.DefaultPolicyRoom!);
+ }
+}
\ No newline at end of file
diff --git a/ModerationBot/StateEventTypes/Policies/BasePolicy.cs b/ModerationBot/StateEventTypes/Policies/BasePolicy.cs
new file mode 100644
index 0000000..64b0448
--- /dev/null
+++ b/ModerationBot/StateEventTypes/Policies/BasePolicy.cs
@@ -0,0 +1,53 @@
+using System.ComponentModel.DataAnnotations;
+using System.Text.Json.Serialization;
+using LibMatrix;
+using LibMatrix.EventTypes;
+using LibMatrix.Interfaces;
+
+namespace ModerationBot.StateEventTypes.Policies;
+
+public abstract class BasePolicy : EventContent {
+ /// <summary>
+ /// Entity this policy applies to, null if event was redacted
+ /// </summary>
+ [JsonPropertyName("entity")]
+ public string? Entity { get; set; }
+
+ /// <summary>
+ /// Reason this policy exists
+ /// </summary>
+ [JsonPropertyName("reason")]
+ public string? Reason { get; set; }
+
+ /// <summary>
+ /// Suggested action to take, one of `ban`, `kick`, `mute`, `redact`, `spoiler`, `warn` or `warn_admins`
+ /// </summary>
+ [JsonPropertyName("recommendation")]
+ [AllowedValues("ban", "kick", "mute", "redact", "spoiler", "warn", "warn_admins")]
+ public string Recommendation { get; set; } = "warn";
+
+ /// <summary>
+ /// Expiry time in milliseconds since the unix epoch, or null if the ban has no expiry.
+ /// </summary>
+ [JsonPropertyName("support.feline.policy.expiry.rev.2")] //stable prefix: expiry, msc pending
+ public long? Expiry { get; set; }
+
+ //utils
+ /// <summary>
+ /// Readable expiry time, provided for easy interaction
+ /// </summary>
+ [JsonPropertyName("gay.rory.matrix_room_utils.readable_expiry_time_utc")]
+ public DateTime? ExpiryDateTime {
+ get => Expiry == null ? null : DateTimeOffset.FromUnixTimeMilliseconds(Expiry.Value).DateTime;
+ set => Expiry = value is null ? null : ((DateTimeOffset)value).ToUnixTimeMilliseconds();
+ }
+
+ #region Internal metadata
+
+ [JsonIgnore]
+ public PolicyList PolicyList { get; set; }
+
+ public StateEventResponse OriginalEvent { get; set; }
+
+ #endregion
+}
diff --git a/ModerationBot/StateEventTypes/Policies/Implementations/MediaPolicyFile.cs b/ModerationBot/StateEventTypes/Policies/Implementations/MediaPolicyFile.cs
new file mode 100644
index 0000000..f0fef63
--- /dev/null
+++ b/ModerationBot/StateEventTypes/Policies/Implementations/MediaPolicyFile.cs
@@ -0,0 +1,16 @@
+using System.Text.Json.Serialization;
+using LibMatrix.EventTypes;
+
+namespace ModerationBot.StateEventTypes.Policies.Implementations;
+
+/// <summary>
+/// File policy event, entity is the MXC URI of the file, hashed with SHA3-256.
+/// </summary>
+[MatrixEvent(EventName = "gay.rory.moderation.rule.media")]
+public class MediaPolicyFile : BasePolicy {
+ /// <summary>
+ /// Hash of the file, hashed with SHA3-256.
+ /// </summary>
+ [JsonPropertyName("file_hash")]
+ public string? FileHash { get; set; }
+}
diff --git a/ModerationBot/StateEventTypes/Policies/Implementations/MediaPolicyHomeserver.cs b/ModerationBot/StateEventTypes/Policies/Implementations/MediaPolicyHomeserver.cs
new file mode 100644
index 0000000..72c9a60
--- /dev/null
+++ b/ModerationBot/StateEventTypes/Policies/Implementations/MediaPolicyHomeserver.cs
@@ -0,0 +1,10 @@
+using LibMatrix.EventTypes;
+
+namespace ModerationBot.StateEventTypes.Policies.Implementations;
+
+/// <summary>
+/// Homeserver media policy event, entity is the MXC URI of the file, hashed with SHA3-256.
+/// </summary>
+[MatrixEvent(EventName = "gay.rory.moderation.rule.media.homeserver")]
+public class MediaPolicyHomeserver : BasePolicy {
+}
diff --git a/ModerationBot/StateEventTypes/Policies/Implementations/MessagePolicyContainsText.cs b/ModerationBot/StateEventTypes/Policies/Implementations/MessagePolicyContainsText.cs
new file mode 100644
index 0000000..fa21e2d
--- /dev/null
+++ b/ModerationBot/StateEventTypes/Policies/Implementations/MessagePolicyContainsText.cs
@@ -0,0 +1,10 @@
+using LibMatrix.EventTypes;
+
+namespace ModerationBot.StateEventTypes.Policies.Implementations;
+
+/// <summary>
+/// Text contains policy event, entity is the text to contain.
+/// </summary>
+[MatrixEvent(EventName = "gay.rory.moderation.rule.text.contains")]
+public class MessagePolicyContainsText : BasePolicy {
+}
diff --git a/ModerationBot/StateEventTypes/Policies/Implementations/UnknownPolicy.cs b/ModerationBot/StateEventTypes/Policies/Implementations/UnknownPolicy.cs
new file mode 100644
index 0000000..78860ca
--- /dev/null
+++ b/ModerationBot/StateEventTypes/Policies/Implementations/UnknownPolicy.cs
@@ -0,0 +1,7 @@
+namespace ModerationBot.StateEventTypes.Policies.Implementations;
+
+/// <summary>
+/// Unknown policy event, usually used for handling unknown cases
+/// </summary>
+public class UnknownPolicy : BasePolicy {
+}
diff --git a/ModerationBot/appsettings.Development.json b/ModerationBot/appsettings.Development.json
new file mode 100644
index 0000000..224d0da
--- /dev/null
+++ b/ModerationBot/appsettings.Development.json
@@ -0,0 +1,24 @@
+{
+ "Logging": {
+ "LogLevel": {
+ "Default": "Debug",
+ "System": "Information",
+ "Microsoft": "Information"
+ }
+ },
+ "LibMatrixBot": {
+ // The homeserver to connect to
+ "Homeserver": "rory.gay",
+ // The access token to use
+ "AccessToken": "syt_xxxxxxxxxxxxxxxxx",
+ // The command prefix
+ "Prefix": "?"
+ },
+ "ModerationBot": {
+ // List of people who should be invited to the control room
+ "Admins": [
+ "@emma:conduit.rory.gay",
+ "@emma:rory.gay"
+ ]
+ }
+}
diff --git a/ModerationBot/appsettings.json b/ModerationBot/appsettings.json
new file mode 100644
index 0000000..6ba02f3
--- /dev/null
+++ b/ModerationBot/appsettings.json
@@ -0,0 +1,9 @@
+{
+ "Logging": {
+ "LogLevel": {
+ "Default": "Debug",
+ "System": "Information",
+ "Microsoft": "Information"
+ }
+ }
+}
|
