Updated

src/main.rs

@@ -32,7 +32,7 @@ use std::io::{self, stderr};
 fn main() -> Result<(), Box<dyn Error>> {
     enable_raw_mode()?;
     let mut stderr = stderr();
-    execute!(stderr, EnterAlternateScreen, EnableMouseCapture)?;
+    execute!(stderr, EnterAlternateScreen)?;
 
     let backend = CrosstermBackend::new(stderr);
     let mut terminal = Terminal::new(backend)?;
@@ -45,11 +45,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let _res = run_app(&mut terminal, &mut app);
 
     disable_raw_mode()?;
-    execute!(
+    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
     terminal.show_cursor()?;
     Ok(())
 }

src/whois/au.rs

@@ -2,22 +2,167 @@ use crate::whois::whois_base::{
     NameServer, RegexQuery, Registrant, RegistrantType, Whois, WhoisData,
 };
 use whois_rust::{WhoIs, WhoIsLookupOptions};
+
+struct Eligibility {
+    e_type: Option<String>,
+    e_name: Option<String>,
+    e_id: Option<String>,
+    r_id: Option<String>,
+}
+
+impl Eligibility {
+    fn new() -> Eligibility {
+        Eligibility {
+            e_id: Some(String::new()),
+            e_name: Some(String::new()),
+            e_type: Some(String::new()),
+            r_id: Some(String::new()),
+        }
+    }
+}
+
 pub struct _Whois {
     base: WhoisData,
-    elegibility: String,
+    eligibility: Eligibility,
 }
 
 impl Whois for _Whois {
     fn new() -> Self {
         _Whois {
             base: WhoisData::new(),
-            elegibility: String::new(),
+            eligibility: Eligibility::new(),
         }
     }
     fn to_vec(&self) -> Vec<String> {
-        vec![String::new()]
+        let mut ret_vec: Vec<String> = vec![];
+        let mut registrar = String::from("Registrar: ");
+        registrar.push_str(&self.base.registrar.clone().unwrap());
+        ret_vec.push(registrar);
+
+        let mut domain_status = String::from("Status: ");
+        domain_status.push_str(&self.base.domain_status.clone().unwrap());
+        ret_vec.push(domain_status);
+
+        let mut dnssec = String::from("DNSSEC: ");
+        dnssec.push_str(&self.base.dnssec.clone().unwrap());
+        ret_vec.push(dnssec);
+
+        let mut registrant_type = String::new();
+        for registrant in &self.base.registrant.clone().unwrap() {
+            match registrant.rtype {
+                RegistrantType::Admin => {
+                    registrant_type.push_str("Admin ");
+                }
+                RegistrantType::Billing => {
+                    registrant_type.push_str("Billing ");
+                }
+                RegistrantType::Tech => {
+                    registrant_type.push_str("Tech ");
+                }
+                RegistrantType::Registrant => {
+                    registrant_type.push_str("Registrant ");
+                }
+            }
+            let mut name = registrant_type.clone();
+            name.push_str("Name: ");
+            name.push_str(&registrant.name);
+            ret_vec.push(name);
+
+            let mut org = registrant_type.clone();
+            org.push_str("Organisation: ");
+            org.push_str(&registrant.org);
+            ret_vec.push(org);
+
+            let mut email = registrant_type.clone();
+            email.push_str("Email: ");
+            email.push_str(&registrant.email);
+            ret_vec.push(email);
+        }
+
+        for nameserver in &self.base.nameservers.clone().unwrap() {
+            let mut tmp = String::from("Nameserver: ");
+            tmp.push_str(&nameserver.host);
+            ret_vec.push(tmp);
+        }
+
+        let mut eligibility_name = String::from("Eligibility Name: ");
+        eligibility_name.push_str(&self.eligibility.e_name.clone().unwrap());
+        ret_vec.push(eligibility_name);
+
+        let mut eligibility_type = String::from("Eligibility Type: ");
+        eligibility_type.push_str(&self.eligibility.e_type.clone().unwrap());
+        ret_vec.push(eligibility_type);
+
+        let mut eligibility_id = String::from("Eligibility ID: ");
+        eligibility_id.push_str(&self.eligibility.e_id.clone().unwrap());
+        ret_vec.push(eligibility_id);
+
+        let mut registrant_id = String::from("Registrant ID: ");
+        registrant_id.push_str(&self.eligibility.r_id.clone().unwrap());
+        ret_vec.push(registrant_id);
+
+        return ret_vec;
     }
     fn lookup(&mut self, domain: String) -> Vec<String> {
+        let whois = WhoIs::from_path("servers.json").unwrap();
+        let result: String = whois
+            .lookup(WhoIsLookupOptions::from_string(domain).unwrap())
+            .unwrap();
+        let registrar_regex =
+            RegexQuery::new(String::from(r"(?i)(.*registrar:|registrar *name:)(.*)"));
+        let domain_status_regex =
+            RegexQuery::new(String::from(r"(?i)(.*domain status:|.*status:)(.* )"));
+        // TODO: Capture the registrant info for each type
+        let registrant_name_regex = RegexQuery::new(String::from(r"(?i)(registrant.*name:)(.*)"));
+        let registrant_org_regex =
+            RegexQuery::new(String::from(r"(?i)(registrant org.*:|registrant:)(.*)"));
+        let registrant_email_regex = RegexQuery::new(String::from(r"(?i)(registrant email:)(.*)"));
+        let nameserver_regex =
+            RegexQuery::new(String::from(r"(?i)(nameservers*:|name servers*:)(.*)"));
+        let dnssec_regex = RegexQuery::new(String::from(r"(?i)(.*dnssec:)(.*)"));
+        let eligebility_name_regex =
+            RegexQuery::new(String::from(r"(?i)(.*eligibility name:)(.*)"));
+        let eligebility_type_regex =
+            RegexQuery::new(String::from(r"(?i)(.*eligibility type:)(.*)"));
+        let eligebility_id_regex = RegexQuery::new(String::from(r"(?i)(.*eligibility id:)(.*)"));
+        let registrant_id_regex = RegexQuery::new(String::from(r"(?i)(.*registrant id:)(.*)"));
+
+        let registrar = WhoisData::return_regex(registrar_regex.get_matches(&result), 0);
+        let domain_status = WhoisData::return_regex(domain_status_regex.get_matches(&result), 0);
+        let reg_name = WhoisData::return_regex(registrant_name_regex.get_matches(&result), 0);
+        let reg_org = WhoisData::return_regex(registrant_org_regex.get_matches(&result), 0);
+        let reg_email = WhoisData::return_regex(registrant_email_regex.get_matches(&result), 0);
+
+        let mut nameservers = vec![];
+        for nameserver in nameserver_regex.get_matches(&result) {
+            nameservers.push(NameServer::new(nameserver));
+        }
+        let mut dnssec = dnssec_regex.get_matches(&result);
+        if dnssec.len() == 0 {
+            dnssec = vec![String::from("Failed to get DNSSEC")];
+        }
+        let eligebility_name =
+            WhoisData::return_regex(eligebility_name_regex.get_matches(&result), 0);
+        let eligebility_type =
+            WhoisData::return_regex(eligebility_type_regex.get_matches(&result), 0);
+        let eligebility_id = WhoisData::return_regex(eligebility_id_regex.get_matches(&result), 0);
+        let registrant_id = WhoisData::return_regex(registrant_id_regex.get_matches(&result), 0);
+
+        // println!("{:?}", registrar[0]);
+        self.base.domain_status = Some(domain_status.clone());
+        self.base.registrant = Some(vec![Registrant::new(
+            reg_name.clone(),
+            reg_org.clone(),
+            reg_email,
+            RegistrantType::Registrant,
+        )]);
+        self.base.nameservers = Some(nameservers);
+        self.base.dnssec = Some(dnssec[0].clone());
+        self.base.registrar = Some(registrar.clone());
+        self.eligibility.e_name = Some(eligebility_name.clone());
+        self.eligibility.e_type = Some(eligebility_type.clone());
+        self.eligibility.e_id = Some(eligebility_id.clone());
+        self.eligibility.r_id = Some(registrant_id.clone());
         self.to_vec()
     }
 }

src/whois/mod.rs

@@ -1,4 +1,5 @@
 pub mod au;
 pub mod default;
 pub mod selector;
+pub mod uk;
 pub mod whois_base;

src/whois/selector.rs

@@ -1,13 +1,16 @@
-use crate::whois::default;
 use addr::parse_domain_name;
 
-use super::{au, whois_base::Whois};
+use super::{au, default, uk, whois_base::Whois};
 
 pub fn select_whois_server(domain: String) -> Result<Box<dyn Whois>, String> {
     let domain = parse_domain_name(&domain.as_str());
     match domain {
         Ok(val) => match val.suffix() {
-            ".com.au" => Ok(Box::new(au::_Whois::new())),
+            "com.au" => Ok(Box::new(au::_Whois::new())),
+            "org.au" => Ok(Box::new(au::_Whois::new())),
+            "net.au" => Ok(Box::new(au::_Whois::new())),
+            "co.uk" => Ok(Box::new(uk::_Whois::new())),
+            "au" => Ok(Box::new(au::_Whois::new())),
             _ => Ok(Box::new(default::_Whois::new())),
         },
         Err(_) => Err(String::from("Failed to select whois server")),

src/whois/uk.rs

@@ -0,0 +1,62 @@
+use crate::whois::whois_base::{
+    NameServer, RegexQuery, Registrant, RegistrantType, Whois, WhoisData,
+};
+use regex::Regex;
+use whois_rust::{WhoIs, WhoIsLookupOptions};
+
+// (.*registrar:\n)(.*)
+
+// (.*name servers:\n)((.*\n)+?^\n)
+
+pub struct _Whois {
+    base: WhoisData,
+}
+
+impl Whois for _Whois {
+    fn new() -> Self
+    where
+        Self: Sized,
+    {
+        _Whois {
+            base: WhoisData::new(),
+        }
+    }
+    fn to_vec(&self) -> Vec<String> {
+        let mut ret_vec: Vec<String> = vec![];
+        let mut registrar = String::from("Registrar: ");
+        registrar.push_str(&self.base.registrar.clone().unwrap());
+        ret_vec.push(registrar);
+
+        return ret_vec;
+    }
+    fn lookup(&mut self, domain: String) -> Vec<String> {
+        let whois = WhoIs::from_path("servers.json").unwrap();
+        let result: String = whois
+            .lookup(WhoIsLookupOptions::from_string(domain).unwrap())
+            .unwrap();
+
+        let registrar_regex = RegexQuery::new(String::from(r"(?mi)(.*registrar:.*\n)(.*?\[)"));
+        let nameserver_regex =
+            RegexQuery::new(String::from(r"(?mi)(.*name servers:\r\n)((.*\r\n))"));
+
+        let registrar = WhoisData::return_regex(registrar_regex.get_matches(&result), 0);
+        // let nameserver_regex = WhoisData::return_regex(self.get_matches(&result), 0);
+
+        self.base.registrar = Some(registrar.clone());
+
+        self.to_vec()
+    }
+}
+
+impl _Whois {
+    pub fn get_matches(&self, haystack: &str, expression: String) -> Vec<String> {
+        let re = Regex::new(&expression).unwrap();
+        let mut results = vec![];
+        for (_, [_, rex2]) in re.captures_iter(haystack).map(|c| c.extract()) {
+            results.push(String::from(rex2.trim()));
+            println!("{:?}", rex2.trim())
+        }
+        println!("{:?}", results);
+        results
+    }
+}