MRU->RMU, fixes, cleanup

7 files changed, 275 insertions, 0 deletions

diff --git a/MatrixUtils.Web/Classes/Constants/RoomConstants.cs b/MatrixUtils.Web/Classes/Constants/RoomConstants.cs
new file mode 100644
index 0000000..5df0d01
--- /dev/null
+++ b/MatrixUtils.Web/Classes/Constants/RoomConstants.cs
@@ -0,0 +1,6 @@
+namespace MatrixUtils.Web.Classes.Constants;
+
+public class RoomConstants {
+    public static readonly string[] DangerousRoomVersions = { "1", "8" };
+    public const string RecommendedRoomVersion = "10";
+}
diff --git a/MatrixUtils.Web/Classes/LocalStorageProviderService.cs b/MatrixUtils.Web/Classes/LocalStorageProviderService.cs
new file mode 100644
index 0000000..3803a17
--- /dev/null
+++ b/MatrixUtils.Web/Classes/LocalStorageProviderService.cs
@@ -0,0 +1,28 @@
+using Blazored.LocalStorage;
+using LibMatrix.Interfaces.Services;
+
+namespace MatrixUtils.Web.Classes;
+
+public class LocalStorageProviderService : IStorageProvider {
+    private readonly ILocalStorageService _localStorageService;
+
+    public LocalStorageProviderService(ILocalStorageService localStorageService) {
+        _localStorageService = localStorageService;
+    }
+
+    Task IStorageProvider.SaveAllChildrenAsync<T>(string key, T value) {
+        throw new NotImplementedException();
+    }
+
+    Task<T?> IStorageProvider.LoadAllChildrenAsync<T>(string key) where T : default => throw new NotImplementedException();
+
+    async Task IStorageProvider.SaveObjectAsync<T>(string key, T value) => await _localStorageService.SetItemAsync(key, value);
+
+    async Task<T?> IStorageProvider.LoadObjectAsync<T>(string key) where T : default => await _localStorageService.GetItemAsync<T>(key);
+
+    async Task<bool> IStorageProvider.ObjectExistsAsync(string key) => await _localStorageService.ContainKeyAsync(key);
+
+    async Task<List<string>> IStorageProvider.GetAllKeysAsync() => (await _localStorageService.KeysAsync()).ToList();
+
+    async Task IStorageProvider.DeleteObjectAsync(string key) => await _localStorageService.RemoveItemAsync(key);
+}
diff --git a/MatrixUtils.Web/Classes/RMUStorageWrapper.cs b/MatrixUtils.Web/Classes/RMUStorageWrapper.cs
new file mode 100644
index 0000000..31e7734
--- /dev/null
+++ b/MatrixUtils.Web/Classes/RMUStorageWrapper.cs
@@ -0,0 +1,98 @@
+using LibMatrix;
+using LibMatrix.Homeservers;
+using LibMatrix.Services;
+using Microsoft.AspNetCore.Components;
+
+namespace MatrixUtils.Web.Classes;
+
+public class RMUStorageWrapper(TieredStorageService storageService, HomeserverProviderService homeserverProviderService, NavigationManager navigationManager) {
+    public async Task<List<UserAuth>?> GetAllTokens() {
+        return await storageService.DataStorageProvider.LoadObjectAsync<List<UserAuth>>("rmu.tokens") ??
+               new List<UserAuth>();
+    }
+
+    public async Task<UserAuth?> GetCurrentToken() {
+        var currentToken = await storageService.DataStorageProvider.LoadObjectAsync<UserAuth>("token");
+        var allTokens = await GetAllTokens();
+        if (allTokens is null or { Count: 0 }) {
+            await SetCurrentToken(null);
+            return null;
+        }
+
+        if (currentToken is null) {
+            await SetCurrentToken(currentToken = allTokens[0]);
+        }
+
+        if (!allTokens.Any(x => x.AccessToken == currentToken.AccessToken)) {
+            await SetCurrentToken(currentToken = allTokens[0]);
+        }
+
+        return currentToken;
+    }
+
+    public async Task AddToken(UserAuth UserAuth) {
+        var tokens = await GetAllTokens() ?? new List<UserAuth>();
+
+        tokens.Add(UserAuth);
+        await storageService.DataStorageProvider.SaveObjectAsync("rmu.tokens", tokens);
+    }
+
+    private async Task<AuthenticatedHomeserverGeneric?> GetCurrentSession() {
+        var token = await GetCurrentToken();
+        if (token == null) {
+            return null;
+        }
+
+        return await homeserverProviderService.GetAuthenticatedWithToken(token.Homeserver, token.AccessToken, token.Proxy);
+    }
+
+    public async Task<AuthenticatedHomeserverGeneric?> GetSession(UserAuth userAuth) {
+        return await homeserverProviderService.GetAuthenticatedWithToken(userAuth.Homeserver, userAuth.AccessToken, userAuth.Proxy);
+    }
+
+    public async Task<AuthenticatedHomeserverGeneric?> GetCurrentSessionOrNavigate() {
+        AuthenticatedHomeserverGeneric? session = null;
+
+        try {
+            //catch if the token is invalid
+            session = await GetCurrentSession();
+        }
+        catch (MatrixException e) {
+            if (e.ErrorCode == "M_UNKNOWN_TOKEN") {
+                var token = await GetCurrentToken();
+                navigationManager.NavigateTo("/InvalidSession?ctx=" + token.AccessToken);
+                return null;
+            }
+
+            throw;
+        }
+
+        if (session is null) {
+            navigationManager.NavigateTo("/Login");
+        }
+
+        return session;
+    }
+
+    public class Settings {
+        public DeveloperSettings DeveloperSettings { get; set; } = new();
+    }
+
+    public class DeveloperSettings {
+        public bool EnableLogViewers { get; set; }
+        public bool EnableConsoleLogging { get; set; } = true;
+        public bool EnablePortableDevtools { get; set; }
+    }
+
+    public async Task RemoveToken(UserAuth auth) {
+        var tokens = await GetAllTokens();
+        if (tokens == null) {
+            return;
+        }
+
+        tokens.RemoveAll(x => x.AccessToken == auth.AccessToken);
+        await storageService.DataStorageProvider.SaveObjectAsync("rmu.tokens", tokens);
+    }
+
+    public async Task SetCurrentToken(UserAuth? auth) => await storageService.DataStorageProvider.SaveObjectAsync("token", auth);
+}
diff --git a/MatrixUtils.Web/Classes/RoomCreationTemplates/DefaultRoomCreationTemplate.cs b/MatrixUtils.Web/Classes/RoomCreationTemplates/DefaultRoomCreationTemplate.cs
new file mode 100644
index 0000000..a627a9c
--- /dev/null
+++ b/MatrixUtils.Web/Classes/RoomCreationTemplates/DefaultRoomCreationTemplate.cs
@@ -0,0 +1,92 @@
+using System.Text.Json.Nodes;
+using LibMatrix;
+using LibMatrix.EventTypes.Spec.State;
+using LibMatrix.EventTypes.Spec.State.RoomInfo;
+using LibMatrix.Responses;
+
+namespace MatrixUtils.Web.Classes.RoomCreationTemplates;
+
+public class DefaultRoomCreationTemplate : IRoomCreationTemplate {
+    public string Name => "Default";
+
+    public CreateRoomRequest CreateRoomRequest =>
+        new() {
+            Name = "My new room",
+            RoomAliasName = "myroom",
+            InitialState = new List<StateEvent> {
+                new() {
+                    Type = "m.room.history_visibility",
+                    TypedContent = new RoomHistoryVisibilityEventContent() {
+                        HistoryVisibility = "world_readable"
+                    }
+                },
+                new() {
+                    Type = "m.room.guest_access",
+                    TypedContent = new RoomGuestAccessEventContent {
+                        GuestAccess = "can_join"
+                    }
+                },
+                new() {
+                    Type = "m.room.join_rules",
+                    TypedContent = new RoomJoinRulesEventContent {
+                        JoinRule = RoomJoinRulesEventContent.JoinRules.Public
+                    }
+                },
+                new() {
+                    Type = "m.room.server_acl",
+                    TypedContent = new RoomServerACLEventContent() {
+                        Allow = new List<string>() { "*" },
+                        Deny = new List<string>(),
+                        AllowIpLiterals = false
+                    }
+                },
+                new() {
+                    Type = "m.room.avatar",
+                    TypedContent = new RoomAvatarEventContent {
+                        Url = "mxc://feline.support/UKNhEyrVsrAbYteVvZloZcFj"
+                    }
+                }
+            },
+            Visibility = "public",
+            PowerLevelContentOverride = new RoomPowerLevelEventContent {
+                UsersDefault = 0,
+                EventsDefault = 100,
+                StateDefault = 50,
+                Invite = 0,
+                Redact = 50,
+                Kick = 50,
+                Ban = 50,
+                NotificationsPl = new RoomPowerLevelEventContent.NotificationsPL {
+                    Room = 50
+                },
+                Events = new() {
+                    { "im.vector.modular.widgets", 50 },
+                    { "io.element.voice_broadcast_info", 50 },
+                    { "m.reaction", 100 },
+                    { "m.room.avatar", 50 },
+                    { "m.room.canonical_alias", 50 },
+                    { "m.room.encryption", 100 },
+                    { "m.room.history_visibility", 100 },
+                    { "m.room.name", 50 },
+                    { "m.room.pinned_events", 50 },
+                    { "m.room.power_levels", 100 },
+                    { "m.room.redaction", 100 },
+                    { "m.room.server_acl", 100 },
+                    { "m.room.tombstone", 100 },
+                    { "m.room.topic", 50 },
+                    { "m.space.child", 50 },
+                    { "org.matrix.msc3401.call", 50 },
+                    { "org.matrix.msc3401.call.member", 50 }
+                },
+                Users = new() {
+                    // { RuntimeCache.CurrentHomeserver.UserId, 100 }
+                    //TODO: re-implement this
+                }
+            },
+            CreationContent = new JsonObject {
+                {
+                    "type", null
+                }
+            }
+        };
+}
diff --git a/MatrixUtils.Web/Classes/RoomCreationTemplates/IRoomCreationTemplate.cs b/MatrixUtils.Web/Classes/RoomCreationTemplates/IRoomCreationTemplate.cs
new file mode 100644
index 0000000..49aee73
--- /dev/null
+++ b/MatrixUtils.Web/Classes/RoomCreationTemplates/IRoomCreationTemplate.cs
@@ -0,0 +1,8 @@
+using LibMatrix.Responses;
+
+namespace MatrixUtils.Web.Classes.RoomCreationTemplates;
+
+public interface IRoomCreationTemplate {
+    public CreateRoomRequest CreateRoomRequest { get; }
+    public string Name { get; }
+}
diff --git a/MatrixUtils.Web/Classes/SessionStorageProviderService.cs b/MatrixUtils.Web/Classes/SessionStorageProviderService.cs
new file mode 100644
index 0000000..ae0bb79
--- /dev/null
+++ b/MatrixUtils.Web/Classes/SessionStorageProviderService.cs
@@ -0,0 +1,28 @@
+using Blazored.SessionStorage;
+using LibMatrix.Interfaces.Services;
+
+namespace MatrixUtils.Web.Classes;
+
+public class SessionStorageProviderService : IStorageProvider {
+    private readonly ISessionStorageService _sessionStorageService;
+
+    public SessionStorageProviderService(ISessionStorageService sessionStorage) {
+        _sessionStorageService = sessionStorage;
+    }
+
+    Task IStorageProvider.SaveAllChildrenAsync<T>(string key, T value) {
+        throw new NotImplementedException();
+    }
+
+    Task<T?> IStorageProvider.LoadAllChildrenAsync<T>(string key) where T : default => throw new NotImplementedException();
+
+    async Task IStorageProvider.SaveObjectAsync<T>(string key, T value) => await _sessionStorageService.SetItemAsync(key, value);
+
+    async Task<T?> IStorageProvider.LoadObjectAsync<T>(string key) where T : default => await _sessionStorageService.GetItemAsync<T>(key);
+
+    async Task<bool> IStorageProvider.ObjectExistsAsync(string key) => await _sessionStorageService.ContainKeyAsync(key);
+
+    async Task<List<string>> IStorageProvider.GetAllKeysAsync() => (await _sessionStorageService.KeysAsync()).ToList();
+
+    async Task IStorageProvider.DeleteObjectAsync(string key) => await _sessionStorageService.RemoveItemAsync(key);
+}
diff --git a/MatrixUtils.Web/Classes/UserAuth.cs b/MatrixUtils.Web/Classes/UserAuth.cs
new file mode 100644
index 0000000..66476ae
--- /dev/null
+++ b/MatrixUtils.Web/Classes/UserAuth.cs
@@ -0,0 +1,15 @@
+using LibMatrix.Responses;
+
+namespace MatrixUtils.Web.Classes;
+
+public class UserAuth : LoginResponse {
+    public UserAuth() { }
+    public UserAuth(LoginResponse login) {
+        Homeserver = login.Homeserver;
+        UserId = login.UserId;
+        AccessToken = login.AccessToken;
+        DeviceId = login.DeviceId;
+    }
+
+    public string? Proxy { get; set; }
+}