feat(#4): add remove command

Author: coffeeispower

src/commands/commit.rs

@@ -16,7 +16,7 @@ fn get_zip_file_path() -> PathBuf {
 }
 pub fn commit() {
     let token = super::expect_token();
-    let app_id = match super::ask_for_app(token.clone()) {
+    let app_id = match super::ask_for_app(token.clone(), "commit") {
         Ok(app_id) => app_id,
         Err(error) => {
             super::err(&format!("Couldn't fetch apps: {}", error));
@@ -131,7 +131,7 @@ fn upload_zip(token: String, app_id: u128) -> Result<(), String> {
                         Ok(())
                     } else {
                         Err(format!(
-                            "Discloud API returned {} http code: {}",
+                            "Commit failed: API returned {} http code: {}",
                             res.status().as_u16(),
                             res.text().unwrap()
                         ))

src/commands/mod.rs

@@ -3,6 +3,7 @@ pub mod commit;
 pub mod init;
 pub mod login;
 pub mod upload;
+pub mod remove;
 use colored::Colorize;
 use dialoguer::{theme::ColorfulTheme, Select};
 use spinners::*;
@@ -70,7 +71,7 @@ mod tests {
         assert_eq!(super::format_warn("Some warnings"), out)
     }
 }
-pub fn ask_for_app(token: String) -> Result<u128, FetchError> {
+pub fn ask_for_app(token: String, action: &str) -> Result<u128, FetchError> {
     let user = crate::entities::user::fetch_user(token.clone())?;
     match user.apps.len() {
         0 => {
@@ -79,14 +80,14 @@ pub fn ask_for_app(token: String) -> Result<u128, FetchError> {
         }
         1 => Ok(user.apps[0].parse().unwrap()),
         _ => {
-            let apps = crate::entities::app::fetch_apps(token)?;
+            let apps = crate::entities::app::App::fetch_all(token)?;
             let options = apps
                 .iter()
                 .map(|app| format!("{}: ({}) {}", app.name, app.lang, app.id))
                 .collect::<Vec<_>>();
             let chosen_opt = Select::with_theme(&ColorfulTheme::default())
                 .items(&options)
-                .with_prompt("Which app you want to commit?")
+                .with_prompt(format!("Which app you want to {}?", action))
                 .interact()
                 .unwrap();
             Ok(apps[chosen_opt].id.parse().unwrap())

src/commands/remove.rs

@@ -0,0 +1,24 @@
+use spinners::*;
+pub fn remove() {
+    let token = super::expect_token();
+    match super::ask_for_app(token.clone(), "delete") {
+        Ok(app_id) => {
+            let mut spinner = Spinner::new(Spinners::Flip, "Deleting your app".into());
+            match crate::entities::app::App::delete(token.clone(), app_id) {
+                Ok(()) => {
+                    spinner.stop_with_message(super::format_log("Your app was successfully nuked!"));
+                }
+                Err(err) => {
+                    super::err(&format!("Couldn't delete your app: {}", err));
+                    std::process::exit(1);
+                }
+            }
+            
+        }
+        Err(err) => {
+            super::err(&format!("Couldn't fetch apps from api: {}", err));
+            std::process::exit(1);
+        }
+    }
+    
+}

src/commands/upload.rs

@@ -128,13 +128,13 @@ fn upload_zip(token: String) -> Result<(), String> {
                     if res.status().is_success() {
                         let res: UploadResponse = res.json().unwrap();
                         if res.status == "error" {
-                            Err(format!("Commit failed: {}", res.message.unwrap()))
+                            Err(format!("Upload failed: {}", res.message.unwrap()))
                         } else {
                             Ok(())
                         }
                     } else {
                         Err(format!(
-                            "Commit failed: API returned {}",
+                            "Upload failed: API returned {}",
                             res.status().as_u16()
                         ))
                     }

src/entities/app.rs

@@ -13,45 +13,62 @@ pub struct App {
     pub main_file: String,
     pub lang: String,
 }
-
-pub fn fetch_app(token: String, id: u128) -> Result<App, FetchError> {
-    #[derive(Deserialize)]
-    struct AppResponse {
-        pub apps: App,
-    }
-    let client = reqwest::blocking::Client::new();
-    let req = client
-        .get(crate::api_url!(format!("/app/{}", id)))
-        .header("api-token", token);
-    match req.send() {
-        Ok(res) => {
-            if res.status().is_success() {
-                Ok(res.json::<AppResponse>().unwrap().apps)
-            } else {
-                Err(FetchError::APIReturnedError(res.status().as_u16()))
+impl App {
+    pub fn fetch_all(token: String) -> Result<Vec<App>, FetchError> {
+        #[derive(Deserialize)]
+        struct AppsResponse {
+            pub apps: Vec<App>,
+        }
+        let client = reqwest::blocking::Client::new();
+        let req = client
+            .get(crate::api_url!("/app/all"))
+            .header("api-token", token);
+        match req.send() {
+            Ok(res) => {
+                if res.status().is_success() {
+                    Ok(res.json::<AppsResponse>().unwrap().apps)
+                } else {
+                    Err(FetchError::APIReturnedError(res.status().as_u16()))
+                }
             }
+            Err(err) => Err(FetchError::FailedToConnect(err)),
         }
-        Err(err) => Err(FetchError::FailedToConnect(err)),
     }
-}
-
-pub fn fetch_apps(token: String) -> Result<Vec<App>, FetchError> {
-    #[derive(Deserialize)]
-    struct AppsResponse {
-        pub apps: Vec<App>,
+    
+    pub fn fetch(token: String, id: u128) -> Result<App, FetchError> {
+        #[derive(Deserialize)]
+        struct AppResponse {
+            pub apps: App,
+        }
+        let client = reqwest::blocking::Client::new();
+        let req = client
+            .get(crate::api_url!(format!("/app/{}", id)))
+            .header("api-token", token);
+        match req.send() {
+            Ok(res) => {
+                if res.status().is_success() {
+                    Ok(res.json::<AppResponse>().unwrap().apps)
+                } else {
+                    Err(FetchError::APIReturnedError(res.status().as_u16()))
+                }
+            }
+            Err(err) => Err(FetchError::FailedToConnect(err)),
+        }
     }
-    let client = reqwest::blocking::Client::new();
-    let req = client
-        .get(crate::api_url!("/app/all"))
-        .header("api-token", token);
-    match req.send() {
-        Ok(res) => {
-            if res.status().is_success() {
-                Ok(res.json::<AppsResponse>().unwrap().apps)
-            } else {
-                Err(FetchError::APIReturnedError(res.status().as_u16()))
+    pub fn delete(token: String, id: u128) -> Result<(), FetchError> {
+        let client = reqwest::blocking::Client::new();
+        let req = client
+            .delete(crate::api_url!(format!("/app/{}/delete", id)))
+            .header("api-token", token);
+            match req.send() {
+            Ok(res) => {
+                if res.status().is_success() {
+                    Ok(())
+                } else {
+                    Err(FetchError::APIReturnedError(res.status().as_u16()))
+                }
             }
+            Err(err) => Err(FetchError::FailedToConnect(err)),
         }
-        Err(err) => Err(FetchError::FailedToConnect(err)),
     }
 }

src/main.rs

@@ -62,6 +62,12 @@ fn main() -> std::io::Result<()> {
             Command::new("commit")
                 .about("Commits to an app on discloud. If you have more than one app, it will ask which app you want to commit to.")
                 .alias("c")
+        )
+        .subcommand(
+            Command::new("remove")
+                .about("Removes an app. If you have more than one app, it will ask which app you want to delete.")
+                .alias("rm")
+                .alias("rb")
         );
     let matches = cmd.get_matches();
     match matches.subcommand() {
@@ -76,6 +82,10 @@ fn main() -> std::io::Result<()> {
             commands::commit::commit();
             Ok(())
         }
+        Some(("remove", _)) => {
+            commands::remove::remove();
+            Ok(())
+        }
         _ => unreachable!(),
     }
 }