Refactor workspace name

Needlework.Net/ViewModels/AboutViewModel.cs

@@ -0,0 +1,9 @@
+namespace Needlework.Net.ViewModels
+{
+    public class AboutViewModel : PageBase
+    {
+        public AboutViewModel() : base("About", "info-circle")
+        {
+        }
+    }
+}

Needlework.Net/ViewModels/ConsoleViewModel.cs

@@ -0,0 +1,102 @@
+using Avalonia.Collections;
+using BlossomiShymae.GrrrLCU;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Needlework.Net.Messages;
+using Needlework.Net.Services;
+using System;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class ConsoleViewModel : PageBase, IRecipient<DataReadyMessage>
+    {
+        public IAvaloniaReadOnlyList<string> RequestMethods { get; } = new AvaloniaList<string>(["GET", "POST", "PUT", "DELETE", "HEAD", "PATCH", "OPTIONS", "TRACE"]);
+        public IAvaloniaList<string> RequestPaths { get; } = new AvaloniaList<string>();
+
+        [ObservableProperty] private bool _isBusy = true;
+        [ObservableProperty] private bool _isRequestBusy = false;
+        [ObservableProperty] private string? _requestMethodSelected = "GET";
+        [ObservableProperty] private string? _requestPath = null;
+        [ObservableProperty] private string? _requestBody = null;
+        [ObservableProperty] private string? _responsePath = null;
+        [ObservableProperty] private string? _responseStatus = null;
+        [ObservableProperty] private string? _responseAuthorization = null;
+
+        public WindowService WindowService { get; }
+
+        public ConsoleViewModel(WindowService windowService) : base("Console", "terminal", -200)
+        {
+            WindowService = windowService;
+
+            WeakReferenceMessenger.Default.Register<DataReadyMessage>(this);
+        }
+
+        [RelayCommand]
+        private async Task SendRequest()
+        {
+            try
+            {
+                IsRequestBusy = true;
+                if (string.IsNullOrEmpty(RequestPath)) throw new Exception("Path is empty.");
+
+                var method = RequestMethodSelected switch
+                {
+                    "GET" => HttpMethod.Get,
+                    "POST" => HttpMethod.Post,
+                    "PUT" => HttpMethod.Put,
+                    "DELETE" => HttpMethod.Delete,
+                    "HEAD" => HttpMethod.Head,
+                    "PATCH" => HttpMethod.Patch,
+                    "OPTIONS" => HttpMethod.Options,
+                    "TRACE" => HttpMethod.Trace,
+                    _ => throw new Exception("Method is not selected."),
+                };
+
+                var processInfo = Connector.GetProcessInfo();
+                var requestBody = WeakReferenceMessenger.Default.Send(new ContentRequestMessage(), "ConsoleRequestEditor").Response;
+                var content = new StringContent(requestBody, new System.Net.Http.Headers.MediaTypeHeaderValue("application/json"));
+                var response = await Connector.SendAsync(method, RequestPath, content);
+                var riotAuthentication = new RiotAuthentication(processInfo.RemotingAuthToken);
+                var responseBody = await response.Content.ReadAsByteArrayAsync();
+  
+                var body = responseBody.Length > 0 ? JsonSerializer.Serialize(JsonSerializer.Deserialize<object>(responseBody), App.JsonSerializerOptions) : string.Empty;
+                if (body.Length >= App.MaxCharacters)
+                {
+                    WindowService.ShowOopsiesWindow(body);
+                    WeakReferenceMessenger.Default.Send(new ResponseUpdatedMessage(string.Empty), nameof(ConsoleViewModel));
+                }
+                else WeakReferenceMessenger.Default.Send(new ResponseUpdatedMessage(body), nameof(ConsoleViewModel));
+               
+                ResponseStatus = $"{(int)response.StatusCode} {response.StatusCode.ToString()}";
+                ResponsePath = $"https://127.0.0.1:{processInfo.AppPort}{RequestPath}";
+                ResponseAuthorization = $"Basic {riotAuthentication.Value}";
+            }
+            catch (Exception ex)
+            {
+                WeakReferenceMessenger.Default.Send(new InfoBarUpdateMessage(new InfoBarViewModel("Request Failed", true, ex.Message, FluentAvalonia.UI.Controls.InfoBarSeverity.Error, TimeSpan.FromSeconds(5))));
+                ResponseStatus = null;
+                ResponsePath = null;
+                ResponseAuthorization = null;
+                WeakReferenceMessenger.Default.Send(new ResponseUpdatedMessage(string.Empty), nameof(ConsoleViewModel));
+            }
+            finally
+            {
+                IsRequestBusy = false;
+            }
+        }
+
+        public void Receive(DataReadyMessage message)
+        {
+            Avalonia.Threading.Dispatcher.UIThread.Invoke(() =>
+            {
+                RequestPaths.Clear();
+                RequestPaths.AddRange(message.Value.Paths);
+                IsBusy = false;
+            });
+        }
+    }
+}

Needlework.Net/ViewModels/EndpointViewModel.cs

