Refactored the Cloud Save status messages

Yelo420 · Yelo420 · commit be380fb7f36f · 2025-03-08T13:16:08.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # GameVault App Changelog
 
+## 1.16.1
+Recommended Gamevault Server Version: `v14.1.0`
+### Changes
+
+- Bug fix: Custom Cloud Save config is not applied to 'find' action
+- Bug fix: Cloud Save Backup/Restore not working on windows username with space in it
+
 ## 1.16.0
 Recommended Gamevault Server Version: `v14.1.0`
 ### 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.16.0.0")]
+[assembly: AssemblyVersion("1.16.1.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
@@ -55,10 +55,10 @@ internal SaveGameHelper()
         {
             zipHelper = new SevenZipHelper();
         }
-        internal async Task<CloudSaveStatus> RestoreBackup(int gameId, string installationDir)
+        internal async Task<string> RestoreBackup(int gameId, string installationDir)
         {
             if (!LoginManager.Instance.IsLoggedIn() || !SettingsViewModel.Instance.License.IsActive())
-                return CloudSaveStatus.Failed;
+                return CloudSaveStatus.RestoreFailed;
 
             if (!SettingsViewModel.Instance.CloudSaves)
                 return CloudSaveStatus.SettingDisabled;
@@ -109,7 +109,7 @@ internal async Task<CloudSaveStatus> RestoreBackup(int gameId, string installati
                             process.WaitForExit();
                             ProcessShepherd.Instance.RemoveProcess(process);
                             Directory.Delete(tempFolder, true);
-                            return CloudSaveStatus.Success;
+                            return CloudSaveStatus.RestoreSuccess;
                         }
                         else
                         {
@@ -122,15 +122,15 @@ internal async Task<CloudSaveStatus> RestoreBackup(int gameId, string installati
                     string statusCode = WebExceptionHelper.GetServerStatusCode(ex);
                     if (statusCode == "405")
                     {
-                        MainWindowViewModel.Instance.AppBarText = "Cloud Saves are not enabled on this Server.";
+                        MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.ServerSettingDisabled;
                     }
                     else if (statusCode != "404")
                     {
-                        MainWindowViewModel.Instance.AppBarText = "Failed to restore cloud save";
+                        MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.RestoreFailed;
                     }
                 }
             }
-            return CloudSaveStatus.Failed;
+            return CloudSaveStatus.RestoreFailed;
         }
         private string GetGameInstallationId(string installationDir)
         {
@@ -148,46 +148,25 @@ internal async Task BackupSaveGamesFromIds(List<int> gameIds)
             var removedIds = runningGameIds.Except(gameIds).ToList();
 
             foreach (var removedId in removedIds)
-            {               
+            {
                 if (!SettingsViewModel.Instance.CloudSaves || !SettingsViewModel.Instance.License.IsActive())
                 {
                     break;
                 }
                 if (!LoginManager.Instance.IsLoggedIn())
                 {
-                    MainWindowViewModel.Instance.AppBarText = "Can not synchronize the cloud saves, because you are offline";
+                    MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.Offline;
                     break;
                 }
                 try
                 {
                     MainWindowViewModel.Instance.AppBarText = "Uploading Savegame to the Server...";
-                    CloudSaveStatus status = await BackupSaveGame(removedId);
-                    switch (status)
-                    {
-                        case CloudSaveStatus.Success:
-                            {
-                                MainWindowViewModel.Instance.AppBarText = "Successfully synchronized the cloud saves";
-                                break;
-                            }
-                        case CloudSaveStatus.BackupCreationFailed:
-                            {
-                                MainWindowViewModel.Instance.AppBarText = "Failed to create a copy of your Savegame";
-                                break;
-                            }
-                        case CloudSaveStatus.BackupUploadFailed:
-                            {
-                                MainWindowViewModel.Instance.AppBarText = "Failed to upload your Savegame to the Server";
-                                break;
-                            }
-                        case CloudSaveStatus.Failed:
-                            {
-                                MainWindowViewModel.Instance.AppBarText = "Something went wrong during the Backup";
-                                break;
-                            }
-                    }
+                    string status = await BackupSaveGame(removedId);
+                    MainWindowViewModel.Instance.AppBarText = status;
                 }
                 catch (Exception ex)
                 {
+                    MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.BackupFailed;
                 }
             }
 
@@ -198,13 +177,13 @@ internal async Task BackupSaveGamesFromIds(List<int> gameIds)
             // Remove IDs that are no longer in the new list
             runningGameIds = runningGameIds.Intersect(gameIds).ToList();
         }
-        internal async Task<CloudSaveStatus> BackupSaveGame(int gameId)
+        internal async Task<string> BackupSaveGame(int gameId)
         {
             if (!SettingsViewModel.Instance.CloudSaves)
                 return CloudSaveStatus.SettingDisabled;
 
             if (!SettingsViewModel.Instance.License.IsActive())
-                return CloudSaveStatus.Failed;
+                return CloudSaveStatus.BackupFailed;
 
             var installedGame = InstallViewModel.Instance?.InstalledGames?.FirstOrDefault(g => g.Key?.ID == gameId);
             string gameMetadataTitle = installedGame?.Key?.Metadata?.Title ?? "";
@@ -214,7 +193,7 @@ internal async Task<CloudSaveStatus> BackupSaveGame(int gameId)
                 PrepareConfigFile(installedGame?.Value!, Path.Combine(AppFilePath.CloudSaveConfigDir, "config.yaml"));
                 string title = await SearchForLudusaviGameTitle(gameMetadataTitle);
                 if (string.IsNullOrEmpty(title))
-                    return CloudSaveStatus.Failed;
+                    return CloudSaveStatus.BackupFailed;
 
                 string tempFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
                 Directory.CreateDirectory(tempFolder);
@@ -229,9 +208,9 @@ internal async Task<CloudSaveStatus> BackupSaveGame(int gameId)
 
                 bool success = await UploadSavegame(archive, gameId, installationDir);
                 Directory.Delete(tempFolder, true);
-                return success ? CloudSaveStatus.Success : CloudSaveStatus.BackupUploadFailed;
+                return success ? CloudSaveStatus.BackupSuccess : CloudSaveStatus.BackupUploadFailed;
             }
-            return CloudSaveStatus.Failed;
+            return CloudSaveStatus.BackupFailed;
         }
         public void PrepareConfigFile(string installationPath, string yamlPath)
         {
@@ -402,14 +381,20 @@ private ProcessStartInfo CreateProcessHeader(bool redirectConsole = false)
             return info;
         }
     }
-    public enum CloudSaveStatus
+    public struct CloudSaveStatus
     {
-        Success,
-        Failed,
-        UpToDate,
-        SettingDisabled,
-        BackupCreationFailed,
-        BackupUploadFailed
+        public static string BackupSuccess = "Successfully synchronized the cloud saves";
+        public static string BackupFailed = "Something went wrong during the Backup";
+        public static string BackupCreationFailed = "Failed to create a copy of your Savegame";
+        public static string BackupUploadFailed = "Failed to upload your Savegame to the Server";
+
+        public static string RestoreSuccess = "Successfully synchronized the cloud save";
+        public static string RestoreFailed = "Failed to restore the Savegame";
+        public static string UpToDate = "Your Savegame is up to date";
+
+        public static string SettingDisabled = "Activate Cloud Saves under Settings -> GameVault+ -> Cloud Saves";
+        public static string ServerSettingDisabled = "Cloud Saves are not enabled on this Server";
+        public static string Offline = "Can not synchronize the cloud saves, because you are offline";
     }
     public class LudusaviManifestEntry
     {
diff --git a/gamevault/UserControls/GameViewUserControl.xaml.cs b/gamevault/UserControls/GameViewUserControl.xaml.cs
@@ -407,7 +407,7 @@ private void Share_Click(object sender, RoutedEventArgs e)
         private async void BackupCloudSaves_Click(object sender, RoutedEventArgs e)
         {
             try
-            {             
+            {
                 if (!SettingsViewModel.Instance.License.IsActive())
                 {
                     MainWindowViewModel.Instance.SetActiveControl(MainControl.Settings);
@@ -416,44 +416,17 @@ private async void BackupCloudSaves_Click(object sender, RoutedEventArgs e)
                 }
                 if (!LoginManager.Instance.IsLoggedIn())
                 {
-                    MainWindowViewModel.Instance.AppBarText = "Can not synchronize the cloud saves, because you are offline";
+                    MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.Offline;
                     return;
                 }
                 MainWindowViewModel.Instance.AppBarText = "Uploading Savegame to the Server...";
                 ((FrameworkElement)sender).IsEnabled = false;
-                CloudSaveStatus status = await SaveGameHelper.Instance.BackupSaveGame(ViewModel!.Game!.ID);
-                switch (status)
-                {
-                    case CloudSaveStatus.Success:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Successfully synchronized the cloud saves";
-                            break;
-                        }
-                    case CloudSaveStatus.BackupCreationFailed:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Failed to get your Savegame";
-                            break;
-                        }
-                    case CloudSaveStatus.BackupUploadFailed:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Failed to upload your Savegame to the Server";
-                            break;
-                        }
-                    case CloudSaveStatus.SettingDisabled:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Activate Cloud Saves under Settings -> GameVault+ -> Cloud Saves";
-                            break;
-                        }
-                    case CloudSaveStatus.Failed:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Something went wrong during the backup";
-                            break;
-                        }
-                }
+                string status = await SaveGameHelper.Instance.BackupSaveGame(ViewModel!.Game!.ID);
+                MainWindowViewModel.Instance.AppBarText = status;
             }
             catch
             {
-                MainWindowViewModel.Instance.AppBarText = "Failed to Upload your Savegame to the Server";
+                MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.BackupFailed;
             }
             ((FrameworkElement)sender).IsEnabled = true;
         }
