authentication overhaul

src/request.rs

@@ -7,28 +7,55 @@ use crate::config::Configuration;
 
 pub struct Request<'a> {
     pub client: Client,
-    pub arg_value: Vec<&'a str>,
+    pub arg_value: ArgMatches<'a>,
     pub map: HashMap<String, String>,
     pub url: Option<String>,
+    pub authentication: Authentication,
 }
 
 pub struct Authentication {
     pub basic: bool,
     pub api_token: bool,
+    pub credentials: (Option<String>, Option<String>)
 }
 
-impl Request<'static> {
-    fn new() -> Request<'static> {
+impl<'a> Request<'a> {
+    /// Public constructor for a request with a simple username and password
+    pub fn with_basic_request(
+        config: Configuration, 
+        arg: ArgMatches,
+        auth: Authentication
+        ) -> Request {
         Request {
             client: Client::new(),
-            arg_value: Vec::new(),
+            arg_value: arg,
             map: HashMap::new(),
-            url: None
+            url: Some(format!("{:?}{:?}", config.base_url, config.base_api)),
+            authentication: auth,
+        }
+    }
+
+    /// Public constructor for a request with an API token
+    pub fn with_api_request(
+        config: Configuration, 
+        arg: ArgMatches,
+        auth: Authentication
+        ) -> Request {        
+        Request {
+            client: Client::new(),
+            arg_value: arg,
+            map: HashMap::new(),
+            url: Some(format!("{:?}{:?}", config.base_url, config.base_api)),
+            authentication: auth, 
         }
     }
 }
 
-impl Authentication {
+impl Authentication{
+    /// Public constructor for getting authentication, provided by the configuration
+    /// file. The most secure methods are checked first, filtering down to the least
+    /// secure methods. Currently, only two methods are supported: API token, and 
+    /// username/password combo.
     pub fn new(config: &Configuration) -> Authentication {
         let basic_auth: String;
         let api_auth: String;
@@ -37,28 +64,67 @@ impl Authentication {
         // this is horror code, I know it
         // match the damn thing
         // someone is going to take this and put it in r/badcode lol
+        basic_auth = config
+                        .password
+                        .as_ref()
+                        .unwrap()
+                        .to_string();
+
+        api_auth = config
+                        .api_token
+                        .as_ref()
+                        .unwrap()
+                        .to_string();
+        
+        if api_auth.is_empty() {
+            if !(basic_auth.is_empty()) {
+                Authentication::with_basic(config.username.as_ref().unwrap().to_string(), basic_auth)
+            } else {
+                panic!("Must have some form of authentication! Exiting...");
+            }
+        } else {
+            Authentication::with_api_token(api_auth)
+        } 
 
-        match config {
-            _ => panic!()
-        }
     }
 
-    fn with_basic() -> Authentication {
+    /// Private constructor once the public constructor figures out what kind of authentication
+    /// is being used. This constructor uses the username/password combo, a less secure of
+    /// authenticating that the API token.
+    fn with_basic(user: String, pass: String) -> Authentication {
         Authentication {
             basic: true,
-            api_token: false
+            api_token: false,
+            credentials: (Some(user), Some(pass))
         }
     }
 
-    fn with_api_token() -> Authentication {
+    /// Private constructor once the public constructor figures out what kind of authentication
+    /// is being used. This constructor uses the API token, a more secure way of authenticating
+    /// instead of using the basic username and password.
+    fn with_api_token(api_token: String) -> Authentication {
         Authentication {
             basic: false,
-            api_token: true
+            api_token: true,
+            credentials: (Some(api_token), None)
         }
     }
 
-    // This method requires the instanciated config, an optional instanciated args, and instanciated auth
-    pub fn request_chooser(&self, config: &Configuration, arg: Option<&ArgMatches>, auth: &Authentication, arg_string: &str) {
-
+    /// Public method that based on the what kind of authentication is being used, it can
+    /// determine what kind of requesting method is going to be used. See the Request
+    /// structure for more details.
+    pub fn request_chooser(
+        self, 
+        config: Configuration, 
+        arg: ArgMatches<'static>,
+        ) -> Request {
+        if let true = self.api_token {
+            Request::with_api_request(config, arg.to_owned(), self)
+        } else {
+            match self.basic {
+                true => Request::with_basic_request(config, arg.to_owned(), self),
+                false => panic!(),
+            }
+        }
     }
-}
+}