@@ -0,0 +1,50 @@
+using Avalonia.Collections;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Needlework.Net.Messages;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class EndpointViewModel : ObservableObject
+    {
+        public string Endpoint { get; }
+        public string Title => Endpoint;
+
+
+        public IAvaloniaReadOnlyList<PathOperationViewModel> PathOperations { get; }
+        [ObservableProperty] private PathOperationViewModel? _selectedPathOperation;
+
+        [ObservableProperty] private string? _search;
+        public IAvaloniaList<PathOperationViewModel> FilteredPathOperations { get; }
+
+        public EndpointViewModel(string endpoint)
+        {
+            Endpoint = endpoint;
+
+            var handler = WeakReferenceMessenger.Default.Send<DataRequestMessage>().Response;
+            PathOperations = new AvaloniaList<PathOperationViewModel>(handler.Plugins[endpoint].Select(x => new PathOperationViewModel(x)));
+            FilteredPathOperations = new AvaloniaList<PathOperationViewModel>(PathOperations);
+        }
+
+        partial void OnSearchChanged(string? value)
+        {
+            FilteredPathOperations.Clear();
+
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                FilteredPathOperations.AddRange(PathOperations);
+                return;
+            }
+            FilteredPathOperations.AddRange(PathOperations.Where(o => o.Path.Contains(value, StringComparison.InvariantCultureIgnoreCase)));
+        }
+
+        partial void OnSelectedPathOperationChanged(PathOperationViewModel? value)
+        {
+            if (value == null) return;
+            WeakReferenceMessenger.Default.Send(new EditorUpdateMessage(new(value.Operation.RequestTemplate ?? string.Empty, "EndpointRequestEditor")));
+        }
+    }
+}

Needlework.Net/ViewModels/EndpointsContainerViewModel.cs

@@ -0,0 +1,31 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using System.Net.Http;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class EndpointsContainerViewModel : PageBase
+    {
+        [ObservableProperty] private ObservableObject _activeViewModel;
+        [ObservableProperty] private ObservableObject _endpointsViewModel;
+        [ObservableProperty] private string _title = string.Empty;
+
+        public EndpointsContainerViewModel(HttpClient httpClient) : base("Endpoints", "list-alt", -500)
+        {
+            _activeViewModel = _endpointsViewModel = new EndpointsViewModel(httpClient, OnClicked);
+        }
+
+        private void OnClicked(ObservableObject viewModel)
+        {
+            ActiveViewModel = viewModel;
+            if (viewModel is EndpointViewModel endpoint) Title = endpoint.Title;
+        }
+
+        [RelayCommand]
+        private void GoBack()
+        {
+            ActiveViewModel = EndpointsViewModel;
+            Title = string.Empty;
+        }
+    }
+}

Needlework.Net/ViewModels/EndpointsViewModel.cs

@@ -0,0 +1,59 @@
+using Avalonia.Collections;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Needlework.Net.Messages;
+using System;
+using System.Linq;
+using System.Net.Http;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class EndpointsViewModel : ObservableObject, IRecipient<DataReadyMessage>
+    {
+        public HttpClient HttpClient { get; }
+
+        public string Title => "Endpoints";
+        public Action<ObservableObject> OnClicked;
+        public IAvaloniaList<string> Plugins { get; } = new AvaloniaList<string>();
+        public IAvaloniaList<string> Query { get; } = new AvaloniaList<string>();
+
+        [ObservableProperty] private bool _isBusy = true;
+        [ObservableProperty] private string _search = string.Empty;
+        [ObservableProperty] private string? _selectedQuery = string.Empty;
+
+        public EndpointsViewModel(HttpClient httpClient, Action<ObservableObject> onClicked)
+        {
+            HttpClient = httpClient;
+            OnClicked = onClicked;
+
+            WeakReferenceMessenger.Default.Register(this);
+        }
+
+        public void Receive(DataReadyMessage message)
+        {
+            IsBusy = false;
+            Plugins.Clear();
+            Plugins.AddRange(message.Value.Plugins.Keys);
+            Query.Clear();
+            Query.AddRange(Plugins);
+        }
+
+        partial void OnSearchChanged(string value)
+        {
+            Query.Clear();
+            if (!string.IsNullOrEmpty(Search))
+                Query.AddRange(Plugins.Where(x => x.Contains(value, StringComparison.InvariantCultureIgnoreCase)));
+            else
+                Query.AddRange(Plugins);
+        }
+
+        [RelayCommand]
+        private void OpenEndpoint(string? value)
+        {
+            if (string.IsNullOrEmpty(value)) return;
+
+            OnClicked.Invoke(new EndpointViewModel(value));
+        }
+    }
+}

Needlework.Net/ViewModels/HomeViewModel.cs

@@ -0,0 +1,20 @@
+using CommunityToolkit.Mvvm.Input;
+using System.Diagnostics;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class HomeViewModel : PageBase
+    {
+        public HomeViewModel() : base("Home", "home", int.MinValue) { }
+
+        [RelayCommand]
+        private void OpenUrl(string url)
+        {
+            var process = new Process()
+            {
+                StartInfo = new ProcessStartInfo(url) { UseShellExecute = true }
+            };
+            process.Start();
+        }
+    }
+}

Needlework.Net/ViewModels/InfoBarViewModel.cs

