mongodb-command-cli 0.1.1

use crate::errors::Result;
use mongodb::bson::{doc, Array, Bson};

pub mod user {
    pub struct User {
        pub user: String,
        pub pwd: String,
        pub roles: Vec<Role>,
    }

    pub struct Role {
        pub role: String,
        pub db: Option<String>,
    }
}

pub async fn create_user(db: mongodb::Database, new_user: user::User) -> Result<()> {
    let mut roles = Array::new();
    for role in new_user.roles {
        if role.db.is_some() {
            roles.push(Bson::Document(doc! {"role":role.role,"db":role.db}));
        } else {
            roles.push(Bson::Document(doc! {"role":role.role}));
        }
    }
    let command = doc! {
        "createUser": new_user.user,
        "pwd": new_user.pwd,
        "roles": roles,
    };
    let r = db.run_command(command, None).await?;
    println!("{}", r);

    Ok(())
}

pub mod role {

    pub struct Role {
        pub role: String,
    }
}

pub fn create_role(_db: mongodb::Database, _new_role: role::Role) -> Result<()> {
    todo!()
}

#[cfg(test)]
mod tests {

    use serde::Deserialize;

    use super::create_user;
    use crate::utils::ser::{read_json, str_to_bson};

    #[tokio::test]
    async fn test_create_user() {
        let client = mongodb::Client::with_uri_str("mongodb://example.com")
            .await
            .unwrap();
        let db = client.database("admin");
        let new_user = super::user::User {
            user: "zhouyu".to_owned(),
            pwd: "123456".to_owned(),
            roles: vec![super::user::Role {
                role: "readWrite".to_string(),
                db: Some("project".to_string()),
            }],
        };

        let r = create_user(db, new_user).await;

        if r.is_err() {
            let e = r.err().unwrap();
            println!("ERROR {}", e);
        }
    }

    #[tokio::test]
    async fn test_read_json() {
        let v = read_json("commands.json").unwrap();
        for ele in v.as_array().unwrap() {
            let ss = ele.to_string();
            let command = str_to_bson(&ss).unwrap();
            println!("{}\n", command);
        }
    }

    #[tokio::test]
    async fn test_run_command() {
        let client = mongodb::Client::with_uri_str(
            "mongodb://admin:a0QgTFipMt9TbV6bNYX8@192.168.50.5:27017",
        )
        .await
        .unwrap();
        let db = client.database("admin");

        let v = read_json("commands.json").unwrap();
        for ele in v.as_array().unwrap() {
            let ss = ele.to_string();
            let command = str_to_bson(&ss).unwrap();
            println!("{}\n", command);

            let r = db.run_command(command, None).await;

            if r.is_err() {
                let e = r.err().unwrap();
                println!("ERROR {}", e);
            }
        }
    }

    #[derive(Debug, Deserialize)]
    struct Order {
        _name: String,
    }

    #[tokio::test]
    async fn test_query() {
        use mongodb::bson::doc;

        let uri = "mongodb://hello:123456@192.168.50.5:27017";
        let client = mongodb::Client::with_uri_str(uri).await.unwrap();
        let db = client.database("hello");

        let r = db
            .collection::<Order>("world")
            .find_one(doc! {}, None)
            .await;
        if r.is_err() {
            let e = r.err().unwrap();
            println!("ERROR {}", e);
        } else {
            println!("RESULT: {:?}", r.unwrap().unwrap())
        }
    }
}