Add the ability to fetch all available packages

Author: marticliment

src/UniGetUI/Pages/SettingsPages/GeneralPages/Backup.xaml

@@ -113,15 +113,15 @@
                 x:Name="BackupToGitHubButton"
                 ButtonText="Backup settings and packages"
                 Click="BackupToGitHubButton_Click"
-                CornerRadius="8"
+                CornerRadius="8,8,0,0"
                 IsEnabled="False"
                 Text="Backup your settings and packages to a private GitHub Gist">
                 <widgets:ButtonCard.Description>
                     <widgets:TranslatedTextBlock Text="Requires you to be logged in with your GitHub account." />
                 </widgets:ButtonCard.Description>
             </widgets:ButtonCard>
 
-            <widgets:ButtonCard
+            <!--widgets:ButtonCard
                 x:Name="RestoreSettingsFromGitHubButton"
                 ButtonText="Restore settings"
                 Click="RestoreSettingsFromGitHubButton_Click"
@@ -131,13 +131,14 @@
                 <widgets:ButtonCard.Description>
                     <widgets:TranslatedTextBlock Text="This will overwrite your current settings. A restart may be required." />
                 </widgets:ButtonCard.Description>
-            </widgets:ButtonCard>
+            </widgets:ButtonCard-->
 
             <widgets:ButtonCard
                 x:Name="RestorePackagesFromGitHubButton"
                 ButtonText="Restore packages"
                 Click="RestorePackagesFromGitHubButton_Click"
-                CornerRadius="8"
+                CornerRadius="0,0,8,8"
+                BorderThickness="1,0,1,1"
                 IsEnabled="False"
                 Text="Restore your packages from a private GitHub Gist">
                 <widgets:ButtonCard.Description>
@@ -147,4 +148,4 @@
 
         </StackPanel>
     </ScrollViewer>
-</Page>
+</Page>

src/UniGetUI/Pages/SettingsPages/GeneralPages/Backup.xaml.cs

@@ -90,11 +90,11 @@ private async void UpdateBackupToGitHubButtonStatus()
             UpdateGitHubLoginStatus();
             bool isAuthenticated = await _authService.IsAuthenticatedAsync();
             BackupToGitHubButton.IsEnabled = isAuthenticated;
-            RestoreSettingsFromGitHubButton.IsEnabled = isAuthenticated;
+            // nRestoreSettingsFromGitHubButton.IsEnabled = isAuthenticated;
             RestorePackagesFromGitHubButton.IsEnabled = isAuthenticated;
         }
 