@@ -0,0 +1,27 @@
+using Avalonia.Controls;
+using CommunityToolkit.Mvvm.ComponentModel;
+using FluentAvalonia.UI.Controls;
+using System;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class InfoBarViewModel : ObservableObject
+    {
+        [ObservableProperty] private string _title;
+        [ObservableProperty] private bool _isOpen;
+        [ObservableProperty] private string _message;
+        [ObservableProperty] private InfoBarSeverity _severity;
+        [ObservableProperty] private TimeSpan _duration;
+        [ObservableProperty] private Control? _actionButton;
+
+        public InfoBarViewModel(string title, bool isOpen, string message, InfoBarSeverity severity, TimeSpan duration, Control? actionButton = null)
+        {
+            _title = title;
+            _isOpen = isOpen;
+            _message = message;
+            _severity = severity;
+            _duration = duration;
+            _actionButton = actionButton;
+        }
+    }
+}

Needlework.Net/ViewModels/MainWindowViewModel.cs

@@ -0,0 +1,155 @@
+using Avalonia.Collections;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using FluentAvalonia.UI.Controls;
+using Microsoft.OpenApi.Models;
+using Needlework.Net.Core;
+using Needlework.Net.Messages;
+using Needlework.Net.Services;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class MainWindowViewModel : ObservableObject, IRecipient<DataRequestMessage>, IRecipient<HostDocumentRequestMessage>, IRecipient<OopsiesWindowRequestedMessage>, IRecipient<InfoBarUpdateMessage>
+    {
+        public IAvaloniaReadOnlyList<NavigationViewItem> MenuItems { get; }
+        [NotifyPropertyChangedFor(nameof(CurrentPage))]
+        [ObservableProperty] private NavigationViewItem _selectedMenuItem;
+        public PageBase CurrentPage => (PageBase)SelectedMenuItem.Tag!;
+
+        public string Version { get; } = Assembly.GetEntryAssembly()?.GetName().Version?.ToString() ?? "0.0.0.0";
+        [ObservableProperty] private bool _isUpdateShown = false;
+
+        public HttpClient HttpClient { get; }
+        public WindowService WindowService { get; }
+        public LcuSchemaHandler? LcuSchemaHandler { get; set; }
+        public OpenApiDocument? HostDocument { get; set; }
+
+        [ObservableProperty] private bool _isBusy = true;
+
+        [ObservableProperty] private ObservableCollection<InfoBarViewModel> _infoBarItems = [];
+
+        public MainWindowViewModel(IEnumerable<PageBase> pages, HttpClient httpClient, WindowService windowService)
+        {
+            MenuItems = new AvaloniaList<NavigationViewItem>(pages
+                .OrderBy(p => p.Index)
+                .ThenBy(p => p.DisplayName)
+                .Select(p => new NavigationViewItem()
+                {
+                    Content = p.DisplayName,
+                    Tag = p,
+                    IconSource = new BitmapIconSource() { UriSource = new Uri($"avares://NeedleworkDotNet/Assets/Icons/{p.Icon}.png") }
+                }));
+            SelectedMenuItem = MenuItems[0];
+
+            HttpClient = httpClient;
+            WindowService = windowService;
+
+            WeakReferenceMessenger.Default.RegisterAll(this);
+
+            Task.Run(FetchDataAsync);
+            new Thread(ProcessEvents) { IsBackground = true }.Start();
+        }
+
+        private void ProcessEvents(object? obj)
+        {
+            while (!IsUpdateShown)
+            {
+                Task.Run(CheckLatestVersionAsync);
+
+                Thread.Sleep(TimeSpan.FromSeconds(60));
+            }
+        }
+
+        private async Task CheckLatestVersionAsync()
+        {
+            try
+            {
+                var request = new HttpRequestMessage(HttpMethod.Get, "https://api.github.com/repos/BlossomiShymae/Needlework.Net/releases/latest");
+                request.Headers.UserAgent.Add(new System.Net.Http.Headers.ProductInfoHeaderValue("Needlework.Net", Version));
+
+                var response = await HttpClient.SendAsync(request);
+                var release = await response.Content.ReadFromJsonAsync<GithubRelease>();
+                if (release == null) return;
+
+                var currentVersion = int.Parse(Version.Replace(".", ""));
+
+                if (release.IsLatest(currentVersion))
+                {
+                    Avalonia.Threading.Dispatcher.UIThread.Post(async () =>
+                    {
+                        await ShowInfoBarAsync(new("Needlework.Net Update", true, $"There is a new version available: {release.TagName}.", InfoBarSeverity.Informational, TimeSpan.FromSeconds(10), new Avalonia.Controls.Button()
+                        {
+                            Command = OpenUrlCommand,
+                            CommandParameter = "https://github.com/BlossomiShymae/Needlework.Net/releases",
+                            Content = "Download"
+                        }));
+                        IsUpdateShown = true;
+                    });
+                }
+            }
+            catch (Exception) { }
+        }
+
+        private async Task FetchDataAsync()
+        {
+            var document = await Resources.GetOpenApiDocumentAsync(HttpClient);
+            HostDocument = document;
+            var handler = new LcuSchemaHandler(document);
+            LcuSchemaHandler = handler;
+
+            WeakReferenceMessenger.Default.Send(new DataReadyMessage(handler));
+            IsBusy = false;
+        }
+
+        public void Receive(DataRequestMessage message)
+        {
+            message.Reply(LcuSchemaHandler!);
+        }
+
+        public void Receive(HostDocumentRequestMessage message)
+        {
+            message.Reply(HostDocument!);
+        }
+
+        [RelayCommand]
+        private void OpenUrl(string url)
+        {
+            var process = new Process()
+            {
+                StartInfo = new ProcessStartInfo(url)
+                {
+                    UseShellExecute = true
+                }
+            };
+            process.Start();
+        }
+
+        public void Receive(OopsiesWindowRequestedMessage message)
+        {
+            WindowService.ShowOopsiesWindow(message.Value);
+        }
+
+        public void Receive(InfoBarUpdateMessage message)
+        {
+            Avalonia.Threading.Dispatcher.UIThread.Post(async () => await ShowInfoBarAsync(message.Value));
+        }
+
+        private async Task ShowInfoBarAsync(InfoBarViewModel vm)
+        {
+            InfoBarItems.Add(vm);
+            await Task.Delay(vm.Duration);
+            InfoBarItems.Remove(vm);
+        }
+    }
+}

