rnatui 2.0.5

//! Example rust app using the NetActuate API rust library
//!
//! This app is mainly for testing and is just an example
//!
//! # Usage
//! ### Set ENVs
//!
//! ```bash
//! export API_KEY='<your api key>'
//! export API_ADDRESS='https://vapi2.netactuate.com/api/cloud'
//! ```
//!
//! ### Install example client
//! ```rust
//! cargo install rnaapi
//! ```
//!
//! ### There are two forms of output, all server info or a single server's info
//!
//! #### All servers info
//! `rnaapi`
//!
//! ## A single servers info
//! `rnaapi -m <mbpkgid>`
//!
//! That's it.
//!
// Copyright (C) 2025 Dennis Durling
// This file is part of RNAAPI Rust API Client Library, licensed
// under the GNU General Public License v3.0
use anyhow::Result;
use clap::CommandFactory;
use clap::{Parser, Subcommand};
use clap_complete::{Shell, generate};
use rnaapi::NaClient;
use rnaapi::config::Settings;
use rnaapi::endpoints;
use rnaapi::{EndpointGetAll, EndpointGetArgs, EndpointGetOne};

#[tokio::main]
async fn main() -> Result<()> {
    //! Test/Example "main" function, right now it just takes
    //! one argument, `-m <mbpkgid>` if not given, returns all the servers you own

    // Get settings from config
    let settings = Settings::new()?;

    // Defaults
    let mut ssh_keyid: u32 = 0;
    let mut display_count: usize = 0;
    let mut loc_mbpkgid: u32 = 0;
    let mut loc_zoneid: u32 = 0;
    let mut command: &str = "default";

    // parse our args into args
    let cli = Cli::parse();

    // check cli sub commands
    match &cli.cmd {
        Some(Commands::GenerateCompletions { shell }) => {
            let mut app = Cli::command();
            let appclone = app.clone();
            generate(
                *shell,
                &mut app,
                appclone.get_name().to_string(),
                &mut std::io::stdout(),
            );
        }
        Some(Commands::Get { cmd }) => match cmd {
            GetCommands::Server { id } => {
                if *id >= 1 {
                    loc_mbpkgid = *id;
                    command = "server";
                } else {
                    command = "server";
                }
            }
            GetCommands::Dns { id } => {
                if *id >= 1 {
                    loc_zoneid = *id;
                    command = "dns";
                } else {
                    command = "dns";
                }
            }
            GetCommands::Ssh { id } => {
                if *id >= 1 {
                    ssh_keyid = *id;
                    command = "ssh";
                } else {
                    command = "ssh";
                }
            }
            GetCommands::Invoice { count } => {
                display_count = *count;
                command = "invoice";
            }
            GetCommands::Location {} => {
                command = "location";
            }
            GetCommands::Image {} => {
                command = "image";
            }
            GetCommands::Account {} => {
                command = "account";
            }
        },
        _ => {}
    }
    // playing with new constructor for client
    // let na_client = NaClient::new(API_KEY.to_owned(), API_ADDRESS.to_owned()).await;
    let na_client = NaClient::new(settings.api_key, settings.api_url).await;

    if command == "server" {
        if loc_mbpkgid > 0 {
            // submit jobs to the tokio async runtime
            // this automatically awaits so no need for .await
            let (srv, jobs, ipv4s, ipv6s, stat) = tokio::join!(
                endpoints::Server::get_one(
                    &na_client,
                    EndpointGetArgs::OneInt(loc_mbpkgid)
                ),
                endpoints::SrvJob::get_all(
                    &na_client,
                    EndpointGetArgs::OneInt(loc_mbpkgid)
                ),
                endpoints::IPv4::get_all(
                    &na_client,
                    EndpointGetArgs::OneInt(loc_mbpkgid)
                ),
                endpoints::IPv6::get_all(
                    &na_client,
                    EndpointGetArgs::OneInt(loc_mbpkgid)
                ),
                endpoints::SrvStatus::get_one(
                    &na_client,
                    EndpointGetArgs::OneInt(loc_mbpkgid)
                ),
            );

            // print basic server info
            println!(
                "Package: {}, fqdn: {}, mbpkgid: {}",
                srv.clone().unwrap().domu_package,
                srv.clone().unwrap().fqdn,
                srv.clone().unwrap().mbpkgid
            );

            println!();
            // print the job data
            for job in jobs.unwrap() {
                println!(
                    "Inserted: {}, Status: {}, command: {}",
                    job.ts_insert, job.status, job.command
                );
            }

            println!();
            // print IPv4 Addresses
            for ipv4 in ipv4s.unwrap() {
                println!(
                    "Reverse: {}, IP: {}, Gateway: {}",
                    ipv4.reverse, ipv4.ip, ipv4.gateway
                );
            }

            println!();
            // print IPv6 Addresses
            for ipv6 in ipv6s.unwrap() {
                println!(
                    "Reverse: {}, IP: {}, Gateway: {}",
                    ipv6.reverse, ipv6.ip, ipv6.gateway
                );
            }

            println!();
            // print server status, very unverbose
            println!("Status: {}", stat.unwrap().status);
        } else {
            let srvrs =
                endpoints::Server::get_all(&na_client, EndpointGetArgs::NoArgs)
                    .await?;

            for srvr in srvrs {
                println!("ID: {}, fqdn: {}", srvr.mbpkgid, srvr.fqdn);
            }
        }
    } else if command == "dns" {
        if loc_zoneid > 0 {
            println!();
            // // print out the zone name
            let zone = endpoints::Zone::get_one(
                &na_client,
                EndpointGetArgs::OneInt(loc_zoneid),
            )
            .await?;
            println!("Zone: {}", zone.name);

            // print out the SOA for the zone
            let soa = zone.soa.unwrap();
            println!("SOA: {}", soa.primary);

            // print out the first record
            let recs = zone.records.unwrap();
            println!("1st Record: {}", recs[0].name);

            // print out the first NS record
            let nsrecs = zone.ns.unwrap();
            println!("1st NS: {}", nsrecs[0].name)
        } else {
            println!();
            // list dns zones
            let zones =
                endpoints::Zone::get_all(&na_client, EndpointGetArgs::NoArgs)
                    .await?;
            for zone in zones {
                println!(
                    "ID: {}, Size: {}, Name: {}",
                    zone.id, zone.name, zone.zone_type
                );
            }
        }
    } else if command == "ssh" {
        if ssh_keyid > 0 {
            let sshkey = endpoints::SSHKeys::get_one(
                &na_client,
                EndpointGetArgs::OneInt(ssh_keyid),
            )
            .await?;
            println!();
            // print some ssh keys
            println!(
                "ID: {}, Key: {}, Fingerprint: {}",
                sshkey.id, sshkey.name, sshkey.fingerprint
            );
        } else {
            let keys = endpoints::SSHKeys::get_all(
                &na_client,
                EndpointGetArgs::NoArgs,
            )
            .await?;
            println!();
            // print some ssh keys
            for sshkey in keys {
                println!(
                    "ID: {}, Key: {}, Fingerprint: {}",
                    sshkey.id, sshkey.name, sshkey.fingerprint
                );
            }
        }
    } else if command == "location" {
        let locs =
            endpoints::Location::get_all(&na_client, EndpointGetArgs::NoArgs)
                .await?;
        println!();
        // list locations
        for loc in locs {
            println!(
                "ID: {}, Name: {}, Continent: {}",
                loc.id, loc.name, loc.continent
            );
        }
    } else if command == "account" {
        let deets =
            endpoints::Details::get_one(&na_client, EndpointGetArgs::NoArgs)
                .await?;
        println!();
        // print acct details
        println!(
            "FullName: {:?}, Address: {:?}, {:?} {:?} {:?}",
            deets.fullname,
            deets.address1,
            deets.city,
            deets.state,
            deets.postcode
        );
    } else if command == "image" {
        let imgs =
            endpoints::Image::get_all(&na_client, EndpointGetArgs::NoArgs)
                .await?;
        println!();
        // list images
        for img in imgs {
            println!(
                "ID: {}, Size: {}, Name: {}",
                img.id,
                img.size.unwrap_or("null".to_owned()),
                img.os.unwrap_or("null".to_owned())
            );
        }
        println!();
    } else if command == "invoice" {
        let invoices =
            endpoints::Invoices::get_all(&na_client, EndpointGetArgs::NoArgs)
                .await?;
        // print some of the invoices, say 3?
        for invoice in invoices.iter().take(display_count) {
            println!("ID: {}, Status: {}", invoice.id, invoice.status);
        }
    }
    // else {
    //     // submit jobs to the tokio async runtime
    //     // this automatically awaits so no need for .await
    //     let (srvrs, locs, pkgs, imgs, zones, ssh_keys, deets, invoices) = tokio::join!(
    //         endpoints::Server::get_all(&na_client, EndpointGetArgs::NoArgs),
    //         endpoints::Location::get_all(&na_client, EndpointGetArgs::NoArgs),
    //         endpoints::Package::get_all(&na_client, EndpointGetArgs::NoArgs),
    //         endpoints::Image::get_all(&na_client, EndpointGetArgs::NoArgs),
    //         endpoints::Zone::get_all(&na_client, EndpointGetArgs::NoArgs),
    //         endpoints::SSHKeys::get_all(&na_client, EndpointGetArgs::NoArgs),
    //         endpoints::Details::get_one(&na_client, EndpointGetArgs::NoArgs),
    //         endpoints::Invoices::get_all(&na_client, EndpointGetArgs::NoArgs),
    //     );

    //     for srvr in srvrs.unwrap() {
    //         println!("fqdn: {}, mbpkgid: {}", srvr.fqdn, srvr.mbpkgid);
    //     }

    //     println!();
    //     // list locations
    //     for loc in locs.unwrap() {
    //         println!("Name: {}, Continent: {}", loc.name, loc.continent);
    //     }

    //     println!();
    //     // list packages
    //     for pkg in pkgs.unwrap() {
    //         println!("Name: {}, Continent: {}", pkg.name, pkg.city);
    //     }

    //     println!();
    //     // list images
    //     for img in imgs.unwrap() {
    //         println!(
    //             "ID: {}, Size: {}, Name: {}",
    //             img.id,
    //             img.size.unwrap_or("null".to_owned()),
    //             img.os.unwrap_or("null".to_owned())
    //         );
    //     }

    //     println!();
    //     // list dns zones
    //     for zone in zones.unwrap() {
    //         println!(
    //             "ID: {}, Size: {}, Name: {}",
    //             zone.id, zone.name, zone.zone_type
    //         );
    //     }

    //     println!();
    //     // print some ssh keys
    //     for sshkey in ssh_keys.unwrap() {
    //         println!(
    //             "Key: {}, Fingerprint: {}",
    //             sshkey.name, sshkey.fingerprint
    //         );
    //     }

    //     println!();
    //     // print some account deets
    //     println!(
    //         "FullName: {:?}, Address: {:?}, {:?} {:?} {:?}",
    //         deets.clone().unwrap().fullname,
    //         deets.clone().unwrap().address1,
    //         deets.clone().unwrap().city,
    //         deets.clone().unwrap().state,
    //         deets.clone().unwrap().postcode
    //     );

    //     println!();
    //     // print some of the invoices, say 3?
    //     for invoice in invoices.unwrap().iter().take(3) {
    //         println!("ID: {}, Status: {}", invoice.id, invoice.status);
    //     }
    // };

    Ok(())
}