-        private async void RestoreSettingsFromGitHubButton_Click(object sender, EventArgs e)
+        /*private async void RestoreSettingsFromGitHubButton_Click(object sender, EventArgs e)
         {
             RestoreSettingsFromGitHubButton.IsEnabled = false;
             var confirmDialog = DialogHelper.DialogFactory.Create();
@@ -112,7 +112,7 @@ private async void RestoreSettingsFromGitHubButton_Click(object sender, EventArg
             }
 
             DialogHelper.ShowLoadingDialog(CoreTools.Translate("Restoring settings from GitHub Gist..."));
-            var settingsContent = await _backupService.RetrieveFileAsync("unigetui.settings.json");
+            var settingsContent = "";//await _backupService.RetrieveFileAsync("unigetui.settings.json");
             if (settingsContent != null)
             {
                 await Task.Run(() => Settings.ImportFromString_JSON(settingsContent));
@@ -134,21 +134,33 @@ private async void RestoreSettingsFromGitHubButton_Click(object sender, EventArg
                 _ = DialogHelper.Window.ShowDialogAsync(errorDialog);
             }
             UpdateBackupToGitHubButtonStatus();
-        }
+        }*/
 
         private async void RestorePackagesFromGitHubButton_Click(object sender, EventArgs e)
         {
             RestorePackagesFromGitHubButton.IsEnabled = false;
-            var packagesContent = await _backupService.RetrieveFileAsync("unigetui.packages.ubundle");
-            if (packagesContent != null)
+            try
             {
-                MainApp.Instance.MainWindow.NavigationPage.LoadBundleFromString(packagesContent, BundleFormatType.UBUNDLE, "GitHub Gist");
+                var b = await _backupService.GetAvailableBackups();
+
+                var errorDialog = DialogHelper.DialogFactory.Create();
+                errorDialog.Title = CoreTools.Translate("Select backup:");
+                errorDialog.Content = CoreTools.Translate(" - " + (string.Join("\n - ", b)));
+                errorDialog.PrimaryButtonText = CoreTools.Translate("OK");
+                errorDialog.DefaultButton = ContentDialogButton.Primary;
+                await DialogHelper.Window.ShowDialogAsync(errorDialog);
+                RestorePackagesFromGitHubButton.IsEnabled = true;
+                return;
+
+
+                MainApp.Instance.MainWindow.NavigationPage.LoadBundleFromString("", BundleFormatType.UBUNDLE, "GitHub Gist");
+
                 Logger.Info("Successfully loaded package bundle from GitHub Gist.");
                 DialogHelper.ShowDismissableBalloon(
-                    CoreTools.Translate("Backup retrieved successfully!"),
+                    CoreTools.Translate("Backup loaded successfully!"),
                     CoreTools.Translate("The package bundle has been loaded into the Package Bundles page."));
             }
-            else
+            catch (Exception ex)
             {
                 DialogHelper.HideLoadingDialog();
                 Logger.Error("Failed to restore packages from GitHub Gist.");
@@ -157,45 +169,40 @@ private async void RestorePackagesFromGitHubButton_Click(object sender, EventArg
                 errorDialog.Content = CoreTools.Translate("Could not restore packages from GitHub Gist. Please check the logs for more details, or ensure a backup exists.");
                 errorDialog.PrimaryButtonText = CoreTools.Translate("OK");
                 errorDialog.DefaultButton = ContentDialogButton.Primary;
-                _ = DialogHelper.Window.ShowDialogAsync(errorDialog);
+                await DialogHelper.Window.ShowDialogAsync(errorDialog);
             }
             UpdateBackupToGitHubButtonStatus();
         }
 
         private async void BackupToGitHubButton_Click(object sender, EventArgs e)
         {
             BackupToGitHubButton.IsEnabled = false;
-            DialogHelper.ShowLoadingDialog(CoreTools.Translate("Backing up settings and packages to GitHub Gist..."));
+            DialogHelper.ShowLoadingDialog(CoreTools.Translate("Backing up packages to GitHub Gist..."));
 
-            // var settingsContent = await Task.Run(Settings.ExportToString_JSON);
             var packagesContent = await InstalledPackagesPage.GenerateBackupContents();
 
-            /*var filesToBackup = new Dictionary<string, string>
-            {
-                { "unigetui.settings.json", settingsContent },
-                { "unigetui.packages.ubundle", packagesContent }
-            };*/
-
-            bool success = await _backupService.UploadPackageBundle(packagesContent);
-
-            DialogHelper.HideLoadingDialog();
-
-            if (success)
+            try
             {
+                await _backupService.UploadPackageBundle(packagesContent);
+                DialogHelper.HideLoadingDialog();
                 Logger.Info("Successfully backed up settings and packages to GitHub Gist.");
                 DialogHelper.ShowDismissableBalloon(
                     CoreTools.Translate("Backup Successful"),
                     CoreTools.Translate("Your settings and packages have been successfully backed up to GitHub Gist."));
             }
-            else
+            catch (Exception ex)
             {
-                Logger.Error("Failed to backup settings or packages to GitHub Gist.");
+                DialogHelper.HideLoadingDialog();
+
+                Logger.Error("An error occurred while uploading the backup:");
+                Logger.Error(ex);
+
                 var dialog = DialogHelper.DialogFactory.Create();
                 dialog.Title = CoreTools.Translate("Backup Failed");
-                dialog.Content = CoreTools.Translate("Could not back up settings and/or packages to GitHub Gist. Please check the logs for more details.");
+                dialog.Content = CoreTools.Translate("Could not back up packages to GitHub Gist: ") + ex.Message;
                 dialog.PrimaryButtonText = CoreTools.Translate("OK");
                 dialog.DefaultButton = ContentDialogButton.Primary;
-                _ = DialogHelper.Window.ShowDialogAsync(dialog);
+                await DialogHelper.Window.ShowDialogAsync(dialog);
             }
             UpdateBackupToGitHubButtonStatus();
         }

src/UniGetUI/Services/GitHubBackupService.cs

@@ -6,29 +6,33 @@
 using UniGetUI.Core.Data;
 using UniGetUI.Core.Logging;
 using UniGetUI.Core.SettingsEngine;
+using UniGetUI.Core.Tools;
 
 namespace UniGetUI.Services
 {
     public class GitHubBackupService
     {
-        private const string GistDescriptionEndingKey = "#[UNIGETUI_BUNDLE_BACKUP_V1]";
-        private readonly GitHubAuthService _authService;
-        private const string GistDescription = $"UniGetUI package backups - DO NOT RENAME OR MODIFY {GistDescriptionEndingKey}";
+        private const string GistDescription_EndingKey = "#[UNIGETUI_BACKUP_V1]";
+        private const string PackageBackup_StartingKey = "#[PACKAGES]";
 
+        private const string GistDescription = $"UniGetUI package backups - DO NOT RENAME OR MODIFY {GistDescription_EndingKey}";
         private const string ReadMeContents = "" +
               "This special Gist is used by UniGetUI to store your package backups. \n" +
               "Please DO NOT EDIT the contents or the description of this gist, or unexpected behaviours may occur.\n" +
               "Learn more about UniGetUI at https://github.com/marticliment/UniGetUI\n";
 
 
+
+        private readonly GitHubAuthService _authService;
+
         private readonly string DeviceUserUniqueIdentifier;
         private readonly string GistFileKey;
 
         public GitHubBackupService(GitHubAuthService authService)
         {
             _authService = authService;
             DeviceUserUniqueIdentifier = $"{Environment.MachineName}\\{Environment.UserName}".Replace(" ", "");
-            GistFileKey = $"PACKAGES {DeviceUserUniqueIdentifier}";
+            GistFileKey = $"{PackageBackup_StartingKey} {DeviceUserUniqueIdentifier}";
         }
 
         private async Task<GitHubClient?> CreateClientAsync()
@@ -52,42 +56,30 @@ public GitHubBackupService(GitHubAuthService authService)
         /// </summary>
         /// <param name="bundleContents"></param>
         /// <returns>A boolean representing the success of the operation</returns>
-        public async Task<bool> UploadPackageBundle(string bundleContents)
+        public async Task UploadPackageBundle(string bundleContents)
         {
             var GHClient = await CreateClientAsync();
-            if (GHClient == null)
-            {
-                Logger.Error("Upload of backup has been aborted since the user is not authenticated");
-                return false;
-            }
-            User user = await GHClient.User.Current();
+            if (GHClient is null)
+                throw new Exception("The GitHub user is not authenticated");
 
-            try
-            {
-                var candidates = await GHClient.Gist.GetAllForUser(user.Login);
-                Gist? existingBackup = candidates.FirstOrDefault(g => g.Description.EndsWith(GistDescriptionEndingKey));
+            User user = await GHClient.User.Current();
 
-                if (existingBackup is null)
-                {
-                    Logger.Warn($"No matching gist was found as a valid backup, a new gist will be created...");
-                    existingBackup = await _createBackupGistAsync(GHClient);
-                }
+            var candidates = await GHClient.Gist.GetAllForUser(user.Login);
+            Gist? existingBackup = candidates.FirstOrDefault(g => g.Description.EndsWith(GistDescription_EndingKey));
 
-                await _updateBackupGistAsync(GHClient, existingBackup, bundleContents);
-                Logger.Info($"Cloud backup completed successfully to gist {user.Login}/{existingBackup.Id}");
-                return true;
-            }
-            catch (Exception ex)
+            if (existingBackup is null)
             {
-                Logger.Error("An error occurred while attempting to upload backup to GitHub:");
-                Logger.Error(ex);
-                return false;
+                Logger.Warn($"No matching gist was found as a valid backup, a new gist will be created...");
+                existingBackup = await _createBackupGistAsync(GHClient);
             }
+
+            await _updateBackupGistAsync(GHClient, existingBackup, bundleContents);
+            Logger.Info($"Cloud backup completed successfully to gist {user.Login}/{existingBackup.Id}");
         }
 
         /// <summary>
         /// Upload the given payload to the given gist.
-        /// Updates the existing file if GistFileKey exists, creates a new one otherwhise
+        /// Updates the existing file if GistFileKey exists, creates a new one otherwhise.
         /// </summary>
         /// <param name="client"></param>
         /// <param name="gist"></param>
@@ -108,7 +100,7 @@ private async Task _updateBackupGistAsync(GitHubClient client, Gist gist, string
         }
 
         /// <summary>
-        /// Creates a new Gist, prepared to be detectable by UniGetUI
+        /// Creates a new Gist, prepared to be detectable by UniGetUI, and with the base readme file
         /// </summary>
         /// <param name="client"></param>
         /// <returns></returns>
@@ -123,7 +115,30 @@ private static Task<Gist> _createBackupGistAsync(GitHubClient client)
             return client.Gist.Create(newGist);
         }
 
-        public async Task<string?> RetrieveFileAsync(string fileName)
+        /// <summary>
+        /// Retrieves a list of available backups to import
+        /// </summary>
+        /// <param name="client"></param>
+        /// <returns></returns>
+        public async Task<IEnumerable<string>> GetAvailableBackups()
+        {
+            var GHClient = await CreateClientAsync();
+            if (GHClient is null)
+                throw new Exception("The GitHub user is not authenticated");
+
+
+            User user = await GHClient.User.Current();
+
+            var candidates = await GHClient.Gist.GetAllForUser(user.Login);
+            Gist? existingBackup = candidates.FirstOrDefault(g => g.Description.EndsWith(GistDescription_EndingKey));
+
+            return existingBackup?.Files
+                .Where(f => f.Key.StartsWith(PackageBackup_StartingKey))
+                .Select(f => $"{f.Key.Split(' ')[^1]} ({CoreTools.FormatAsSize(f.Value.Size)})") ?? [];
+        }
+
+
+        /*public async Task<string?> RetrieveFileAsync(string fileName)
         {
             var client = await CreateClientAsync();
             if (client == null) return null;
@@ -203,6 +218,6 @@ private static Task<Gist> _createBackupGistAsync(GitHubClient client)
                 Logger.Error(ex);
                 return null;
             }
-        }
+        }*/
     }
 }