Needlework.Net/ViewModels/OopsiesWindowViewModel.cs

@@ -0,0 +1,29 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Needlework.Net.Messages;
+using System.Diagnostics;
+using System.IO;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class OopsiesWindowViewModel(string text) : ObservableObject
+    {
+        public string Text { get; } = text;
+
+        [RelayCommand]
+        private void OpenDefaultEditor()
+        {
+            var temp = Path.GetTempFileName().Replace(".tmp", ".json");
+            File.WriteAllText(temp, Text);
+            Process.Start("explorer", "\"" + temp + "\"");
+            CloseDialog();
+        }
+
+        [RelayCommand]
+        private void CloseDialog()
+        {
+            WeakReferenceMessenger.Default.Send(new OopsiesWindowCanceledMessage(null));
+        }
+    }
+}

Needlework.Net/ViewModels/OperationViewModel.cs

@@ -0,0 +1,233 @@
+using Avalonia.Collections;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.OpenApi.Models;
+using Needlework.Net.Messages;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class OperationViewModel : ObservableObject
+    {
+        public string Summary { get; }
+        public string Description { get; }
+        public string ReturnType { get; }
+        public bool IsRequestBody { get; }
+        public string? RequestBodyType { get; }
+        public IAvaloniaReadOnlyList<PropertyClassViewModel> RequestClasses { get; }
+        public IAvaloniaReadOnlyList<PropertyClassViewModel> ResponseClasses { get; }
+        public IAvaloniaReadOnlyList<ParameterViewModel> PathParameters { get; }
+        public IAvaloniaReadOnlyList<ParameterViewModel> QueryParameters { get; }
+        public string? RequestTemplate { get; }
+
+        public OperationViewModel(OpenApiOperation operation)
+        {
+            Summary = operation.Summary ?? string.Empty;
+            Description = operation.Description ?? string.Empty;
+            IsRequestBody = operation.RequestBody != null;
+            ReturnType = GetReturnType(operation.Responses);
+            RequestClasses = GetRequestClasses(operation.RequestBody);
+            ResponseClasses = GetResponseClasses(operation.Responses);
+            PathParameters = GetParameters(operation.Parameters, ParameterLocation.Path);
+            QueryParameters = GetParameters(operation.Parameters, ParameterLocation.Query);
+            RequestBodyType = GetRequestBodyType(operation.RequestBody);
+            RequestTemplate = GetRequestTemplate(operation.RequestBody);
+        }
+
+        private string? GetRequestTemplate(OpenApiRequestBody? requestBody)
+        {
+            var requestClasses = GetRequestClasses(requestBody);
+            if (requestClasses.Count == 0)
+            {
+                var type = GetRequestBodyType(requestBody);
+                if (type == null) return null;
+                return GetRequestDefaultValue(type);
+            }
+
+            var template = CreateTemplate(requestClasses);
+            return JsonSerializer.Serialize(JsonSerializer.Deserialize<object>(string.Join(string.Empty, template)), App.JsonSerializerOptions);
+        }
+
+        private List<string> CreateTemplate(AvaloniaList<PropertyClassViewModel> requestClasses)
+        {
+            if (requestClasses.Count == 0) return [];
+            List<string> template = [];
+            template.Add("{");
+
+            var rootClass = requestClasses.First();
+            if (rootClass.PropertyEnums.Any()) return [rootClass.PropertyEnums.First().Values];
+            var propertyFields = rootClass.PropertyFields;
+            for (int i = 0; i < propertyFields.Count; i++)
+            {
+                template.Add($"\"{propertyFields[i].Name}\"");
+                template.Add(":");
+                template.Add($"#{propertyFields[i].Type}");
+
+                if (i == propertyFields.Count - 1) template.Add("}");
+                else template.Add(",");
+            }
+
+            for (int i = 0; i < template.Count; i++)
+            {
+                var type = template[i];
+                if (!type.Contains("#")) continue;
+
+                var foundClass = requestClasses.Where(c => c.Id == type.Replace("#", string.Empty));
+                if (foundClass.Any())
+                {
+                    if (foundClass.First().PropertyEnums.Any())
+                    {
+                        template[i] = string.Join(string.Empty, CreateTemplate([.. foundClass]));
+                    }
+                    else
+                    {
+                        AvaloniaList<PropertyClassViewModel> classes = [.. requestClasses];
+                        classes.Remove(rootClass);
+                        template[i] = string.Join(string.Empty, CreateTemplate(classes));
+                    }
+                }
+                else
+                {
+                    template[i] = GetRequestDefaultValue(type);
+                }
+            }
+
+            return template;
+        }
+
+        private static string GetRequestDefaultValue(string type)
+        {
+            var defaultValue = string.Empty;
+            if (type.Contains("[]")) defaultValue = "[]";
+            else if (type.Contains("string")) defaultValue = "\"\"";
+            else if (type.Contains("boolean")) defaultValue = "false";
+            else if (type.Contains("integer")) defaultValue = "0";
+            else if (type.Contains("double") || type.Contains("float")) defaultValue = "0.0";
+            else if (type.Contains("object")) defaultValue = "{}";
+            return defaultValue;
+        }
+
+        private string? GetRequestBodyType(OpenApiRequestBody? requestBody)
+        {
+            if (requestBody == null) return null;
+            if (requestBody.Content.TryGetValue("application/json", out var media))
+            {
+                var schema = media.Schema;
+                if (schema == null) return null; // Because "PostLolAccountVerificationV1SendDeactivationPin" exists where the media body is empty...
+                return GetSchemaType(schema);
+            }
+            return null;
+        }
+
+        private AvaloniaList<ParameterViewModel> GetParameters(IList<OpenApiParameter> parameters, ParameterLocation location)
+        {
+            var pathParameters = new AvaloniaList<ParameterViewModel>();
+            foreach (var parameter in parameters)
+            {
+                if (parameter.In != location) continue;
+                pathParameters.Add(new ParameterViewModel(parameter.Name, GetSchemaType(parameter.Schema), parameter.Required));
+            }
+
+            return pathParameters;
+        }
+
+        private AvaloniaList<PropertyClassViewModel> GetResponseClasses(OpenApiResponses responses)
+        {
+            if (responses.TryGetValue("2XX", out var response)
+                && response.Content.TryGetValue("application/json", out var media))
+            {
+                var document = WeakReferenceMessenger.Default.Send(new HostDocumentRequestMessage()).Response;
+                var schema = media.Schema;
+                AvaloniaList<PropertyClassViewModel> propertyClasses = [];
+                WalkSchema(schema, propertyClasses, document);
+                return propertyClasses;
+            }
+            return [];
+        }
+
+        private void WalkSchema(OpenApiSchema schema, AvaloniaList<PropertyClassViewModel> propertyClasses, OpenApiDocument document)
+        {
+            var type = GetSchemaType(schema);
+            if (IsComponent(type))
+            {
+                string componentId = GetComponentId(schema);
+                var componentSchema = document.Components.Schemas[componentId];
+                var responseClass = new PropertyClassViewModel(componentId, componentSchema.Properties, componentSchema.Enum);
+
+                if (propertyClasses.Where(c => c.Id == componentId).Any()) return; // Avoid adding duplicate schemas in classes
+                propertyClasses.Add(responseClass);
+
+                foreach ((var _, var property) in componentSchema.Properties)
+                    // Check for self-references like "LolLootLootOddsResponse"
+                    // I blame dubble
+                    if (IsComponent(GetSchemaType(property)) && componentId != GetComponentId(property))
+                        WalkSchema(property, propertyClasses, document);
+            }
+        }
+
+        private static string GetComponentId(OpenApiSchema schema)
+        {
+            string componentId;
+            if (schema.Reference != null) componentId = schema.Reference.Id;
+            else if (schema.Items != null) componentId = schema.Items.Reference.Id;
+            else componentId = schema.AdditionalProperties.Reference.Id;
+            return componentId;
+        }
+
+        private static bool IsComponent(string type)
+        {
+            return !(type.Contains("object")
+                                || type.Contains("array")
+                                || type.Contains("bool")
+                                || type.Contains("string")
+                                || type.Contains("integer")
+                                || type.Contains("number"));
+        }
+
+        private AvaloniaList<PropertyClassViewModel> GetRequestClasses(OpenApiRequestBody? requestBody)
+        {
+            if (requestBody == null) return [];
+            if (requestBody.Content.TryGetValue("application/json", out var media))
+            {
+                var document = WeakReferenceMessenger.Default.Send(new HostDocumentRequestMessage()).Response;
+                var schema = media.Schema;
+                if (schema == null) return [];
+
+                var type = GetSchemaType(media.Schema);
+                if (IsComponent(type))
+                {
+                    var componentId = GetComponentId(schema);
+                    var componentSchema = document.Components.Schemas[componentId];
+                    AvaloniaList<PropertyClassViewModel> propertyClasses = [];
+                    WalkSchema(componentSchema, propertyClasses, document);
+                    return propertyClasses;
+                }
+            }
+            return [];
+        }
+
+        private string GetReturnType(OpenApiResponses responses)
+        {
+            if (responses.TryGetValue("2XX", out var response)
+                && response.Content.TryGetValue("application/json", out var media))
+            {
+                var schema = media.Schema;
+                return GetSchemaType(schema);
+            }
+            return "none";
+        }
+
+        public static string GetSchemaType(OpenApiSchema schema)
+        {
+            if (schema.Reference != null) return schema.Reference.Id;
+            if (schema.Type == "object" && schema.AdditionalProperties?.Reference != null) return schema.AdditionalProperties.Reference.Id;
+            if (schema.Type == "integer" || schema.Type == "number") return $"{schema.Type}:{schema.Format}";
+            if (schema.Type == "array" && schema.Items.Reference != null) return $"{schema.Items.Reference.Id}[]";
+            if (schema.Type == "array" && (schema.Items.Type == "integer" || schema.Items.Type == "number")) return $"{schema.Items.Type}:{schema.Items.Format}[]";
+            if (schema.Type == "array") return $"{schema.Items.Type}[]";
+            return schema.Type;
+        }
+    }
+}

