First real stable push since migrating

LD-SysInfo/Services/ApiClient.cs

@@ -0,0 +1,206 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Security.Cryptography.X509Certificates;
+using System.Net.Security;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using System.Windows;
+using LD_SysInfo.Models;
+
+namespace LD_SysInfo.Services
+{
+    public class ApiClient
+    {
+        /// <summary>
+        /// Constructs the full URL for API requests.
+        /// </summary>
+        private static readonly HttpClient httpClient = CreateHttpClient();
+        private readonly AppConfig _config;
+        private static string jwtToken = null; // 🔹 Store the JWT token globally
+
+        public ApiClient(AppConfig config)
+        {
+            _config = config ?? throw new ArgumentNullException(nameof(config));
+        }
+
+
+        private string BuildUrl(string route)
+        {
+            return $"{_config.ServerUrl.TrimEnd('/')}/{route.TrimStart('/')}";
+        }
+
+        /// <summary>
+        /// Creates an HttpClient that bypasses SSL validation (for testing purposes only).
+        /// </summary>
+        public static HttpClient CreateHttpClient()
+        {
+            HttpClientHandler handler = new HttpClientHandler
+            {
+                ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, certChain, sslPolicyErrors) =>
+                {
+                    return true; // 🔥 Ignores all SSL certificate warnings (TEMPORARY!)
+                }
+            };
+
+            return new HttpClient(handler);
+        }
+
+        /// <summary>
+        /// Sets the JWT token to be used for subsequent requests.
+        /// </summary>
+        public static void SetJwtToken(string token)
+        {
+            jwtToken = token;
+            httpClient.DefaultRequestHeaders.Authorization =
+                new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", jwtToken);
+        }
+        /// <summary>
+        /// Gets the JWT token to be used for subsequent requests.
+        /// </summary>
+        public static string GetJwtToken()
+        {
+            return jwtToken;
+        }
+
+        /// <summary>
+        /// Authenticates with the API using credentials from config.json.
+        /// </summary>
+        public async Task<LoginResponse> AuthenticateAsync(string username, string password)
+        {
+            try
+            {
+                string encryptedUsername = EncryptionHelper.EncryptData(username);
+                string encryptedPassword = EncryptionHelper.EncryptData(password);
+
+                var payload = new
+                {
+                    username = encryptedUsername,
+                    password = encryptedPassword
+                };
+
+                string jsonContent = JsonConvert.SerializeObject(payload);
+                var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
+
+                HttpResponseMessage response = await httpClient.PostAsync(BuildUrl("/api/auth/login"), content);
+                string rawResponse = await response.Content.ReadAsStringAsync();
+
+                if (!response.IsSuccessStatusCode)
+                {
+                    Console.WriteLine($"❌ Authentication failed: {response.StatusCode} - {rawResponse}");
+                    return null;
+                }
+
+                var loginResponse = JsonConvert.DeserializeObject<LoginResponse>(rawResponse);
+
+                if (!string.IsNullOrEmpty(loginResponse?.Token))
+                {
+                    SetJwtToken(loginResponse.Token);
+                }
+
+                return loginResponse;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"❌ Exception during login: {ex.Message}");
+                return null;
+            }
+        }
+
+
+
+        /// <summary>
+        /// Checks connectivity to the server using the stored JWT token.
+        /// </summary>
+        public async Task<bool> CheckConnectivity()
+        {
+            string testUrl = "https://localhost:8443/api/system/ping-status";  // Your HTTPS URL with port 8443
+
+            try
+            {
+                if (string.IsNullOrEmpty(jwtToken))
+                {
+                    throw new Exception("No JWT token stored. Please authenticate first.");
+                }
+
+                var response = await SendWithAutoReauthAsync(() =>
+    httpClient.GetAsync(testUrl)
+);
+
+
+                if (response.IsSuccessStatusCode)
+                {
+                    return true;
+                }
+                else
+                {
+                    Console.WriteLine($"❌ Server Unreachable: {response.StatusCode}");
+                    return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"❌ Connection Error: {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Sends the collected data to the server.
+        /// </summary>
+        public async Task<string> StoreSystemInfoAsync(string encryptedData)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(jwtToken))
+                    return "❌ Error: Not authenticated. Please log in first.";
+
+                var payload = new { data = encryptedData };
+                string jsonContent = JsonConvert.SerializeObject(payload);
+                var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
+
+                var response = await SendWithAutoReauthAsync(() =>
+                    httpClient.PostAsync(BuildUrl("/api/system-info"), content)
+                );
+
+                if (response.IsSuccessStatusCode)
+                    return await response.Content.ReadAsStringAsync();
+                else
+                    return $"❌ Error: {response.StatusCode} - {await response.Content.ReadAsStringAsync()}";
+            }
+            catch (Exception ex)
+            {
+                return $"❌ Exception: {ex.Message}";
+            }
+        }
+
+
+        /// <summary>
+        /// Sends the collected data to the server.
+        /// </summary>
+        private async Task<HttpResponseMessage> SendWithAutoReauthAsync(Func<Task<HttpResponseMessage>> requestFunc)
+        {
+            var response = await requestFunc();
+
+            if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
+            {
+                Console.WriteLine("⚠️ Token expired or invalid. Attempting re-auth...");
+
+                var loginResponse = await AuthenticateAsync(_config.Auth.Username, _config.Auth.Password);
+                if (loginResponse == null || string.IsNullOrEmpty(loginResponse.Token))
+                {
+                    Console.WriteLine("❌ Re-authentication failed.");
+                    return response; // Return original 401 response
+                }
+
+                // Retry original request after reauth
+                response = await requestFunc();
+            }
+
+            return response;
+        }
+
+
+    }
+}