Release 1.17.5

Yelo420 · web-flow · commit 416176641cea · 2025-12-13T17:28:28.000+01:00
Release 1.17.5
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # GameVault App Changelog
 
+## 1.17.5
+Recommended Gamevault Server Version: `v16.1.2`
+### Changes
+- Bug fix: The required request headers for download resume and database backup were not sent.
+- Bug fix: You couldn't enter spaces for the password in the login window.
+- Bug fix: The session tokens were not properly persistent
+
 ## 1.17.4
 Recommended Gamevault Server Version: `v16.1.1`
 ### Changes
diff --git a/gamevault/AssemblyInfo.cs b/gamevault/AssemblyInfo.cs
@@ -11,7 +11,7 @@
                                               //(used if a resource is not found in the page,
                                               // app, or any theme specific resource dictionaries)
 )]
-[assembly: AssemblyVersion("1.17.4.0")]
+[assembly: AssemblyVersion("1.17.5.0")]
 [assembly: AssemblyCopyright("� Phalcode�. All Rights Reserved.")]
 #if DEBUG
 [assembly: XmlnsDefinition("debug-mode", "Namespace")]
diff --git a/gamevault/Helper/Integrations/SaveGameHelper.cs b/gamevault/Helper/Integrations/SaveGameHelper.cs
@@ -70,7 +70,7 @@ internal async Task<string> RestoreBackup(int gameId, string installationDir)
                 string[] auth = WebHelper.GetCredentials();
 
                 string url = @$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}";