///
/// This is the CLI Args struct
///
#[derive(Parser, Debug)]
#[command(version, about)]
struct Cli {
    #[command(subcommand)]
    cmd: Option<Commands>,
}

#[derive(Subcommand, Debug)]
enum Commands {
    Get {
        #[command(subcommand)]
        cmd: GetCommands,
    },
    /// generate completions
    GenerateCompletions { shell: Shell },
}

#[derive(Subcommand, Debug)]
enum GetCommands {
    /// Server subcommands
    Server {
        // -i argument for picking an mbpkgid
        #[arg(short, long, default_value_t = 0)]
        id: u32,
    },

    /// DNS subcommands
    Dns {
        // -i argument for picking a dns zone
        #[arg(short, long, default_value_t = 0)]
        id: u32,
    },

    // /// Job subcommands
    // Job {
    //     // -i argument for picking a Job
    //     #[arg(short, long, default_value_t = 0)]
    //     id: u32,
    // },
    /// SSh subcommands
    Ssh {
        // -i argument for ssh keyid
        #[arg(short, long, default_value_t = 0)]
        id: u32,
    },

    // /// IPs subcommands
    // Ip {
    //     // --proto argument (-p) for 4 or 6
    //     // default to 4
    //     #[arg(short, long, default_value_t = 4)]
    //     proto: u32,
    // },
    /// Invoices subcommands
    Invoice {
        // -i argument for number to display
        #[arg(short, long, default_value_t = 5)]
        count: usize,
    },

    /// Location subcommands
    Location {},

    /// Images subcommands
    Image {},

    /// Account subcommands
    Account {},
}