Needlework.Net/ViewModels/PageBase.cs

@@ -0,0 +1,12 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace Needlework.Net.ViewModels
+{
+
+    public abstract partial class PageBase(string displayName, string icon, int index = 0) : ObservableValidator
+    {
+        [ObservableProperty] private string _displayName = displayName;
+        [ObservableProperty] private string _icon = icon;
+        [ObservableProperty] private int _index = index;
+    }
+}

Needlework.Net/ViewModels/ParameterViewModel.cs

@@ -0,0 +1,20 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class ParameterViewModel : ObservableObject
+    {
+        public string Name { get; }
+        public string Type { get; }
+        public bool IsRequired { get; }
+        [ObservableProperty] private string? _value = null;
+
+        public ParameterViewModel(string name, string type, bool isRequired, string? value = null)
+        {
+            Name = name;
+            Type = type;
+            IsRequired = isRequired;
+            Value = value;
+        }
+    }
+}

Needlework.Net/ViewModels/PathOperationViewModel.cs

@@ -0,0 +1,142 @@
+using Avalonia.Media;
+using BlossomiShymae.GrrrLCU;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Needlework.Net.Core;
+using Needlework.Net.Messages;
+using System;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class PathOperationViewModel : ObservableObject
+    {
+        public string Method { get; }
+        public SolidColorBrush Color { get; }
+        public string Path { get; }
+        public OperationViewModel Operation { get; }
+        public ProcessInfo? ProcessInfo { get; }
+
+        [ObservableProperty] private bool _isBusy;
+        [ObservableProperty] private string? _responsePath;
+        [ObservableProperty] private string? _responseStatus;
+        [ObservableProperty] private string? _responseAuthentication;
+        [ObservableProperty] private string? _responseUsername;
+        [ObservableProperty] private string? _responsePassword;
+        [ObservableProperty] private string? _responseAuthorization;
+
+        public PathOperationViewModel(PathOperation pathOperation)
+        {
+            Method = pathOperation.Method.ToUpper();
+            Color = new SolidColorBrush(GetColor(Method));
+            Path = pathOperation.Path;
+            Operation = new OperationViewModel(pathOperation.Operation);
+            ProcessInfo = GetProcessInfo();
+            if (ProcessInfo != null)
+            {
+                ResponsePath = $"https://127.0.0.1:{ProcessInfo.AppPort}{Path}";
+                var riotAuth = new RiotAuthentication(ProcessInfo.RemotingAuthToken);
+                ResponseUsername = riotAuth.Username;
+                ResponsePassword = riotAuth.Password;
+                ResponseAuthorization = $"Basic {riotAuth.Value}";
+            }
+        }
+
+        private ProcessInfo? GetProcessInfo()
+        {
+            try
+            {
+                var processInfo = Connector.GetProcessInfo();
+                return processInfo;
+            }
+            catch (Exception) { }
+            return null;
+        }
+
+        [RelayCommand]
+        public async Task SendRequest()
+        {
+            try
+            {
+                IsBusy = true;
+
+                var method = Method switch
+                {
+                    "GET" => HttpMethod.Get,
+                    "POST" => HttpMethod.Post,
+                    "PUT" => HttpMethod.Put,
+                    "DELETE" => HttpMethod.Delete,
+                    "HEAD" => HttpMethod.Head,
+                    "PATCH" => HttpMethod.Patch,
+                    "OPTIONS" => HttpMethod.Options,
+                    "TRACE" => HttpMethod.Trace,
+                    _ => throw new Exception("Method is missing.")
+                };
+
+                var processInfo = Connector.GetProcessInfo();
+                var sb = new StringBuilder(Path);
+                foreach (var pathParameter in Operation.PathParameters)
+                {
+                    sb.Replace($"{{{pathParameter.Name}}}", pathParameter.Value);
+                }
+
+                var firstQueryAdded = false;
+                foreach (var queryParameter in Operation.QueryParameters)
+                {
+                    if (!string.IsNullOrWhiteSpace(queryParameter.Value))
+                    {
+                        sb.Append(firstQueryAdded ? '&' : '?');
+                        firstQueryAdded = true;
+                        sb.Append($"{queryParameter.Name}={Uri.EscapeDataString(queryParameter.Value)}");
+                    }
+                }
+                var uri = sb.ToString();
+
+                var requestBody = WeakReferenceMessenger.Default.Send(new ContentRequestMessage(), "EndpointRequestEditor").Response;
+                var content = new StringContent(requestBody, new System.Net.Http.Headers.MediaTypeHeaderValue("application/json"));
+
+                var response = await Connector.SendAsync(method, uri, content);
+                var riotAuthentication = new RiotAuthentication(processInfo.RemotingAuthToken);
+                var responseBytes = await response.Content.ReadAsByteArrayAsync();
+
+                var responseBody = responseBytes.Length > 0 ? JsonSerializer.Serialize(JsonSerializer.Deserialize<object>(responseBytes), App.JsonSerializerOptions) : string.Empty;
+                if (responseBody.Length >= App.MaxCharacters)
+                {
+                    WeakReferenceMessenger.Default.Send(new OopsiesWindowRequestedMessage(responseBody));
+                    WeakReferenceMessenger.Default.Send(new EditorUpdateMessage(new(string.Empty, "EndpointResponseEditor")));
+                }
+                else WeakReferenceMessenger.Default.Send(new EditorUpdateMessage(new(responseBody, "EndpointResponseEditor")));
+
+                ResponseStatus = $"{(int)response.StatusCode} {response.StatusCode}";
+                ResponsePath = $"https://127.0.0.1:{processInfo.AppPort}{uri}";
+                ResponseAuthentication = $"Basic {riotAuthentication.Value}";
+                ResponseUsername = riotAuthentication.Username;
+                ResponsePassword = riotAuthentication.Password;
+            }
+            catch (Exception ex)
+            {
+                WeakReferenceMessenger.Default.Send(new InfoBarUpdateMessage(new InfoBarViewModel("Request Failed", true, ex.Message, FluentAvalonia.UI.Controls.InfoBarSeverity.Error, TimeSpan.FromSeconds(5))));
+                WeakReferenceMessenger.Default.Send(new EditorUpdateMessage(new(string.Empty, "EndpointResponseEditor")));
+            }
+            finally
+            {
+                IsBusy = false;
+            }
+        }
+
+        public static Color GetColor(string method) => method switch
+        {
+            "GET" => Avalonia.Media.Color.FromRgb(95, 99, 186),
+            "POST" => Avalonia.Media.Color.FromRgb(103, 186, 95),
+            "PUT" => Avalonia.Media.Color.FromRgb(186, 139, 95),
+            "DELETE" => Avalonia.Media.Color.FromRgb(186, 95, 95),
+            "HEAD" => Avalonia.Media.Color.FromRgb(136, 95, 186),
+            "PATCH" => Avalonia.Media.Color.FromRgb(95, 186, 139),
+            _ => throw new InvalidOperationException("Method does not have assigned color.")
+        };
+    }
+}

