Add code to dynamically identify the required gist, no need to store its identifier locally. Multiple user support added

Author: marticliment

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

@@ -167,16 +167,16 @@ private async void BackupToGitHubButton_Click(object sender, EventArgs e)
             BackupToGitHubButton.IsEnabled = false;
             DialogHelper.ShowLoadingDialog(CoreTools.Translate("Backing up settings and packages to GitHub Gist..."));
 
-            var settingsContent = await Task.Run(Settings.ExportToString_JSON);
+            // var settingsContent = await Task.Run(Settings.ExportToString_JSON);
             var packagesContent = await InstalledPackagesPage.GenerateBackupContents();
 
-            var filesToBackup = new Dictionary<string, string>
+            /*var filesToBackup = new Dictionary<string, string>
             {
                 { "unigetui.settings.json", settingsContent },
                 { "unigetui.packages.ubundle", packagesContent }
-            };
+            };*/
 
-            bool success = await _backupService.BackupAsync(filesToBackup);
+            bool success = await _backupService.UploadPackageBundle(packagesContent);
 
             DialogHelper.HideLoadingDialog();
 

src/UniGetUI/Services/GitHubBackupService.cs

@@ -3,22 +3,35 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Octokit;
+using UniGetUI.Core.Data;
 using UniGetUI.Core.Logging;
 using UniGetUI.Core.SettingsEngine;
 
 namespace UniGetUI.Services
 {
     public class GitHubBackupService
     {
+        private const string GistDescriptionEndingKey = "#[UNIGETUI_BUNDLE_BACKUP_V1]";
         private readonly GitHubAuthService _authService;
-        private const string GistDescription = "UniGetUI Backup";
+        private const string GistDescription = $"UniGetUI package backups - DO NOT RENAME OR MODIFY {GistDescriptionEndingKey}";
+
+        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 string DeviceUserUniqueIdentifier;
+        private readonly string GistFileKey;
 
         public GitHubBackupService(GitHubAuthService authService)
         {
             _authService = authService;
+            DeviceUserUniqueIdentifier = $"{Environment.MachineName}\\{Environment.UserName}";
+            GistFileKey = $"{DeviceUserUniqueIdentifier}";
         }
 
-        private async Task<GitHubClient?> GetAuthenticatedClientAsync()
+        private async Task<GitHubClient?> CreateClientAsync()
         {
             var token = await _authService.GetAccessTokenAsync();
 
@@ -27,85 +40,92 @@ public GitHubBackupService(GitHubAuthService authService)
                 Logger.Error("GitHub access token is not available. Cannot perform Gist operation.");
                 return null;
             }
-            return new GitHubClient(new ProductHeaderValue("UniGetUI"))
+
+            return new GitHubClient(new ProductHeaderValue("UniGetUI", CoreData.VersionName))
             {
                 Credentials = new Credentials(token)
             };
         }
 
-        public async Task<bool> BackupAsync(Dictionary<string, string> filesToBackup)
+        /// <summary>
+        /// Assuming authentication is set up, upload the given bundleContents to GitHub
+        /// </summary>
+        /// <param name="bundleContents"></param>
+        /// <returns>A boolean representing the success of the operation</returns>
+        public async Task<bool> UploadPackageBundle(string bundleContents)
         {
-            var client = await GetAuthenticatedClientAsync();
-            if (client == null) return false;
+            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();
 
             try
             {
-                var gistId = Settings.GetValue(Settings.K.GitHubGistId);
-                Gist gistToUpdate = null;
-
-                if (!string.IsNullOrEmpty(gistId))
-                {
-                    try
-                    {
-                        gistToUpdate = await client.Gist.Get(gistId);
-                        Logger.Info($"Found existing Gist with ID: {gistId} for update.");
-                    }
-                    catch (NotFoundException)
-                    {
-                        Logger.Warn($"Previously stored Gist ID {gistId} not found. Will create a new Gist.");
-                        Settings.SetValue(Settings.K.GitHubGistId, ""); 
-                        gistId = null;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logger.Error($"Error fetching Gist ID {gistId}: {ex.Message}");
-                        Settings.SetValue(Settings.K.GitHubGistId, "");
-                        gistId = null;
-                    }
-                }
+                var candidates = await GHClient.Gist.GetAllForUser(user.Login);
+                Gist? existingBackup = candidates.FirstOrDefault(g => g.Description.EndsWith(GistDescriptionEndingKey));
 
-                if (gistToUpdate != null)
+                if (existingBackup is null)
                 {
-                    var update = new GistUpdate
-                    {
-                        Description = GistDescription
-                    };
-                    foreach(var file in filesToBackup)
-                    {
-                        update.Files[file.Key] = new GistFileUpdate { Content = file.Value };
-                    }
-                    await client.Gist.Edit(gistId, update);
-                    Logger.Info($"Successfully updated Gist ID: {gistId}");
+                    Logger.Warn($"No matching gist was found as a valid backup, a new gist will be created...");
+                    existingBackup = await _createBackupGistAsync(GHClient);
                 }
-                else
-                {
-                    var newGist = new NewGist
-                    {
-                        Description = GistDescription,
-                        Public = false
-                    };
-                    foreach (var file in filesToBackup)
-                    {
-                        newGist.Files.Add(file.Key, file.Value);
-                    }
 
-                    var createdGist = await client.Gist.Create(newGist);
-                    Settings.SetValue(Settings.K.GitHubGistId, createdGist.Id);
-                    Logger.Info($"Successfully created new Gist ID: {createdGist.Id}");
-                }
+                await _updateBackupGistAsync(GHClient, existingBackup, bundleContents);
+                Logger.Info($"Cloud backup completed successfully to gist {user.Login}/{existingBackup.Id}");
                 return true;
             }
             catch (Exception ex)
             {
-                Logger.Error("Failed to backup to GitHub Gist:");
+                Logger.Error("An error occurred while attempting to upload backup to GitHub:");
                 Logger.Error(ex);
                 return false;
             }
         }
 
+        /// <summary>
+        /// Upload the given payload to the given gist.
+        /// Updates the existing file if GistFileKey exists, creates a new one otherwhise
+        /// </summary>
+        /// <param name="client"></param>
+        /// <param name="gist"></param>
+        /// <param name="payload"></param>
+        private async Task _updateBackupGistAsync(GitHubClient client, Gist gist, string payload)
+        {
+            var update = new GistUpdate { Description = GistDescription };
+            if (update.Files.ContainsKey(GistFileKey))
+            {
+                update.Files[GistFileKey] = new GistFileUpdate { Content = payload };
+            }
+            else
+            {
+                update.Files.Add(GistFileKey, new GistFileUpdate { Content = payload });
+            }
+            await client.Gist.Edit(gist.Id, update);
+            Logger.Info($"Successfully updated Gist ID: {gist.Id}");
+        }
+
+        /// <summary>
+        /// Creates a new Gist, prepared to be detectable by UniGetUI
+        /// </summary>
+        /// <param name="client"></param>
+        /// <returns></returns>
+        private static Task<Gist> _createBackupGistAsync(GitHubClient client)
+        {
+            var newGist = new NewGist
+            {
+                Description = GistDescription,
+                Public = false,
+            };
+            newGist.Files.Add("- UniGetUI Package Backups", ReadMeContents);
+            return client.Gist.Create(newGist);
+        }
+
         public async Task<string?> RetrieveFileAsync(string fileName)
         {
-            var client = await GetAuthenticatedClientAsync();
+            var client = await CreateClientAsync();
             if (client == null) return null;
 
             string fileContent = null;
@@ -131,21 +151,21 @@ public async Task<bool> BackupAsync(Dictionary<string, string> filesToBackup)
                     catch (NotFoundException)
                     {
                         Logger.Warn($"Stored Gist ID {gistId} not found. Will try to find by description.");
-                        Settings.SetValue(Settings.K.GitHubGistId, ""); 
-                        gistId = null; 
+                        Settings.SetValue(Settings.K.GitHubGistId, "");
+                        gistId = null;
                     }
                     catch (Exception ex)
                     {
                         Logger.Error($"Error fetching Gist ID {gistId}: {ex.Message}. Will try to find by description.");
                         Settings.SetValue(Settings.K.GitHubGistId, "");
-                        gistId = null; 
+                        gistId = null;
                     }
                 }
 
-                if (fileContent == null) 
+                if (fileContent == null)
                 {
                     Logger.Info("Attempting to find settings Gist by description...");
-                    var gists = await client.Gist.GetAll(); 
+                    var gists = await client.Gist.GetAll();
                     var settingsGist = gists.FirstOrDefault(g => g.Description == GistDescription && g.Files.ContainsKey(fileName));
 
                     if (settingsGist != null)
@@ -154,7 +174,7 @@ public async Task<bool> BackupAsync(Dictionary<string, string> filesToBackup)
                         if (fullGist.Files.TryGetValue(fileName, out var file) && file != null)
                         {
                             fileContent = file.Content;
-                            Settings.SetValue(Settings.K.GitHubGistId, fullGist.Id); 
+                            Settings.SetValue(Settings.K.GitHubGistId, fullGist.Id);
                             Logger.Info($"Found settings Gist by description. ID: {fullGist.Id}");
                         }
                         else
@@ -165,7 +185,7 @@ public async Task<bool> BackupAsync(Dictionary<string, string> filesToBackup)
                     else
                     {
                         Logger.Warn($"No UniGetUI settings Gist found for the user with file {fileName}.");
-                        return null; 
+                        return null;
                     }
                 }
 
@@ -185,4 +205,4 @@ public async Task<bool> BackupAsync(Dictionary<string, string> filesToBackup)
             }
         }
     }
-}
+}