@@ -470,34 +443,12 @@ private async void RestoreCloudSaves_Click(object sender, RoutedEventArgs e)
                 MainWindowViewModel.Instance.AppBarText = $"Syncing cloud save...";
                 ((FrameworkElement)sender).IsEnabled = false;
                 string installationDir = InstallViewModel.Instance.InstalledGames.First(g => g.Key.ID == ViewModel!.Game!.ID).Value;
-                CloudSaveStatus status = await SaveGameHelper.Instance.RestoreBackup(ViewModel!.Game!.ID, installationDir);
-                switch (status)
-                {
-                    case CloudSaveStatus.Success:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Successfully synchronized the cloud save";
-                            break;
-                        }
-                    case CloudSaveStatus.UpToDate:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Your Savegame is up to date";
-                            break;
-                        }
-                    case CloudSaveStatus.SettingDisabled:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Activate Cloud Saves under Settings -> GameVault+ -> Cloud Saves";
-                            break;
-                        }
-                    case CloudSaveStatus.Failed:
-                        {
-                            MainWindowViewModel.Instance.AppBarText = "Failed to restore the Savegame";
-                            break;
-                        }
-                }
+                string status = await SaveGameHelper.Instance.RestoreBackup(ViewModel!.Game!.ID, installationDir);
+                MainWindowViewModel.Instance.AppBarText = status;
             }
             catch
             {
-                MainWindowViewModel.Instance.AppBarText = "Failed to restore the Savegame";
+                MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.RestoreFailed;
             }
             ((FrameworkElement)sender).IsEnabled = true;
         }

