feat: install packages extensions by reading its type and add uninstall extension feature

Author: kimlimjustin

src-tauri/src/extensions.rs

@@ -285,7 +285,7 @@ pub fn install_themes(extension_path: PathBuf) {
   let current_extension_config = storage::read_data("extensions".to_string());
   let current_extension_config = match current_extension_config {
     Ok(config) => {
-      if config.status {
+      if config.status && config.data.is_object() {
         config.data
       } else {
         serde_json::json!({})
@@ -300,13 +300,18 @@ pub fn install_themes(extension_path: PathBuf) {
     Some(_) => current_extension_config,
     None => {
       let mut current_extension_config = current_extension_config.clone();
-      current_extension_config["themes"] = serde_json::json!([]);
+      // Create themes key on current extension config
+      current_extension_config
+        .as_object_mut()
+        .unwrap()
+        .insert("themes".to_string(), serde_json::json!({}));
       current_extension_config
     }
   };
 
   let themes = current_extension_config.get("themes").unwrap();
-  let themes = themes.as_array().unwrap();
+  let empty_vec = Vec::new();
+  let themes = themes.as_array().unwrap_or(&empty_vec);
 
   // Remove theme if already installed
   let mut themes = themes
@@ -327,3 +332,96 @@ pub fn install_themes(extension_path: PathBuf) {
     .insert("themes".to_string(), serde_json::json!(themes));
   storage::write_data("extensions".to_string(), current_extension_config);
 }
+
+pub fn install_extensions(extension_path: PathBuf) {
+  let extension_file: Result<serde_json::Value, serde_json::Error> = serde_json::from_str(
+    std::fs::read_to_string(extension_path.clone())
+      .unwrap()
+      .as_str(),
+  );
+  let extension_information = match extension_file {
+    Ok(file) => file,
+    Err(_) => {
+      panic!("Error parsing extension file");
+    }
+  };
+
+  // Check the type of packaged extension
+  if extension_information
+    .get("extensionType")
+    .unwrap_or(&serde_json::Value::Null)
+    != "theme"
+  {
+    panic!("Only theme extension is supported right now");
+  }
+  install_themes(extension_path);
+}
+
+pub fn uninstall_extensions(extension_identifier: String) {
+  let extensions = storage::read_data("extensions".to_string());
+  let mut extensions = match extensions {
+    Ok(config) => {
+      if config.status {
+        config.data
+      } else {
+        serde_json::json!({})
+      }
+    }
+    Err(_) => {
+      serde_json::json!({})
+    }
+  };
+  // Iterate on every object of extensions and iterate extensions key of the object and remove the extension
+  let mut extensions = extensions.as_object_mut().unwrap().clone();
+  let mut new_extensions = serde_json::json!({}).as_object_mut().unwrap().clone();
+  for (key, value) in extensions {
+    let value = value.as_array().unwrap().clone();
+    let new_value = value
+      .iter()
+      .filter(|ext| {
+        let _empty_string = serde_json::Value::String("".to_string());
+        let ext_identifier = ext.get("identifier").unwrap_or(&_empty_string);
+        if key == "themes" && ext_identifier == &extension_identifier {
+          let theme = storage::read_data("theme".to_string());
+          let theme = match theme {
+            Ok(config) => {
+              if config.status {
+                config.data
+              } else {
+                serde_json::json!({})
+              }
+            }
+            Err(_) => {
+              serde_json::json!({})
+            }
+          };
+          let theme = theme.as_object().unwrap().clone();
+          let current_active_theme = theme
+            .get("theme")
+            .unwrap_or(&serde_json::Value::String("".to_string()))
+            .to_string();
+
+          let current_active_theme =
+            current_active_theme.split("@").collect::<Vec<_>>()[0].to_string();
+          // If the current_active_theme starts with unused " character, remove it
+          let current_active_theme = if current_active_theme.starts_with("\"") {
+            current_active_theme.split_at(1).1.to_string()
+          } else {
+            current_active_theme
+          };
+          let current_active_theme = serde_json::Value::String(current_active_theme);
+          if &current_active_theme == ext_identifier {
+            storage::write_data(
+              "theme".to_string(),
+              serde_json::json!({"theme": "System Default"}),
+            );
+          }
+        }
+        ext_identifier != &extension_identifier
+      })
+      .cloned()
+      .collect::<Vec<_>>();
+    new_extensions.insert(key.to_string(), serde_json::json!(new_value));
+  }
+  storage::write_data("extensions".to_string(), serde_json::json!(new_extensions));
+}

src-tauri/src/main.rs

@@ -58,6 +58,24 @@ lazy_static! {
                       .multiple_values(false),
                   ),
               ),
+          )
+          .subcommand(
+            App::new("install")
+              .about("Install extension from packaged json file")
+              .arg(
+                Arg::new("extension")
+                  .about("Packaged extension file")
+                  .takes_value(true)
+                  .multiple_values(false),
+              ),
+          )
+          .subcommand(
+            App::new("uninstall").about("Uninstall extension").arg(
+              Arg::new("extension")
+                .about("Extension identifier")
+                .takes_value(true)
+                .multiple_values(true),
+            ),
           ),
       )
       .arg(
@@ -124,8 +142,8 @@ fn change_transparent_effect(effect: String, window: tauri::Window) {
 fn main() {
   // Extensions stuff
   if ARGS_STRUCT.subcommand_matches("extensions").is_some() {
-    let extension_type = ARGS_STRUCT.subcommand_matches("extensions").unwrap();
-    match extension_type.subcommand_matches("theme") {
+    let extension_cmd = ARGS_STRUCT.subcommand_matches("extensions").unwrap();
+    match extension_cmd.subcommand_matches("theme") {
       Some(theme_command) => {
         match theme_command.subcommand_matches("build") {
           Some(theme_build_info) => {
@@ -183,6 +201,37 @@ fn main() {
       }
       None => {}
     }
+    match extension_cmd.subcommand_matches("install") {
+      Some(extension_install_info) => {
+        let extension = extension_install_info.value_of("extension");
+        if extension.is_some() {
+          let extension = extension.unwrap();
+          let extension = Path::new(extension);
+          if extension.exists() && extension.is_file() {
+            extensions::install_extensions(extension.to_path_buf())
+          } else {
+            panic!("Extension file not found");
+          }
+        } else {
+          panic!("No extension specified");
+        }
+        std::process::exit(0);
+      }
+      None => {}
+    }
+    match extension_cmd.subcommand_matches("uninstall") {
+      Some(extension_uninstall_info) => {
+        let extension = extension_uninstall_info.value_of("extension");
+        if extension.is_some() {
+          let extension = extension.unwrap();
+          extensions::uninstall_extensions(extension.to_string());
+        } else {
+          panic!("No extension specified");
+        }
+        std::process::exit(0);
+      }
+      None => {}
+    }
   }
   tauri::Builder::default()
     .invoke_handler(tauri::generate_handler![