Kordophone/kpcli/src/client/mod.rs

use kordophone::APIInterface;
use kordophone::api::http_client::HTTPAPIClient;
use kordophone::api::http_client::Credentials;
use kordophone::api::InMemoryTokenStore;

use dotenv;
use anyhow::Result;
use clap::Subcommand;
use crate::printers::{ConversationPrinter, MessagePrinter};

pub fn make_api_client_from_env() -> HTTPAPIClient<InMemoryTokenStore> {
    dotenv::dotenv().ok();

    // read from env
    let base_url = std::env::var("KORDOPHONE_API_URL")
        .expect("KORDOPHONE_API_URL must be set");

    let credentials = Credentials {
        username: std::env::var("KORDOPHONE_USERNAME")
            .expect("KORDOPHONE_USERNAME must be set"),

        password: std::env::var("KORDOPHONE_PASSWORD")
            .expect("KORDOPHONE_PASSWORD must be set"),
    };

    HTTPAPIClient::new(base_url.parse().unwrap(), credentials.into(), InMemoryTokenStore::new())
}

#[derive(Subcommand)]
pub enum Commands {
    /// Prints all known conversations on the server.
    Conversations,

    /// Prints all messages in a conversation.
    Messages {
        conversation_id: String,
    },

    /// Prints the server Kordophone version.
    Version,
}

impl Commands {
    pub async fn run(cmd: Commands) -> Result<()> {
        let mut client = ClientCli::new();
        match cmd {
            Commands::Version => client.print_version().await,
            Commands::Conversations => client.print_conversations().await,
            Commands::Messages { conversation_id } => client.print_messages(conversation_id).await,
        }
    }
}

struct ClientCli {
    api: HTTPAPIClient<InMemoryTokenStore>,
}

impl ClientCli {
    pub fn new() -> Self {
        let api = make_api_client_from_env();
        Self { api: api }
    }

    pub async fn print_version(&mut self) -> Result<()> {
        let version = self.api.get_version().await?;
        println!("Version: {}", version);
        Ok(())
    }

    pub async fn print_conversations(&mut self) -> Result<()> {
        let conversations = self.api.get_conversations().await?;
        for conversation in conversations {
            println!("{}", ConversationPrinter::new(&conversation.into()));
        }

        Ok(())
    }

    pub async fn print_messages(&mut self, conversation_id: String) -> Result<()> {
        let messages = self.api.get_messages(&conversation_id).await?;
        for message in messages {
            println!("{}", MessagePrinter::new(&message.into()));
        }
        Ok(())
    }
}