Backup shortcuts (#144)

* Add initial option to back up shortcuts

* Show list of backups

* Reload backups on change

* Restore backups

* Improve UX of backup ui

* Reorganize ui

* Update version in cargo.toml

* Update flatpak description

* Update cargo-lock.json

src/ui/ui_backup.rs

@@ -0,0 +1,124 @@
+use std::path::{Path, PathBuf};
+
+use chrono::Local;
+use egui::ScrollArea;
+
+use crate::{
+    config::get_backups_flder,
+    steam::{get_shortcuts_paths, SteamSettings},
+};
+
+use super::MyEguiApp;
+
+#[derive(Default)]
+pub struct BackupState {
+    pub available_backups: Option<Vec<PathBuf>>,
+    pub last_restore: Option<PathBuf>,
+}
+
+impl MyEguiApp {
+    pub fn render_backup(&mut self, ui: &mut egui::Ui) {
+        ui.heading("Backups");
+        ui.label("Here you can restore backed up shortcuts files");
+        ui.label("Click a backup to restore it, your current shortcuts will be backed up first");
+        ui.add_space(15.0);
+
+        if let Some(last_restore) = self.backup_state.last_restore.as_ref() {
+            ui.heading(format!("Last restored {:?}", last_restore));
+        }
+
+        if ui.button("Click here to create a new backup").clicked() {
+            backup_shortcuts(&self.settings.steam);
+            self.backup_state.available_backups = None;
+        }
+
+        let available_backups = self
+            .backup_state
+            .available_backups
+            .get_or_insert_with(|| load_backups());
+
+        if available_backups.is_empty() {
+            ui.label("No backups found, they will be created every time you run import");
+        } else {
+            ScrollArea::vertical()
+                .stick_to_right()
+                .auto_shrink([false, true])
+                .show(ui, |ui| {
+                    for backup_path in available_backups {
+                        if ui
+                            .button(backup_path.to_string_lossy().to_string())
+                            .clicked()
+                        {
+                            //Restore
+                            backup_shortcuts(&self.settings.steam);
+                            if restore_backup(&self.settings.steam, backup_path.as_path()) {
+                                self.backup_state.last_restore = Some(backup_path.clone());
+                            }
+                        }
+                    }
+                });
+        }
+
+      
+    }
+}
+
+pub fn restore_backup(steam_settings: &SteamSettings, shortcut_path: &Path) -> bool {
+    let file_name = shortcut_path.file_name().unwrap();
+    let paths = get_shortcuts_paths(steam_settings);
+    if let Ok(paths) = paths {
+        for user in paths {
+            if let Some(user_shortcut_path) = user.shortcut_path {
+                if file_name.to_string_lossy().starts_with(&user.user_id) {
+                    std::fs::copy(shortcut_path, Path::new(&user_shortcut_path)).unwrap();
+                    println!("Restored shortcut to path : {}", user_shortcut_path);
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+pub fn load_backups() -> Vec<PathBuf> {
+    let backup_folder = get_backups_flder();
+    let files = std::fs::read_dir(&backup_folder);
+    let mut result = vec![];
+    if let Ok(files) = files {
+        for file in files {
+            if let Ok(file) = file {
+                if file
+                    .path()
+                    .extension()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    == "vdf"
+                {
+                    result.push(file.path().to_path_buf());
+                }
+            }
+        }
+    }
+    result.sort();
+    result.reverse();
+    return result;
+}
+
+pub fn backup_shortcuts(steam_settings: &SteamSettings) {
+    let backup_folder = get_backups_flder();
+    let paths = get_shortcuts_paths(&steam_settings);
+    let date = Local::now();
+    let date_string = date.format("%Y-%m-%d-%H-%M-%S");
+    if let Ok(user_infos) = paths {
+        for user_info in user_infos {
+            if let Some(shortcut_path) = user_info.shortcut_path {
+                let new_path = backup_folder.join(format!(
+                    "{}-{}-shortcuts.vdf",
+                    user_info.user_id, date_string
+                ));
+                println!("Backed up shortcut at: {:?}", new_path);
+                std::fs::copy(&shortcut_path, &new_path).unwrap();
+            }
+        }
+    }
+}