-                using (HttpResponseMessage response = await WebHelper.GetAsync(@$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}", HttpCompletionOption.ResponseHeadersRead))
+                using (HttpResponseMessage response = await WebHelper.GetAsync(@$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}", null, HttpCompletionOption.ResponseHeadersRead))
                 {
                     response.EnsureSuccessStatusCode();
                     string fileName = response.Content.Headers.ContentDisposition.FileName.Split('_')[1].Split('.')[0];
@@ -356,7 +356,7 @@ private async Task<bool> UploadSavegame(string saveFilePath, int gameId, string
                 string installationId = GetGameInstallationId(installationDir);
                 using (MemoryStream memoryStream = await FileToMemoryStreamAsync(saveFilePath))
                 {
-                    await WebHelper.UploadFileAsync(@$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}", memoryStream, "x.zip", new RequestHeader[] { new RequestHeader() { Name = "X-Installation-Id", Value = installationId } });
+                    await WebHelper.UploadFileAsync(@$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}", memoryStream, "x.zip", new List<RequestHeader> { new RequestHeader() { Name = "X-Installation-Id", Value = installationId } });
                 }
             }
             catch
diff --git a/gamevault/Helper/PasswordBoxAttachedProperties.cs b/gamevault/Helper/PasswordBoxAttachedProperties.cs
@@ -210,13 +210,8 @@ private static void OnPreviewKeyDown(object sender, KeyEventArgs e)
             if (sender is not TextBox textBox || !GetIsPassword(textBox))
                 return;
 
-            // Prevent spaces in password
-            if (e.Key == Key.Space)
-            {
-                e.Handled = true;
-            }
             // Handle Ctrl+A select all
-            else if (e.Key == Key.A && (Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
+            if (e.Key == Key.A && (Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
             {
                 textBox.SelectAll();
                 e.Handled = true;
diff --git a/gamevault/Helper/Web/HttpClientDownloadWithProgress.cs b/gamevault/Helper/Web/HttpClientDownloadWithProgress.cs
@@ -14,25 +14,25 @@
 
 namespace gamevault.Helper
 {
-    public class HttpClientDownloadWithProgress : IDisposable
+    public class HttpClientDownloadWithProgress
     {
         private readonly string DownloadUrl;
         private readonly string DestinationFolderPath;
         private string FileName;
         private string FallbackFileName;
-        private KeyValuePair<string, string>? AdditionalHeader;
+        private Dictionary<string, string>? AdditionalHeader;
         private bool Cancelled = false;
         private bool Paused = false;
         private long ResumePosition = -1;
         private long PreResumeSize = -1;
         private DateTime LastTime;
-        private HttpClient HttpClient;
+
 
         public delegate void ProgressChangedHandler(long totalFileSize, long currentBytesDownloaded, long totalBytesDownloaded, double? progressPercentage, long resumePosition);
 
         public event ProgressChangedHandler ProgressChanged;
 
-        public HttpClientDownloadWithProgress(string downloadUrl, string destinationFolderPath, string fallbackFileName, KeyValuePair<string, string>? additionalHeader = null)
+        public HttpClientDownloadWithProgress(string downloadUrl, string destinationFolderPath, string fallbackFileName, Dictionary<string, string>? additionalHeader = null)
         {
             DownloadUrl = downloadUrl;
             DestinationFolderPath = destinationFolderPath;
@@ -42,8 +42,7 @@ public HttpClientDownloadWithProgress(string downloadUrl, string destinationFold
 
         public async Task StartDownload(bool tryResume = false)
         {
-            HttpClient = new HttpClient { Timeout = TimeSpan.FromDays(7) };
-            CreateHeader();
+
             if (tryResume)
             {
                 InitResume();
@@ -55,18 +54,9 @@ public async Task StartDownload(bool tryResume = false)
                     File.Delete($"{DestinationFolderPath}\\gamevault-metadata");
             }
 
-            using (HttpResponseMessage response = await WebHelper.GetAsync(DownloadUrl, HttpCompletionOption.ResponseHeadersRead))
+            using (HttpResponseMessage response = await WebHelper.GetAsync(DownloadUrl, AdditionalHeader, HttpCompletionOption.ResponseHeadersRead))
                 await DownloadFileFromHttpResponseMessage(response);
         }
-        private void CreateHeader()
-        {
-            string[] auth = WebHelper.GetCredentials();
-            HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{auth[0]}:{auth[1]}")));
-            HttpClient.DefaultRequestHeaders.Add("User-Agent", $"GameVault/{SettingsViewModel.Instance.Version}");
-
-            if (AdditionalHeader != null)
-                HttpClient.DefaultRequestHeaders.Add(AdditionalHeader.Value.Key, AdditionalHeader.Value.Value);
-        }
         private void InitResume()
         {
             string resumeData = Preferences.Get(AppConfigKey.DownloadProgress, $"{DestinationFolderPath}\\gamevault-metadata");
@@ -77,7 +67,11 @@ private void InitResume()
                     string[] resumeDataToProcess = resumeData.Split(";");
                     ResumePosition = long.Parse(resumeDataToProcess[0]);
                     PreResumeSize = long.Parse(resumeDataToProcess[1]);
-                    HttpClient.DefaultRequestHeaders.Range = new RangeHeaderValue(long.Parse(resumeDataToProcess[0]), null);
+                    if (AdditionalHeader == null)
+                    {
+                        AdditionalHeader = new Dictionary<string, string>();                    
+                    }
+                    AdditionalHeader?.Add("Range", $"bytes={ResumePosition}-");                  
                 }
                 catch { }
             }
@@ -206,17 +200,11 @@ public void Cancel()
                 return;
             }
             Cancelled = true;
-            Dispose();
         }
         public void Pause()
         {
             Paused = true;
             Cancelled = true;
-            Dispose();
-        }
-        public void Dispose()
-        {
-            HttpClient?.Dispose();
         }
     }
 }
diff --git a/gamevault/Helper/Web/OAuthHttpClient.cs b/gamevault/Helper/Web/OAuthHttpClient.cs
@@ -33,6 +33,11 @@ public void InjectTokens(string accessToken, string refreshToken)
         {
             _accessToken = accessToken;
             _refreshToken = refreshToken;
+            try
+            {
+                nextTokenRefresh = GetNextTokenRefresh(_accessToken);
+            }
+            catch { }
         }
         public string GetRefreshToken()
         {
@@ -60,7 +65,7 @@ public async Task<bool> LoginBasicAuthAsync(string username, string password)
             return true;
         }
 
-        private async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, RequestHeader[]? additionalHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead)
+        private async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, List<RequestHeader>? additionalHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead)
         {
             if (string.IsNullOrEmpty(_accessToken))
             {
@@ -82,16 +87,16 @@ private async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, Re
             return await _httpClient.SendAsync(request, option);
         }
 
-        public Task<HttpResponseMessage> GetAsync(string url, RequestHeader[]? additionalHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead) =>
+        public Task<HttpResponseMessage> GetAsync(string url, List<RequestHeader>? additionalHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead) =>
             SendAsync(new HttpRequestMessage(HttpMethod.Get, url), additionalHeaders, option);
 
-        public Task<HttpResponseMessage> PostAsync(string url, HttpContent content, RequestHeader[]? additionalHeaders = null) =>
+        public Task<HttpResponseMessage> PostAsync(string url, HttpContent content, List<RequestHeader>? additionalHeaders = null) =>
             SendAsync(new HttpRequestMessage(HttpMethod.Post, url) { Content = content }, additionalHeaders);
 
-        public Task<HttpResponseMessage> PutAsync(string url, HttpContent content, RequestHeader[]? additionalHeaders = null) =>
+        public Task<HttpResponseMessage> PutAsync(string url, HttpContent content, List<RequestHeader>? additionalHeaders = null) =>
             SendAsync(new HttpRequestMessage(HttpMethod.Put, url) { Content = content }, additionalHeaders);
 
-        public Task<HttpResponseMessage> DeleteAsync(string url, RequestHeader[]? additionalHeaders = null) =>
+        public Task<HttpResponseMessage> DeleteAsync(string url, List<RequestHeader>? additionalHeaders = null) =>
             SendAsync(new HttpRequestMessage(HttpMethod.Delete, url), additionalHeaders);
 
         private async Task<bool> RefreshTokenAsync()
diff --git a/gamevault/Helper/Web/WebHelper.cs b/gamevault/Helper/Web/WebHelper.cs
@@ -19,7 +19,7 @@ internal class WebHelper
         {
             DefaultRequestHeaders = { { "User-Agent", "GameVault" } }
         };
-        private static RequestHeader[] AdditionalRequestHeaders;
+        private static List<RequestHeader> AdditionalRequestHeaders = new List<RequestHeader>();
         static WebHelper() { }
         internal static void SetCredentials(string serverUrl, string username, string password)
         {
@@ -47,7 +47,7 @@ internal static string GetRefreshToken()
         {
             return HttpClient.GetRefreshToken();
         }
-        internal static void SetAdditionalRequestHeaders(RequestHeader[] additionalRequestHeaders)
+        internal static void SetAdditionalDefaultRequestHeaders(List<RequestHeader> additionalRequestHeaders)
         {
             AdditionalRequestHeaders = additionalRequestHeaders;
 
@@ -62,40 +62,45 @@ internal static void SetAdditionalRequestHeaders(RequestHeader[] additionalReque
         internal static async Task<string> BaseGetAsync(string url)
         {
             var response = await BaseHttpClient.GetAsync(url);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             return await response.Content.ReadAsStringAsync();
         }
         internal static async Task<string> BasePostAsync(string url, string payload)
         {
             var content = new StringContent(payload, Encoding.UTF8, "application/json");
             var response = await BaseHttpClient.PostAsync(url, content);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             return await response.Content.ReadAsStringAsync();
         }
         internal static async Task<string> BaseSendRequest(HttpRequestMessage request)
         {
             var response = await BaseHttpClient.SendAsync(request);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             return await response.Content.ReadAsStringAsync();
         }
         #endregion
         internal static async Task<string> GetAsync(string url)
         {
             var response = await HttpClient.GetAsync(url, AdditionalRequestHeaders);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             return await response.Content.ReadAsStringAsync();
         }
-        internal static async Task<HttpResponseMessage> GetAsync(string url, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead)
+        internal static async Task<HttpResponseMessage> GetAsync(string url, Dictionary<string, string>? additionalManualRequestHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead)
         {
-            var response = await HttpClient.GetAsync(url, AdditionalRequestHeaders, option);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            List<RequestHeader> additionalHeaders = null;
+            if (additionalManualRequestHeaders is { Count: > 0 })
+            {
+                additionalHeaders = additionalManualRequestHeaders.Select(h => new RequestHeader { Name = h.Key, Value = h.Value }).Concat(AdditionalRequestHeaders).ToList();
+            }
+            var response = await HttpClient.GetAsync(url, additionalHeaders ?? AdditionalRequestHeaders, option);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             return response;
         }
         internal static async Task<string> PostAsync(string url, string payload)
         {
             var content = new StringContent(payload, Encoding.UTF8, "application/json");
             var response = await HttpClient.PostAsync(url, content, AdditionalRequestHeaders);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             return await response.Content.ReadAsStringAsync();
         }
 
@@ -109,20 +114,20 @@ internal static async Task<string> PutAsync(string url, string payload)
         internal static async Task<string> DeleteAsync(string url)
         {
             var response = await HttpClient.DeleteAsync(url, AdditionalRequestHeaders);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             return await response.Content.ReadAsStringAsync();
         }
         public static async Task DownloadImageFromUrlAsync(string imageUrl, string cacheFile)
         {
             var response = await HttpClient.GetAsync(imageUrl, AdditionalRequestHeaders);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             var imageBytes = await response.Content.ReadAsByteArrayAsync();
             await File.WriteAllBytesAsync(cacheFile, imageBytes);
         }
         public static async Task<BitmapImage> DownloadImageFromUrlAsync(string imageUrl)
         {
             var response = await HttpClient.GetAsync(imageUrl, AdditionalRequestHeaders);
-           await WebExceptionHelper.EnsureSuccessStatusCode(response);
+            await WebExceptionHelper.EnsureSuccessStatusCode(response);
             var imageData = await response.Content.ReadAsByteArrayAsync();
             using (var memoryStream = new MemoryStream(imageData))
             {
@@ -135,13 +140,13 @@ public static async Task<BitmapImage> DownloadImageFromUrlAsync(string imageUrl)
                 return bitmap;
             }
         }
-        public static async Task<string> UploadFileAsync(string apiUrl, Stream imageStream, string fileName, RequestHeader[]? additionalHeaders = null)
+        public static async Task<string> UploadFileAsync(string apiUrl, Stream imageStream, string fileName, List<RequestHeader>? additionalHeaders = null)
         {
             //Mix request headers
-            RequestHeader[]? mixedHeaders = null;
+            List<RequestHeader>? mixedHeaders = null;
             if (additionalHeaders != null && AdditionalRequestHeaders != null)
             {
-                mixedHeaders = AdditionalRequestHeaders.Concat(additionalHeaders).ToArray();
+                mixedHeaders = AdditionalRequestHeaders.Concat(additionalHeaders).ToList();
             }
             else if (additionalHeaders == null)
             {
@@ -158,7 +163,7 @@ public static async Task<string> UploadFileAsync(string apiUrl, Stream imageStre
                 imageContent.Headers.ContentType = new MediaTypeHeaderValue(mimeType);
                 formData.Add(imageContent, "file", fileName);
                 var response = await HttpClient.PostAsync(apiUrl, formData, mixedHeaders);
-               await WebExceptionHelper.EnsureSuccessStatusCode(response);
+                await WebExceptionHelper.EnsureSuccessStatusCode(response);
                 var responseContent = await response.Content.ReadAsStringAsync();
                 return responseContent;
             }
@@ -184,7 +189,7 @@ public static string RemoveSpecialCharactersFromUrl(string url)
             }
             return sb.ToString();
         }
-        
+
     }
 }
 
diff --git a/gamevault/UserControls/GameDownloadUserControl.xaml.cs b/gamevault/UserControls/GameDownloadUserControl.xaml.cs
@@ -178,12 +178,12 @@ private async Task DownloadGame(bool tryResume = false)
             ViewModel.DownloadFailedVisibility = System.Windows.Visibility.Hidden;
 
             if (!Directory.Exists(m_DownloadPath)) { Directory.CreateDirectory(m_DownloadPath); }
-            KeyValuePair<string, string>? header = null;
+            Dictionary<string,string> additionalRequestHeaders = new Dictionary<string,string>();
             if (SettingsViewModel.Instance.DownloadLimit > 0)
             {
-                header = new KeyValuePair<string, string>("X-Download-Speed-Limit", SettingsViewModel.Instance.DownloadLimit.ToString());
+                additionalRequestHeaders.Add("X-Download-Speed-Limit", SettingsViewModel.Instance.DownloadLimit.ToString());
             }
-            client = new HttpClientDownloadWithProgress($"{SettingsViewModel.Instance.ServerUrl}/api/games/{ViewModel.Game.ID}/download", m_DownloadPath, Path.GetFileName(ViewModel.Game.Path), header);
+            client = new HttpClientDownloadWithProgress($"{SettingsViewModel.Instance.ServerUrl}/api/games/{ViewModel.Game.ID}/download", m_DownloadPath, Path.GetFileName(ViewModel.Game.Path), additionalRequestHeaders);
             client.ProgressChanged += DownloadProgress;
             startTime = DateTime.Now;
             downloadSpeedCalc = new DownloadSpeedCalculator();
@@ -195,7 +195,6 @@ private async Task DownloadGame(bool tryResume = false)
             catch (Exception ex)
             {
                 IsDownloadActive = false;
-                client.Dispose();
                 ViewModel.State = $"Error: '{ex.Message}'";
                 ViewModel.DownloadUIVisibility = System.Windows.Visibility.Hidden;
                 ViewModel.DownloadFailedVisibility = System.Windows.Visibility.Visible;
@@ -314,7 +313,6 @@ private void DownloadCompleted()
 
             UpdateDataSizeUI();
             ViewModel.DownloadUIVisibility = System.Windows.Visibility.Hidden;
-            client.Dispose();
             IsDownloadActive = false;
             ViewModel.State = "Downloaded";
             uiBtnExtract.IsEnabled = true;
diff --git a/gamevault/UserControls/SettingsComponents/BackupRestoreUserControl.xaml.cs b/gamevault/UserControls/SettingsComponents/BackupRestoreUserControl.xaml.cs
diff --git a/gamevault/Windows/LoginWindow.xaml.cs b/gamevault/Windows/LoginWindow.xaml.cs

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ internal async Task<string> RestoreBackup(int gameId, string installationDir)`
`70`	`70`	`string[] auth = WebHelper.GetCredentials();`
`71`	`71`
`72`	`72`	`string url = @$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}";`
`73`		`- using (HttpResponseMessage response = await WebHelper.GetAsync(@$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}", HttpCompletionOption.ResponseHeadersRead))`
	`73`	`+ using (HttpResponseMessage response = await WebHelper.GetAsync(@$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}", null, HttpCompletionOption.ResponseHeadersRead))`
`74`	`74`	`{`
`75`	`75`	`response.EnsureSuccessStatusCode();`
`76`	`76`	`string fileName = response.Content.Headers.ContentDisposition.FileName.Split('_')[1].Split('.')[0];`
`@@ -356,7 +356,7 @@ private async Task<bool> UploadSavegame(string saveFilePath, int gameId, string`
`356`	`356`	`string installationId = GetGameInstallationId(installationDir);`
`357`	`357`	`using (MemoryStream memoryStream = await FileToMemoryStreamAsync(saveFilePath))`
`358`	`358`	`{`
`359`		`- await WebHelper.UploadFileAsync(@$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}", memoryStream, "x.zip", new RequestHeader[] { new RequestHeader() { Name = "X-Installation-Id", Value = installationId } });`
	`359`	`+ await WebHelper.UploadFileAsync(@$"{SettingsViewModel.Instance.ServerUrl}/api/savefiles/user/{LoginManager.Instance.GetCurrentUser()!.ID}/game/{gameId}", memoryStream, "x.zip", new List<RequestHeader> { new RequestHeader() { Name = "X-Installation-Id", Value = installationId } });`
`360`	`360`	`}`
`361`	`361`	`}`
`362`	`362`	`catch`
Original file line number	Diff line number	Diff line change
`@@ -14,25 +14,25 @@`
`14`	`14`
`15`	`15`	`namespace gamevault.Helper`
`16`	`16`	`{`
`17`		`- public class HttpClientDownloadWithProgress : IDisposable`
	`17`	`+ public class HttpClientDownloadWithProgress`
`18`	`18`	`{`
`19`	`19`	`private readonly string DownloadUrl;`
`20`	`20`	`private readonly string DestinationFolderPath;`
`21`	`21`	`private string FileName;`
`22`	`22`	`private string FallbackFileName;`
`23`		`- private KeyValuePair<string, string>? AdditionalHeader;`
	`23`	`+ private Dictionary<string, string>? AdditionalHeader;`
`24`	`24`	`private bool Cancelled = false;`
`25`	`25`	`private bool Paused = false;`
`26`	`26`	`private long ResumePosition = -1;`
`27`	`27`	`private long PreResumeSize = -1;`
`28`	`28`	`private DateTime LastTime;`
`29`		`- private HttpClient HttpClient;`
	`29`	`+`
`30`	`30`
`31`	`31`	`public delegate void ProgressChangedHandler(long totalFileSize, long currentBytesDownloaded, long totalBytesDownloaded, double? progressPercentage, long resumePosition);`
`32`	`32`
`33`	`33`	`public event ProgressChangedHandler ProgressChanged;`
`34`	`34`
`35`		`- public HttpClientDownloadWithProgress(string downloadUrl, string destinationFolderPath, string fallbackFileName, KeyValuePair<string, string>? additionalHeader = null)`
	`35`	`+ public HttpClientDownloadWithProgress(string downloadUrl, string destinationFolderPath, string fallbackFileName, Dictionary<string, string>? additionalHeader = null)`
`36`	`36`	`{`
`37`	`37`	`DownloadUrl = downloadUrl;`
`38`	`38`	`DestinationFolderPath = destinationFolderPath;`
`@@ -42,8 +42,7 @@ public HttpClientDownloadWithProgress(string downloadUrl, string destinationFold`
`42`	`42`
`43`	`43`	`public async Task StartDownload(bool tryResume = false)`
`44`	`44`	`{`
`45`		`- HttpClient = new HttpClient { Timeout = TimeSpan.FromDays(7) };`
`46`		`- CreateHeader();`
	`45`	`+`
`47`	`46`	`if (tryResume)`
`48`	`47`	`{`
`49`	`48`	`InitResume();`
`@@ -55,18 +54,9 @@ public async Task StartDownload(bool tryResume = false)`
`55`	`54`	`File.Delete($"{DestinationFolderPath}\\gamevault-metadata");`
`56`	`55`	`}`
`57`	`56`
`58`		`- using (HttpResponseMessage response = await WebHelper.GetAsync(DownloadUrl, HttpCompletionOption.ResponseHeadersRead))`
	`57`	`+ using (HttpResponseMessage response = await WebHelper.GetAsync(DownloadUrl, AdditionalHeader, HttpCompletionOption.ResponseHeadersRead))`
`59`	`58`	`await DownloadFileFromHttpResponseMessage(response);`
`60`	`59`	`}`
`61`		`- private void CreateHeader()`
`62`		`- {`
`63`		`- string[] auth = WebHelper.GetCredentials();`
`64`		`- HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{auth[0]}:{auth[1]}")));`
`65`		`- HttpClient.DefaultRequestHeaders.Add("User-Agent", $"GameVault/{SettingsViewModel.Instance.Version}");`
`66`		`-`
`67`		`- if (AdditionalHeader != null)`
`68`		`- HttpClient.DefaultRequestHeaders.Add(AdditionalHeader.Value.Key, AdditionalHeader.Value.Value);`
`69`		`- }`
`70`	`60`	`private void InitResume()`
`71`	`61`	`{`
`72`	`62`	`string resumeData = Preferences.Get(AppConfigKey.DownloadProgress, $"{DestinationFolderPath}\\gamevault-metadata");`
`@@ -77,7 +67,11 @@ private void InitResume()`
`77`	`67`	`string[] resumeDataToProcess = resumeData.Split(";");`
`78`	`68`	`ResumePosition = long.Parse(resumeDataToProcess[0]);`
`79`	`69`	`PreResumeSize = long.Parse(resumeDataToProcess[1]);`
`80`		`- HttpClient.DefaultRequestHeaders.Range = new RangeHeaderValue(long.Parse(resumeDataToProcess[0]), null);`
	`70`	`+ if (AdditionalHeader == null)`
	`71`	`+ {`
	`72`	`+ AdditionalHeader = new Dictionary<string, string>();`
	`73`	`+ }`
	`74`	`+ AdditionalHeader?.Add("Range", $"bytes={ResumePosition}-");`
`81`	`75`	`}`
`82`	`76`	`catch { }`
`83`	`77`	`}`
`@@ -206,17 +200,11 @@ public void Cancel()`
`206`	`200`	`return;`
`207`	`201`	`}`
`208`	`202`	`Cancelled = true;`
`209`		`- Dispose();`
`210`	`203`	`}`
`211`	`204`	`public void Pause()`
`212`	`205`	`{`
`213`	`206`	`Paused = true;`
`214`	`207`	`Cancelled = true;`
`215`		`- Dispose();`
`216`		`- }`
`217`		`- public void Dispose()`
`218`		`- {`
`219`		`- HttpClient?.Dispose();`
`220`	`208`	`}`
`221`	`209`	`}`
`222`	`210`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,11 @@ public void InjectTokens(string accessToken, string refreshToken)`
`33`	`33`	`{`
`34`	`34`	`_accessToken = accessToken;`
`35`	`35`	`_refreshToken = refreshToken;`
	`36`	`+ try`
	`37`	`+ {`
	`38`	`+ nextTokenRefresh = GetNextTokenRefresh(_accessToken);`
	`39`	`+ }`
	`40`	`+ catch { }`
`36`	`41`	`}`
`37`	`42`	`public string GetRefreshToken()`
`38`	`43`	`{`
`@@ -60,7 +65,7 @@ public async Task<bool> LoginBasicAuthAsync(string username, string password)`
`60`	`65`	`return true;`
`61`	`66`	`}`
`62`	`67`
`63`		`- private async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, RequestHeader[]? additionalHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead)`
	`68`	`+ private async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, List<RequestHeader>? additionalHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead)`
`64`	`69`	`{`
`65`	`70`	`if (string.IsNullOrEmpty(_accessToken))`
`66`	`71`	`{`
`@@ -82,16 +87,16 @@ private async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, Re`
`82`	`87`	`return await _httpClient.SendAsync(request, option);`
`83`	`88`	`}`
`84`	`89`
`85`		`- public Task<HttpResponseMessage> GetAsync(string url, RequestHeader[]? additionalHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead) =>`
	`90`	`+ public Task<HttpResponseMessage> GetAsync(string url, List<RequestHeader>? additionalHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead) =>`
`86`	`91`	`SendAsync(new HttpRequestMessage(HttpMethod.Get, url), additionalHeaders, option);`
`87`	`92`
`88`		`- public Task<HttpResponseMessage> PostAsync(string url, HttpContent content, RequestHeader[]? additionalHeaders = null) =>`
	`93`	`+ public Task<HttpResponseMessage> PostAsync(string url, HttpContent content, List<RequestHeader>? additionalHeaders = null) =>`
`89`	`94`	`SendAsync(new HttpRequestMessage(HttpMethod.Post, url) { Content = content }, additionalHeaders);`
`90`	`95`
`91`		`- public Task<HttpResponseMessage> PutAsync(string url, HttpContent content, RequestHeader[]? additionalHeaders = null) =>`
	`96`	`+ public Task<HttpResponseMessage> PutAsync(string url, HttpContent content, List<RequestHeader>? additionalHeaders = null) =>`
`92`	`97`	`SendAsync(new HttpRequestMessage(HttpMethod.Put, url) { Content = content }, additionalHeaders);`
`93`	`98`
`94`		`- public Task<HttpResponseMessage> DeleteAsync(string url, RequestHeader[]? additionalHeaders = null) =>`
	`99`	`+ public Task<HttpResponseMessage> DeleteAsync(string url, List<RequestHeader>? additionalHeaders = null) =>`
`95`	`100`	`SendAsync(new HttpRequestMessage(HttpMethod.Delete, url), additionalHeaders);`
`96`	`101`
`97`	`102`	`private async Task<bool> RefreshTokenAsync()`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ internal class WebHelper`
`19`	`19`	`{`
`20`	`20`	`DefaultRequestHeaders = { { "User-Agent", "GameVault" } }`
`21`	`21`	`};`
`22`		`- private static RequestHeader[] AdditionalRequestHeaders;`
	`22`	`+ private static List<RequestHeader> AdditionalRequestHeaders = new List<RequestHeader>();`
`23`	`23`	`static WebHelper() { }`
`24`	`24`	`internal static void SetCredentials(string serverUrl, string username, string password)`
`25`	`25`	`{`
`@@ -47,7 +47,7 @@ internal static string GetRefreshToken()`
`47`	`47`	`{`
`48`	`48`	`return HttpClient.GetRefreshToken();`
`49`	`49`	`}`
`50`		`- internal static void SetAdditionalRequestHeaders(RequestHeader[] additionalRequestHeaders)`
	`50`	`+ internal static void SetAdditionalDefaultRequestHeaders(List<RequestHeader> additionalRequestHeaders)`
`51`	`51`	`{`
`52`	`52`	`AdditionalRequestHeaders = additionalRequestHeaders;`
`53`	`53`
`@@ -62,40 +62,45 @@ internal static void SetAdditionalRequestHeaders(RequestHeader[] additionalReque`
`62`	`62`	`internal static async Task<string> BaseGetAsync(string url)`
`63`	`63`	`{`
`64`	`64`	`var response = await BaseHttpClient.GetAsync(url);`
`65`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`65`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`66`	`66`	`return await response.Content.ReadAsStringAsync();`
`67`	`67`	`}`
`68`	`68`	`internal static async Task<string> BasePostAsync(string url, string payload)`
`69`	`69`	`{`
`70`	`70`	`var content = new StringContent(payload, Encoding.UTF8, "application/json");`
`71`	`71`	`var response = await BaseHttpClient.PostAsync(url, content);`
`72`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`72`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`73`	`73`	`return await response.Content.ReadAsStringAsync();`
`74`	`74`	`}`
`75`	`75`	`internal static async Task<string> BaseSendRequest(HttpRequestMessage request)`
`76`	`76`	`{`
`77`	`77`	`var response = await BaseHttpClient.SendAsync(request);`
`78`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`78`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`79`	`79`	`return await response.Content.ReadAsStringAsync();`
`80`	`80`	`}`
`81`	`81`	`#endregion`
`82`	`82`	`internal static async Task<string> GetAsync(string url)`
`83`	`83`	`{`
`84`	`84`	`var response = await HttpClient.GetAsync(url, AdditionalRequestHeaders);`
`85`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`85`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`86`	`86`	`return await response.Content.ReadAsStringAsync();`
`87`	`87`	`}`
`88`		`- internal static async Task<HttpResponseMessage> GetAsync(string url, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead)`
	`88`	`+ internal static async Task<HttpResponseMessage> GetAsync(string url, Dictionary<string, string>? additionalManualRequestHeaders = null, HttpCompletionOption option = HttpCompletionOption.ResponseContentRead)`
`89`	`89`	`{`
`90`		`- var response = await HttpClient.GetAsync(url, AdditionalRequestHeaders, option);`
`91`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`90`	`+ List<RequestHeader> additionalHeaders = null;`
	`91`	`+ if (additionalManualRequestHeaders is { Count: > 0 })`
	`92`	`+ {`
	`93`	`+ additionalHeaders = additionalManualRequestHeaders.Select(h => new RequestHeader { Name = h.Key, Value = h.Value }).Concat(AdditionalRequestHeaders).ToList();`
	`94`	`+ }`
	`95`	`+ var response = await HttpClient.GetAsync(url, additionalHeaders ?? AdditionalRequestHeaders, option);`
	`96`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`92`	`97`	`return response;`
`93`	`98`	`}`
`94`	`99`	`internal static async Task<string> PostAsync(string url, string payload)`
`95`	`100`	`{`
`96`	`101`	`var content = new StringContent(payload, Encoding.UTF8, "application/json");`
`97`	`102`	`var response = await HttpClient.PostAsync(url, content, AdditionalRequestHeaders);`
`98`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`103`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`99`	`104`	`return await response.Content.ReadAsStringAsync();`
`100`	`105`	`}`
`101`	`106`
`@@ -109,20 +114,20 @@ internal static async Task<string> PutAsync(string url, string payload)`
`109`	`114`	`internal static async Task<string> DeleteAsync(string url)`
`110`	`115`	`{`
`111`	`116`	`var response = await HttpClient.DeleteAsync(url, AdditionalRequestHeaders);`
`112`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`117`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`113`	`118`	`return await response.Content.ReadAsStringAsync();`
`114`	`119`	`}`
`115`	`120`	`public static async Task DownloadImageFromUrlAsync(string imageUrl, string cacheFile)`
`116`	`121`	`{`
`117`	`122`	`var response = await HttpClient.GetAsync(imageUrl, AdditionalRequestHeaders);`
`118`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`123`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`119`	`124`	`var imageBytes = await response.Content.ReadAsByteArrayAsync();`
`120`	`125`	`await File.WriteAllBytesAsync(cacheFile, imageBytes);`
`121`	`126`	`}`
`122`	`127`	`public static async Task<BitmapImage> DownloadImageFromUrlAsync(string imageUrl)`
`123`	`128`	`{`
`124`	`129`	`var response = await HttpClient.GetAsync(imageUrl, AdditionalRequestHeaders);`
`125`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`130`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`126`	`131`	`var imageData = await response.Content.ReadAsByteArrayAsync();`
`127`	`132`	`using (var memoryStream = new MemoryStream(imageData))`
`128`	`133`	`{`
`@@ -135,13 +140,13 @@ public static async Task<BitmapImage> DownloadImageFromUrlAsync(string imageUrl)`
`135`	`140`	`return bitmap;`
`136`	`141`	`}`
`137`	`142`	`}`
`138`		`- public static async Task<string> UploadFileAsync(string apiUrl, Stream imageStream, string fileName, RequestHeader[]? additionalHeaders = null)`
	`143`	`+ public static async Task<string> UploadFileAsync(string apiUrl, Stream imageStream, string fileName, List<RequestHeader>? additionalHeaders = null)`
`139`	`144`	`{`
`140`	`145`	`//Mix request headers`
`141`		`- RequestHeader[]? mixedHeaders = null;`
	`146`	`+ List<RequestHeader>? mixedHeaders = null;`
`142`	`147`	`if (additionalHeaders != null && AdditionalRequestHeaders != null)`
`143`	`148`	`{`
`144`		`- mixedHeaders = AdditionalRequestHeaders.Concat(additionalHeaders).ToArray();`
	`149`	`+ mixedHeaders = AdditionalRequestHeaders.Concat(additionalHeaders).ToList();`
`145`	`150`	`}`
`146`	`151`	`else if (additionalHeaders == null)`
`147`	`152`	`{`
`@@ -158,7 +163,7 @@ public static async Task<string> UploadFileAsync(string apiUrl, Stream imageStre`
`158`	`163`	`imageContent.Headers.ContentType = new MediaTypeHeaderValue(mimeType);`
`159`	`164`	`formData.Add(imageContent, "file", fileName);`
`160`	`165`	`var response = await HttpClient.PostAsync(apiUrl, formData, mixedHeaders);`
`161`		`- await WebExceptionHelper.EnsureSuccessStatusCode(response);`
	`166`	`+ await WebExceptionHelper.EnsureSuccessStatusCode(response);`
`162`	`167`	`var responseContent = await response.Content.ReadAsStringAsync();`
`163`	`168`	`return responseContent;`
`164`	`169`	`}`
`@@ -184,7 +189,7 @@ public static string RemoveSpecialCharactersFromUrl(string url)`
`184`	`189`	`}`
`185`	`190`	`return sb.ToString();`
`186`	`191`	`}`
`187`		`-`
	`192`	`+`
`188`	`193`	`}`
`189`	`194`	`}`
`190`	`195`