Needlework.Net/ViewModels/PropertyClassViewModel.cs

@@ -0,0 +1,36 @@
+using Avalonia.Collections;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Models;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Needlework.Net.ViewModels
+{
+    public class PropertyClassViewModel : ObservableObject
+    {
+        public string Id { get; }
+        public IAvaloniaReadOnlyList<PropertyFieldViewModel> PropertyFields { get; } = new AvaloniaList<PropertyFieldViewModel>();
+        public IAvaloniaReadOnlyList<PropertyEnumViewModel> PropertyEnums { get; } = new AvaloniaList<PropertyEnumViewModel>();
+
+        public PropertyClassViewModel(string id, IDictionary<string, OpenApiSchema> properties, IList<IOpenApiAny> enumValue)
+        {
+            AvaloniaList<PropertyFieldViewModel> propertyFields = [];
+            AvaloniaList<PropertyEnumViewModel> propertyEnums = [];
+            foreach ((var propertyName, var propertySchema) in properties)
+            {
+                var type = OperationViewModel.GetSchemaType(propertySchema);
+                var field = new PropertyFieldViewModel(propertyName, type);
+                propertyFields.Add(field);
+            }
+            if (enumValue != null && enumValue.Any())
+            {
+                var propertyEnum = new PropertyEnumViewModel(enumValue);
+                propertyEnums.Add(propertyEnum);
+            }
+            PropertyFields = propertyFields;
+            PropertyEnums = propertyEnums;
+            Id = id;
+        }
+    }
+}

