chore: update

src-tauri/src/core/backup.rs

@@ -0,0 +1,118 @@
+use crate::config::Config;
+use crate::utils::dirs;
+use anyhow::Error;
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use reqwest_dav::list_cmd::{ListEntity, ListFile};
+use std::env::{consts::OS, temp_dir};
+use std::fs;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::Arc;
+use zip::write::SimpleFileOptions;
+
+pub struct WebDavClient {
+    client: Arc<Mutex<Option<reqwest_dav::Client>>>,
+}
+
+impl WebDavClient {
+    pub fn global() -> &'static WebDavClient {
+        static WEBDAV_CLIENT: OnceCell<WebDavClient> = OnceCell::new();
+        WEBDAV_CLIENT.get_or_init(|| WebDavClient {
+            client: Arc::new(Mutex::new(None)),
+        })
+    }
+
+    async fn get_client(&self) -> Result<reqwest_dav::Client, Error> {
+        if self.client.lock().is_none() {
+            let verge = Config::verge().latest().clone();
+            if verge.webdav_url.is_none()
+                || verge.webdav_username.is_none()
+                || verge.webdav_password.is_none()
+            {
+                let msg =
+                "Unable to create web dav client, please make sure the webdav config is correct"
+                    .to_string();
+                log::error!(target: "app","{}",msg);
+                return Err(anyhow::Error::msg(msg));
+            }
+
+            let url = verge.webdav_url.unwrap_or_default();
+            let username = verge.webdav_username.unwrap_or_default();
+            let password = verge.webdav_password.unwrap_or_default();
+
+            let client = reqwest_dav::ClientBuilder::new()
+                .set_host(url.to_owned())
+                .set_auth(reqwest_dav::Auth::Basic(
+                    username.to_owned(),
+                    password.to_owned(),
+                ))
+                .build()?;
+            *self.client.lock() = Some(client.clone());
+        }
+        Ok(self.client.lock().clone().unwrap())
+    }
+
+    pub fn reset(&self) {
+        if !self.client.lock().is_none() {
+            self.client.lock().take();
+        }
+    }
+
+    pub async fn upload(&self, file_path: PathBuf, file_name: String) -> Result<(), Error> {
+        let client = self.get_client().await?;
+        if client.get(dirs::BACKUP_DIR).await.is_err() {
+            client.mkcol(dirs::BACKUP_DIR).await?;
+        }
+
+        let webdav_path: String = format!("{}/{}", dirs::BACKUP_DIR, file_name);
+        client
+            .put(webdav_path.as_ref(), fs::read(file_path)?)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn list_files(&self) -> Result<Vec<ListFile>, Error> {
+        let client = self.get_client().await?;
+        let files = client
+            .list(dirs::BACKUP_DIR, reqwest_dav::Depth::Number(1))
+            .await?;
+        let mut final_files = Vec::new();
+        for file in files {
+            if let ListEntity::File(file) = file {
+                final_files.push(file);
+            }
+        }
+        Ok(final_files)
+    }
+}
+
+pub fn create_backup() -> Result<(String, PathBuf), Error> {
+    let now = chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string();
+    let zip_file_name = format!("{}-backup-{}.zip", OS, now);
+    let zip_path = temp_dir().join(&zip_file_name);
+
+    let file = fs::File::create(&zip_path)?;
+    let mut zip = zip::ZipWriter::new(file);
+    zip.add_directory("profiles/", SimpleFileOptions::default())?;
+    let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    if let Ok(entries) = fs::read_dir(dirs::app_profiles_dir()?) {
+        for entry in entries {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            if path.is_file() {
+                let backup_path = format!("profiles/{}", entry.file_name().to_str().unwrap());
+                zip.start_file(backup_path, options)?;
+                zip.write_all(fs::read(path).unwrap().as_slice())?;
+            }
+        }
+    }
+    zip.start_file(dirs::CLASH_CONFIG, options)?;
+    zip.write_all(fs::read(dirs::clash_path()?)?.as_slice())?;
+    zip.start_file(dirs::VERGE_CONFIG, options)?;
+    zip.write_all(fs::read(dirs::verge_path()?)?.as_slice())?;
+    zip.start_file(dirs::PROFILE_YAML, options)?;
+    zip.write_all(fs::read(dirs::profiles_path()?)?.as_slice())?;
+    zip.finish()?;
+    Ok((zip_file_name, zip_path))
+}