twilly_cli 0.2.2

A CLI tool for interacting the Twilio API built upon the twilly crate
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

mod account;
mod conversation;
mod serverless;
mod sync;

use std::{process, str::FromStr};

use inquire::{Confirm, Select};
use strum::IntoEnumIterator;
use twilly::{self, SubResource, TwilioConfig};
use twilly_cli::{prompt_user_selection, request_credentials};

#[tokio::main(flavor = "current_thread")]
async fn main() {
    print_welcome_message();

    let mut loaded_config = false;
    let mut config = confy::load::<TwilioConfig>("twilly", "profile").unwrap_or_else(|err| {
        eprintln!("Unable to load profile configuration: {}", err);
        TwilioConfig {
            ..Default::default()
        }
    });

    if config.account_sid.is_empty() | config.auth_token.is_empty() {
        config = request_credentials();
    } else if Confirm::new(&format!(
        "Account ({}) found in memory. Use this profile?",
        config.account_sid
    ))
    .with_default(true)
    .with_placeholder("Y")
    .prompt()
    .unwrap()
    {
        loaded_config = true;
    } else {
        config = request_credentials();
    }

    let twilio = twilly::Client::new(&config);

    if !loaded_config {
        println!("Checking account...");
        let account = twilio
            .accounts()
            .get(None)
            .await
            .unwrap_or_else(|error| panic!("{}", error));

        println!(
            "✅ Account details good! {} ({} - {})",
            account.friendly_name, account.type_field, account.status
        );

        confy::store("twilly", "profile", &config)
            .unwrap_or_else(|err| eprintln!("Unable to store profile configuration: {}", err));
    }

    loop {
        let mut sub_resource_options: Vec<String> = SubResource::iter()
            .map(|sub_resource| sub_resource.to_string())
            .collect();
        let mut exit_option = vec![String::from("Exit")];
        sub_resource_options.append(&mut exit_option);
        let sub_resource_choice_prompt = Select::new("Select a resource:", sub_resource_options);
        let sub_resource_choice = prompt_user_selection(sub_resource_choice_prompt);

        if sub_resource_choice.is_none() {
            process::exit(0);
        }

        let sub_resource = sub_resource_choice.unwrap();

        // Top level so only 'exit' option.
        if sub_resource == "Exit" {
            process::exit(0);
        }

        let sub_resource = SubResource::from_str(&sub_resource).unwrap();

        match sub_resource {
            twilly::SubResource::Account => account::choose_account_action(&twilio).await,
            twilly::SubResource::Conversations => {
                conversation::choose_conversation_action(&twilio).await
            }
            twilly::SubResource::Sync => sync::choose_sync_resource(&twilio).await,
            twilly::SubResource::Serverless => {
                serverless::choose_serverless_resource(&twilio).await
            }
        }
    }
}

fn print_welcome_message() {
    println!();
    println!();
    println!();
    println!(
        "___________       .__.__  .__         
\\__    ___/_  _  _|__|  | |  | ___.__.
  |    |  \\ \\/ \\/ /  |  | |  |<   |  |
  |    |   \\     /|  |  |_|  |_\\___  |
  |____|    \\/\\_/ |__|____/____/ ____|
                               \\/     "
    );
    println!();
    println!("Welcome to Twilly! I'm here to help you interact with Twilio!");
    println!();
}