nsg-cli 0.1.1

CLI tool for the Neuroscience Gateway (NSG) BRAIN Initiative API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use anyhow::Result;
use clap::Args;
use colored::Colorize;
use std::io::{self, Write};
use crate::client::NsgClient;
use crate::config::Credentials;

#[derive(Debug, Args)]
pub struct LoginCommand {
    #[arg(short, long, help = "NSG username")]
    username: Option<String>,

    #[arg(short, long, help = "NSG password")]
    password: Option<String>,

    #[arg(short, long, help = "NSG application key")]
    app_key: Option<String>,

    #[arg(long, help = "Skip connection test")]
    no_verify: bool,
}

impl LoginCommand {
    pub fn execute(self) -> Result<()> {
        println!("{}", "NSG Login".bold().cyan());
        println!("{}", "=".repeat(60).cyan());
        println!();

        let username = self.get_or_prompt_username()?;
        let password = self.get_or_prompt_password()?;
        let app_key = self.get_or_prompt_app_key()?;

        println!();
        println!("{} Saving credentials...", "→".cyan());

        let credentials = Credentials::new(username, password, app_key);

        if !self.no_verify {
            println!("{} Testing connection to NSG...", "→".cyan());
            let client = NsgClient::new(credentials.clone())?;

            match client.test_connection() {
                Ok(_) => {
                    println!("{} Connection successful!", "✓".green().bold());
                }
                Err(e) => {
                    eprintln!();
                    eprintln!("{} {}", "✗".red().bold(), "Authentication failed!".red());
                    eprintln!();
                    eprintln!("Error: {}", e);
                    eprintln!();
                    eprintln!("Please check your credentials:");
                    eprintln!("  1. Username and password are correct");
                    eprintln!("  2. Application key is valid");
                    eprintln!("  3. Your NSG account is active");
                    eprintln!();
                    eprintln!("Get credentials at: {}", "https://www.nsgportal.org/".cyan());
                    anyhow::bail!("Login failed");
                }
            }
        }

        credentials.save()?;

        println!();
        println!("{}", "=".repeat(60).green());
        println!("{} {}", "✓".green().bold(), "Login successful!".green().bold());
        println!("{}", "=".repeat(60).green());
        println!();
        println!("Credentials saved to: {}", Credentials::credentials_location().cyan());
        println!();
        println!("You can now use:");
        println!("  {} - List your NSG jobs", "nsg list".cyan());
        println!("  {} - Check job status", "nsg status <job_id>".cyan());
        println!("  {} - Submit a new job", "nsg submit <zip_file> --tool <tool>".cyan());
        println!("  {} - Download job results", "nsg download <job_id>".cyan());
        println!();

        Ok(())
    }

    fn get_or_prompt_username(&self) -> Result<String> {
        if let Some(username) = &self.username {
            return Ok(username.clone());
        }

        print!("NSG Username: ");
        io::stdout().flush()?;

        let mut input = String::new();
        io::stdin().read_line(&mut input)?;
        let username = input.trim().to_string();

        if username.is_empty() {
            anyhow::bail!("Username cannot be empty");
        }

        Ok(username)
    }

    fn get_or_prompt_password(&self) -> Result<String> {
        if let Some(password) = &self.password {
            return Ok(password.clone());
        }

        print!("NSG Password: ");
        io::stdout().flush()?;
        let password = rpassword::read_password()?;

        if password.is_empty() {
            anyhow::bail!("Password cannot be empty");
        }

        Ok(password)
    }

    fn get_or_prompt_app_key(&self) -> Result<String> {
        if let Some(app_key) = &self.app_key {
            return Ok(app_key.clone());
        }

        print!("NSG Application Key: ");
        io::stdout().flush()?;

        let mut input = String::new();
        io::stdin().read_line(&mut input)?;
        let app_key = input.trim().to_string();

        if app_key.is_empty() {
            anyhow::bail!("Application key cannot be empty");
        }

        Ok(app_key)
    }
}