Original file line number	Diff line number	Diff line change
`@@ -55,10 +55,10 @@ internal SaveGameHelper()`
`55`	`55`	`{`
`56`	`56`	`zipHelper = new SevenZipHelper();`
`57`	`57`	`}`
`58`		`- internal async Task<CloudSaveStatus> RestoreBackup(int gameId, string installationDir)`
	`58`	`+ internal async Task<string> RestoreBackup(int gameId, string installationDir)`
`59`	`59`	`{`
`60`	`60`	`if (!LoginManager.Instance.IsLoggedIn() \|\| !SettingsViewModel.Instance.License.IsActive())`
`61`		`- return CloudSaveStatus.Failed;`
	`61`	`+ return CloudSaveStatus.RestoreFailed;`
`62`	`62`
`63`	`63`	`if (!SettingsViewModel.Instance.CloudSaves)`
`64`	`64`	`return CloudSaveStatus.SettingDisabled;`
`@@ -109,7 +109,7 @@ internal async Task<CloudSaveStatus> RestoreBackup(int gameId, string installati`
`109`	`109`	`process.WaitForExit();`
`110`	`110`	`ProcessShepherd.Instance.RemoveProcess(process);`
`111`	`111`	`Directory.Delete(tempFolder, true);`
`112`		`- return CloudSaveStatus.Success;`
	`112`	`+ return CloudSaveStatus.RestoreSuccess;`