Needlework.Net/ViewModels/PropertyEnumViewModel.cs

@@ -0,0 +1,17 @@
+using Microsoft.OpenApi.Any;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Needlework.Net.ViewModels
+{
+    public class PropertyEnumViewModel
+    {
+        public string Type { get; } = "Enum";
+        public string Values { get; }
+
+        public PropertyEnumViewModel(IList<IOpenApiAny> enumValue)
+        {
+            Values = $"[{string.Join(", ", enumValue.Select(x => $"\"{((OpenApiString)x).Value}\"").ToList())}]";
+        }
+    }
+}

Needlework.Net/ViewModels/PropertyFieldViewModel.cs

@@ -0,0 +1,14 @@
+namespace Needlework.Net.ViewModels
+{
+    public class PropertyFieldViewModel
+    {
+        public string Name { get; }
+        public string Type { get; }
+
+        public PropertyFieldViewModel(string name, string type)
+        {
+            Name = name;
+            Type = type;
+        }
+    }
+}

Needlework.Net/ViewModels/WebsocketViewModel.cs

@@ -0,0 +1,131 @@
+using BlossomiShymae.GrrrLCU;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Needlework.Net.Messages;
+using Needlework.Net.Services;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using Websocket.Client;
+
+namespace Needlework.Net.ViewModels
+{
+    public partial class WebsocketViewModel : PageBase
+    {
+        public ObservableCollection<string> EventLog { get; } = [];
+        public SemaphoreSlim EventLogLock { get; } = new(1, 1);
+
+        [NotifyPropertyChangedFor(nameof(FilteredEventLog))]
+        [ObservableProperty] private string _search = string.Empty;
+        [ObservableProperty] private bool _isAttach = true;
+        [ObservableProperty] private bool _isTail = false;
+        [ObservableProperty] private string? _selectedEventLog = null;
+
+        private Dictionary<string, EventMessage> _events = [];
+
+        public WebsocketClient? Client { get; set; }
+
+        public WindowService WindowService { get; }
+
+        public IReadOnlyList<string> FilteredEventLog => string.IsNullOrWhiteSpace(Search) ? EventLog : [.. EventLog.Where(x => x.Contains(Search, StringComparison.InvariantCultureIgnoreCase))];
+
+        public WebsocketViewModel(WindowService windowService) : base("Event Viewer", "plug", -100)
+        {
+            WindowService = windowService;
+            EventLog.CollectionChanged += (s, e) => OnPropertyChanged(nameof(FilteredEventLog));
+            var thread = new Thread(InitializeWebsocket) { IsBackground = true };
+            thread.Start();
+        }
+
+        private void InitializeWebsocket()
+        {
+            while (true)
+            {
+                try
+                {
+                    var client = Connector.CreateLcuWebsocketClient();
+                    client.EventReceived.Subscribe(OnMessage);
+                    client.DisconnectionHappened.Subscribe(OnDisconnection);
+                    client.ReconnectionHappened.Subscribe(OnReconnection);
+
+                    client.Start();
+                    client.Send(new EventMessage(RequestType.Subscribe, EventMessage.Kinds.OnJsonApiEvent));
+                    Client = client;
+                    return;
+                }
+                catch (Exception) { }
+                Thread.Sleep(TimeSpan.FromSeconds(5));
+            }
+        }
+
+        [RelayCommand]
+        private void Clear()
+        {
+            _events.Clear();
+            EventLog.Clear();
+        }
+
+        partial void OnSelectedEventLogChanged(string? value)
+        {
+            if (value == null) return;
+            if (_events.TryGetValue(value, out var message))
+            {
+                var text = JsonSerializer.Serialize(message, App.JsonSerializerOptions);
+                if (text.Length >= App.MaxCharacters) WindowService.ShowOopsiesWindow(text);
+                else WeakReferenceMessenger.Default.Send(new ResponseUpdatedMessage(text), nameof(WebsocketViewModel));
+            }
+        }
+
+        private void OnReconnection(ReconnectionInfo info)
+        {
+            Trace.WriteLine($"-- Reconnection --\nType{info.Type}");
+        }
+
+        private void OnDisconnection(DisconnectionInfo info)
+        {
+            Trace.WriteLine($"-- Disconnection --\nType:{info.Type}\nSubProocol:{info.SubProtocol}\nCloseStatus:{info.CloseStatus}\nCloseStatusDescription:{info.CloseStatusDescription}\nExceptionMessage:{info?.Exception?.Message}\n:InnerException:{info?.Exception?.InnerException}");
+            Client?.Dispose();
+            var thread = new Thread(InitializeWebsocket) { IsBackground = true };
+            thread.Start();
+        }
+
+        private void OnMessage(EventMessage message)
+        {
+            Avalonia.Threading.Dispatcher.UIThread.Invoke(async () =>
+            {
+                if (!IsAttach) return;
+
+                var line = $"{DateTime.Now:HH:mm:ss.fff} {message.Data?.EventType.ToUpper()} {message.Data?.Uri}";
+                Trace.WriteLine($"Message: {line}");
+
+                await EventLogLock.WaitAsync();
+                try
+                {
+                    if (EventLog.Count < 1000)
+                    {
+                        EventLog.Add(line);
+                        _events[line] = message;
+                    }
+                    else
+                    {
+                        var key = EventLog[0];
+                        EventLog.RemoveAt(0);
+                        _events.Remove(key);
+
+                        EventLog.Add(line);
+                        _events[line] = message;
+                    }
+                }
+                finally
+                {
+                    EventLogLock.Release();
+                }
+            });
+        }
+    }
+}