feat(mods): add mods add <id> command

Author: coffeeispower

Cargo.lock

@@ -1,3 +1,4 @@
+pub mod mods;
 pub mod aboutme;
 pub mod logs;
 pub mod stop;

src/commands/mod.rs

@@ -0,0 +1,20 @@
+use crate::{commands::{expect_token, ask_for_app}, entities::{moderator::{Mod, Feature}, app::App, user::fetch_user}};
+macro_rules! handle_result {
+    ($v:expr) => {
+        match $v {
+            Ok(v) => v,
+            Err(err) => {
+                super::err(&err.to_string());
+                std::process::exit(1);
+            }
+        }
+    }
+}
+pub fn add(id: u128) {
+    let token = expect_token();
+    let app_id = handle_result!(ask_for_app(token.clone(), "add a moderator"));
+    let app = handle_result!(App::fetch(token.clone(), app_id));
+    let user = handle_result!(fetch_user(token.clone()));
+    let moderator = handle_result!(Mod::new(token.clone(), &user, &app, vec![Feature::SeeLogs, Feature::Status]));
+    super::log(&format!("Permissions {:?} have been given to {}", moderator.get_features(), id));
+}

src/commands/mods/add.rs

@@ -0,0 +1,2 @@
+pub mod add;
+use super::*;

src/commands/mods/mod.rs

@@ -147,4 +147,6 @@ impl App {
             Err(err) => Err(FetchError::FailedToConnect(err)),
         }
     }
+
+    
 }

src/entities/app.rs

@@ -1,3 +1,4 @@
+pub mod moderator;
 use std::fmt::Display;
 
 pub mod app;

src/entities/mod.rs

@@ -0,0 +1,91 @@
+use std::fmt::Debug;
+
+use serde::{Deserialize, Serialize};
+use serde_enum_str::*;
+
+use super::{user::User, app::App, FetchError};
+#[derive(Deserialize_enum_str, Serialize_enum_str, Clone)]
+pub enum Feature {
+    #[serde(rename = "start_app")]
+    Start,
+    #[serde(rename = "stop_app")]
+    Stop,
+    #[serde(rename = "restart_app")]
+    Restart,
+    #[serde(rename = "logs_app")]
+    SeeLogs,
+    #[serde(rename = "commit_app")]
+    Commit,
+    #[serde(rename = "status_app")]
+    Status,
+    #[serde(rename = "edit_ram")]
+    SetRam,
+    #[serde(rename = "backup_app")]
+    Backup
+}
+impl Debug for Feature {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(
+            match self {
+                Self::Backup => "backup",
+                Self::Commit => "commit",
+                Self::Restart => "restart",
+                Self::SeeLogs => "logs",
+                Self::SetRam => "ram",
+                Self::Start => "start",
+                Self::Status => "status",
+                Self::Stop => "stop"
+            }
+        )
+    }
+}
+#[derive(Deserialize, Serialize)]
+pub struct Mod {
+    #[serde(rename = "mod_id")]
+    user_id: u128,
+    #[serde(rename = "perms")]
+    features: Vec<Feature>
+}
+impl Mod {
+    pub fn new(token: String, user: &User, app: &App, features: Vec<Feature>) -> Result<Mod, FetchError> {
+        let moderator = Self {
+            user_id: user.user_id.parse().unwrap(),
+            features
+        };
+        moderator.add_to(token, app)?;
+        Ok(moderator)
+    }
+    pub fn get_features(&self) -> Vec<Feature> {
+        self.features.clone()
+    }
+    pub fn add_to(&self, token: String, app: &App) -> Result<(), FetchError>{
+        #[derive(Deserialize)]
+        struct Response {
+            status: String,
+            message: Option<String>
+        }
+        let client = reqwest::blocking::Client::new();
+        let req = client
+            .post(crate::api_url!(format!("/app/{}/team", app.id)))
+            .header("api-token", token)
+            .json(self);
+        match req.send() {
+            Ok(res) => {
+                match res.json::<Response>() {
+                    Err(err) => {
+                        Err(FetchError::FailedWithMessage(err.to_string()))
+                    }
+                    Ok(response) => {
+                        if response.status == "ok" {
+                            Ok(())
+                        } else {
+                            Err(FetchError::FailedWithMessage(response.message.unwrap()))
+                        }
+                    }
+                }
+                
+            }
+            Err(err) => Err(FetchError::FailedToConnect(err)),
+        }
+    }
+}

src/entities/moderator.rs

@@ -101,6 +101,19 @@ fn main() -> std::io::Result<()> {
             Command::new("aboutme")
                 .about("Shows information about you.")
                 .alias("user")
+        )
+        .subcommand(
+            Command::new("mods")
+                .about("Manages your apps' mods")
+                .subcommand_required(true)
+                .arg_required_else_help(true)
+                .alias("m")
+                .subcommand(
+                    Command::new("add")
+                        .about("Adds a mod to an app, by default, the mod can only see the logs and status, use `discloud mods allow` to allow more actions.")
+                        .arg(Arg::new("id").value_parser(value_parser!(u128)).action(clap::ArgAction::Set).required(true))
+                )
+                .after_help("Be careful with what people you add and what permissions you give: With Great Power comes Great Responsability.")
         );
     let matches = cmd.get_matches();
     match matches.subcommand() {
@@ -144,6 +157,16 @@ fn main() -> std::io::Result<()> {
             commands::aboutme::aboutme();
             Ok(())
         }
+        Some(("mods", matches)) => {
+            match matches.subcommand() {
+                Some(("add", matches)) => {
+                    let id: u128 = *matches.get_one("id").unwrap();
+                    commands::mods::add::add(id);
+                    Ok(())
+                }
+                _ => unreachable!()
+            }
+        }
         _ => unreachable!(),
     }
 }