`113`	`113`	`}`
`114`	`114`	`else`
`115`	`115`	`{`
`@@ -122,15 +122,15 @@ internal async Task<CloudSaveStatus> RestoreBackup(int gameId, string installati`
`122`	`122`	`string statusCode = WebExceptionHelper.GetServerStatusCode(ex);`
`123`	`123`	`if (statusCode == "405")`
`124`	`124`	`{`
`125`		`- MainWindowViewModel.Instance.AppBarText = "Cloud Saves are not enabled on this Server.";`
	`125`	`+ MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.ServerSettingDisabled;`
`126`	`126`	`}`
`127`	`127`	`else if (statusCode != "404")`
`128`	`128`	`{`
`129`		`- MainWindowViewModel.Instance.AppBarText = "Failed to restore cloud save";`
	`129`	`+ MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.RestoreFailed;`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`	`}`
`133`		`- return CloudSaveStatus.Failed;`
	`133`	`+ return CloudSaveStatus.RestoreFailed;`
`134`	`134`	`}`
`135`	`135`	`private string GetGameInstallationId(string installationDir)`
`136`	`136`	`{`
`@@ -148,46 +148,25 @@ internal async Task BackupSaveGamesFromIds(List<int> gameIds)`
`148`	`148`	`var removedIds = runningGameIds.Except(gameIds).ToList();`
`149`	`149`
`150`	`150`	`foreach (var removedId in removedIds)`
`151`		`- {`
	`151`	`+ {`
`152`	`152`	`if (!SettingsViewModel.Instance.CloudSaves \|\| !SettingsViewModel.Instance.License.IsActive())`
`153`	`153`	`{`
`154`	`154`	`break;`
`155`	`155`	`}`
`156`	`156`	`if (!LoginManager.Instance.IsLoggedIn())`
`157`	`157`	`{`
`158`		`- MainWindowViewModel.Instance.AppBarText = "Can not synchronize the cloud saves, because you are offline";`
	`158`	`+ MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.Offline;`
`159`	`159`	`break;`
`160`	`160`	`}`
`161`	`161`	`try`
`162`	`162`	`{`
`163`	`163`	`MainWindowViewModel.Instance.AppBarText = "Uploading Savegame to the Server...";`
`164`		`- CloudSaveStatus status = await BackupSaveGame(removedId);`
`165`		`- switch (status)`
`166`		`- {`
`167`		`- case CloudSaveStatus.Success:`
`168`		`- {`
`169`		`- MainWindowViewModel.Instance.AppBarText = "Successfully synchronized the cloud saves";`
`170`		`- break;`
`171`		`- }`
`172`		`- case CloudSaveStatus.BackupCreationFailed:`
`173`		`- {`
`174`		`- MainWindowViewModel.Instance.AppBarText = "Failed to create a copy of your Savegame";`
`175`		`- break;`
`176`		`- }`
`177`		`- case CloudSaveStatus.BackupUploadFailed:`
`178`		`- {`
`179`		`- MainWindowViewModel.Instance.AppBarText = "Failed to upload your Savegame to the Server";`
`180`		`- break;`
`181`		`- }`
`182`		`- case CloudSaveStatus.Failed:`
`183`		`- {`
`184`		`- MainWindowViewModel.Instance.AppBarText = "Something went wrong during the Backup";`
`185`		`- break;`
`186`		`- }`
`187`		`- }`
	`164`	`+ string status = await BackupSaveGame(removedId);`
	`165`	`+ MainWindowViewModel.Instance.AppBarText = status;`
`188`	`166`	`}`
`189`	`167`	`catch (Exception ex)`
`190`	`168`	`{`
	`169`	`+ MainWindowViewModel.Instance.AppBarText = CloudSaveStatus.BackupFailed;`
`191`	`170`	`}`
`192`	`171`	`}`
`193`	`172`
`@@ -198,13 +177,13 @@ internal async Task BackupSaveGamesFromIds(List<int> gameIds)`
`198`	`177`	`// Remove IDs that are no longer in the new list`
`199`	`178`	`runningGameIds = runningGameIds.Intersect(gameIds).ToList();`
`200`	`179`	`}`
`201`		`- internal async Task<CloudSaveStatus> BackupSaveGame(int gameId)`
	`180`	`+ internal async Task<string> BackupSaveGame(int gameId)`
`202`	`181`	`{`
`203`	`182`	`if (!SettingsViewModel.Instance.CloudSaves)`
`204`	`183`	`return CloudSaveStatus.SettingDisabled;`
`205`	`184`
`206`	`185`	`if (!SettingsViewModel.Instance.License.IsActive())`
`207`		`- return CloudSaveStatus.Failed;`
	`186`	`+ return CloudSaveStatus.BackupFailed;`
`208`	`187`
`209`	`188`	`var installedGame = InstallViewModel.Instance?.InstalledGames?.FirstOrDefault(g => g.Key?.ID == gameId);`
`210`	`189`	`string gameMetadataTitle = installedGame?.Key?.Metadata?.Title ?? "";`
`@@ -214,7 +193,7 @@ internal async Task<CloudSaveStatus> BackupSaveGame(int gameId)`
`214`	`193`	`PrepareConfigFile(installedGame?.Value!, Path.Combine(AppFilePath.CloudSaveConfigDir, "config.yaml"));`
`215`	`194`	`string title = await SearchForLudusaviGameTitle(gameMetadataTitle);`
`216`	`195`	`if (string.IsNullOrEmpty(title))`
`217`		`- return CloudSaveStatus.Failed;`
	`196`	`+ return CloudSaveStatus.BackupFailed;`
`218`	`197`
`219`	`198`	`string tempFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());`
`220`	`199`	`Directory.CreateDirectory(tempFolder);`
`@@ -229,9 +208,9 @@ internal async Task<CloudSaveStatus> BackupSaveGame(int gameId)`
`229`	`208`
`230`	`209`	`bool success = await UploadSavegame(archive, gameId, installationDir);`
`231`	`210`	`Directory.Delete(tempFolder, true);`
`232`		`- return success ? CloudSaveStatus.Success : CloudSaveStatus.BackupUploadFailed;`
	`211`	`+ return success ? CloudSaveStatus.BackupSuccess : CloudSaveStatus.BackupUploadFailed;`
`233`	`212`	`}`
`234`		`- return CloudSaveStatus.Failed;`
	`213`	`+ return CloudSaveStatus.BackupFailed;`
`235`	`214`	`}`
`236`	`215`	`public void PrepareConfigFile(string installationPath, string yamlPath)`
`237`	`216`	`{`
`@@ -402,14 +381,20 @@ private ProcessStartInfo CreateProcessHeader(bool redirectConsole = false)`
`402`	`381`	`return info;`
`403`	`382`	`}`
`404`	`383`	`}`
`405`		`- public enum CloudSaveStatus`
	`384`	`+ public struct CloudSaveStatus`
`406`	`385`	`{`
`407`		`- Success,`
`408`		`- Failed,`
`409`		`- UpToDate,`
`410`		`- SettingDisabled,`
`411`		`- BackupCreationFailed,`
`412`		`- BackupUploadFailed`
	`386`	`+ public static string BackupSuccess = "Successfully synchronized the cloud saves";`
	`387`	`+ public static string BackupFailed = "Something went wrong during the Backup";`
	`388`	`+ public static string BackupCreationFailed = "Failed to create a copy of your Savegame";`
	`389`	`+ public static string BackupUploadFailed = "Failed to upload your Savegame to the Server";`
	`390`	`+`
	`391`	`+ public static string RestoreSuccess = "Successfully synchronized the cloud save";`
	`392`	`+ public static string RestoreFailed = "Failed to restore the Savegame";`
	`393`	`+ public static string UpToDate = "Your Savegame is up to date";`
	`394`	`+`
	`395`	`+ public static string SettingDisabled = "Activate Cloud Saves under Settings -> GameVault+ -> Cloud Saves";`
	`396`	`+ public static string ServerSettingDisabled = "Cloud Saves are not enabled on this Server";`
	`397`	`+ public static string Offline = "Can not synchronize the cloud saves, because you are offline";`
`413`	`398`	`}`
`414`	`399`	`public class LudusaviManifestEntry`
`415`	`400`	`{`