rfham-cli 0.1.0

CLI for accessing RF-Ham tools.
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

use crate::{OnceCommand, error::CliError};
use colored::Colorize;
use rfham_core::Name;
use rfham_core::callsign::CallSign;
use rfham_itu::callsigns::ItuSeriesAllocation;
use std::process::ExitCode;
use std::str::FromStr;

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

#[derive(Debug)]
pub struct ValidateCallSign {
    callsign: String,
}

#[derive(Debug)]
#[allow(dead_code)] // TODO: implement in services
pub struct LookupCallSign {
    callsign: String,
    service: Option<Name>,
}

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

impl OnceCommand for ValidateCallSign {
    type Output = ExitCode;
    type Error = CliError;

    fn execute(self) -> Result<Self::Output, Self::Error> {
        if let Ok(callsign) = CallSign::from_str(&self.callsign) {
            println!(
                "Callsign {:?} {}:",
                self.callsign,
                "is valid".bold().green()
            );
            if let Some(a_prefix) = callsign.ancillary_prefix() {
                println!("└── ancillary prefix: {}", a_prefix);
            }
            println!("└── prefix: {}", callsign.prefix());
            if let Some(allocation) = ItuSeriesAllocation::from_callsign(&callsign) {
                println!("    └── ITU allocation; {allocation:#}");
            } else {
                println!("    └── ITU allocation; Unknown/unallocated");
                println!(
                    "    └── is non-standard: {}",
                    callsign.is_prefix_non_standard()
                );
            }
            println!("└── separator numeral: {}", callsign.separator_numeral());
            println!("└── suffix: {}", callsign.suffix());
            println!("    └── is special: {}", callsign.is_special());
            if let Some(a_suffix) = callsign.ancillary_suffix() {
                println!("└── ancillary suffix: {}", a_suffix);
                println!("    └── is portable: {}", callsign.is_portable());
                println!("    └── is mobile: {}", callsign.is_mobile());
                println!(
                    "    └── is aeronautical mobile: {}",
                    callsign.is_aeronautical_mobile()
                );
                println!(
                    "    └── is maritime mobile: {}",
                    callsign.is_maritime_mobile()
                );
                println!(
                    "    └── is at alternate location: {}",
                    callsign.is_at_alternate_location()
                );
                println!("    └── is operating QRP: {}", callsign.is_operating_qrp());
                println!(
                    "    └── FCC license pending: {}",
                    callsign.is_fcc_license_pending()
                );
            }
        } else {
            println!(
                "Callsign {:?} {}",
                self.callsign,
                "is not valid".bold().red()
            );
        }
        Ok(ExitCode::SUCCESS)
    }
}

impl ValidateCallSign {
    pub fn new(callsign: String) -> Self {
        Self { callsign }
    }
}
// ------------------------------------------------------------------------------------------------

impl OnceCommand for LookupCallSign {
    type Output = ExitCode;
    type Error = CliError;

    fn execute(self) -> Result<Self::Output, Self::Error> {
        Ok(ExitCode::SUCCESS)
    }
}

impl LookupCallSign {
    pub fn new(callsign: String, service: Option<Name>) -> Self {
        Self { callsign, service }
    }
}