add subbacounts (RELEASEMINOR)(API2-709)

Author: seniorburito

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "voiceit2"
-version = "0.2.4"
+version = "0.3.0"
 authors = ["gilgameshskytrooper <[email protected]>"]
 description = """
 A Rust wrapper for VoiceIt's API 2.0 featuring Voice + Face Verification and Identification.

src/client/mod.rs

@@ -195,6 +195,125 @@ impl VoiceIt2 {
         Ok(body)
     }
 
+    // SUBACCOUNTS
+    pub fn create_managed_sub_account(
+        &self,
+        first_name: &str,
+        last_name: &str,
+        email: &str,
+        password: &str,
+        content_language: &str,
+    ) -> Result<String, VoiceItError> {
+        let url = format!(
+            "{}/subaccount/managed{}",
+            String::from(BASE_URL),
+            self.notification_url_parameter
+        );
+
+        let form = multipart::Form::new()
+            .text("firstName", String::from(first_name))
+            .text("lastName", String::from(last_name))
+            .text("email", String::from(email))
+            .text("password", String::from(password))
+            .text("contentLanguage", String::from(content_language));
+
+        let mut response = Client::new()
+            .post(&url)
+            .header("platformId", PLATFORM_ID)
+            .header("platformVersion", PLATFORM_VERSION)
+            .basic_auth(self.api_key.clone(), Some(self.api_token.clone()))
+            .multipart(form)
+            .send()?;
+
+        let mut body = String::new();
+        response.read_to_string(&mut body)?;
+
+        Ok(body)
+    }
+
+    pub fn create_unmanaged_sub_account(
+        &self,
+        first_name: &str,
+        last_name: &str,
+        email: &str,
+        password: &str,
+        content_language: &str,
+    ) -> Result<String, VoiceItError> {
+        let url = format!(
+            "{}/subaccount/unmanaged{}",
+            String::from(BASE_URL),
+            self.notification_url_parameter
+        );
+
+        let form = multipart::Form::new()
+            .text("firstName", String::from(first_name))
+            .text("lastName", String::from(last_name))
+            .text("email", String::from(email))
+            .text("password", String::from(password))
+            .text("contentLanguage", String::from(content_language));
+
+        let mut response = Client::new()
+            .post(&url)
+            .header("platformId", PLATFORM_ID)
+            .header("platformVersion", PLATFORM_VERSION)
+            .basic_auth(self.api_key.clone(), Some(self.api_token.clone()))
+            .multipart(form)
+            .send()?;
+
+        let mut body = String::new();
+        response.read_to_string(&mut body)?;
+
+        Ok(body)
+    }
+
+    pub fn regenerate_sub_account_api_token(
+        &self,
+        sub_account_api_key: &str,
+    ) -> Result<String, VoiceItError> {
+        let url = format!(
+            "{}/subaccount/{}{}",
+            String::from(BASE_URL),
+            String::from(sub_account_api_key),
+            self.notification_url_parameter
+        );
+
+        let mut response = Client::new()
+            .post(&url)
+            .header("platformId", PLATFORM_ID)
+            .header("platformVersion", PLATFORM_VERSION)
+            .basic_auth(self.api_key.clone(), Some(self.api_token.clone()))
+            .send()?;
+
+        let mut body = String::new();
+        response.read_to_string(&mut body)?;
+
+        Ok(body)
+    }
+
+    pub fn delete_subaccount(
+        &self,
+        sub_account_api_key: &str,
+    ) -> Result<String, VoiceItError> {
+        let url = format!(
+            "{}/subaccount/{}{}",
+            String::from(BASE_URL),
+            String::from(sub_account_api_key),
+            self.notification_url_parameter
+        );
+
+        let mut response = Client::new()
+            .delete(&url)
+            .header("platformId", PLATFORM_ID)
+            .header("platformVersion", PLATFORM_VERSION)
+            .basic_auth(self.api_key.clone(), Some(self.api_token.clone()))
+            .send()?;
+
+        let mut body = String::new();
+        response.read_to_string(&mut body)?;
+
+        Ok(body)
+    }
+
     // GROUPS
 
     pub fn create_group(&self, description: &str) -> Result<String, VoiceItError> {

src/lib.rs

@@ -40,6 +40,12 @@ use structs::verification::{
     VideoVerificationReturn, VoiceVerificationByUrlReturn, VoiceVerificationReturn,
 };
 
+#[allow(unused_imports)]
+use structs::subaccounts::{
+    CreateSubAccountReturn,RegenerateSubAccountAPITokenReturn,DeleteSubAccountReturn,
+};
+
+
 use regex::Regex;
 use std::fs::File;
 use std::io::copy;
@@ -59,6 +65,11 @@ fn is_user_token(text: &str) -> bool {
     re.is_match(text)
 }
 
+fn is_api_key(text: &str) -> bool {
+    let re: Regex = Regex::new(r"^key_[a-zA-Z0-9]{32}$").unwrap();
+    re.is_match(text)
+}
+
 fn download_file(link: &str) -> Result<(), Box<dyn std::error::Error>> {
     let mut response = reqwest::get(link)?;
 
@@ -267,6 +278,78 @@ mod tests {
         assert_eq!(&x.get_base_url(), "https://api.voiceit.io");
     }
 
+    #[test]
+    fn test_subaccounts(){
+        let env = std::env::var("BOXFUSE_ENV").unwrap();
+        if env == "voiceittest" {
+            let home_dir = std::env::var("HOME").unwrap();
+            std::fs::write(
+                format!("{}/platformVersion", home_dir),
+                crate::client::PLATFORM_VERSION,
+            )
+            .expect("Unable to write platformVersion file");
+        }
+
+        let x = crate::client::VoiceIt2::new(
+            std::env::var("VIAPIKEY").unwrap(),
+            std::env::var("VIAPITOKEN").unwrap(),
+        );
+
+        let result: crate::structs::subaccounts::CreateSubAccountReturn = match &x.create_managed_sub_account("test", "rust", "", "", "") {
+            Ok(x) => serde_json::from_str(&x).expect(&x),
+            Err(err) => {
+                panic!("Panic error: {:?}", err);
+            }
+        };
+    
+        assert_eq!(result.status, 201);
+        let sub_account_managed_api_key = result.apiKey;
+        assert!(crate::is_api_key(&sub_account_managed_api_key));
+        assert_eq!(result.responseCode, "SUCC");
+
+        let result: crate::structs::subaccounts::CreateSubAccountReturn = match &x.create_unmanaged_sub_account("test", "rust", "", "", "") {
+            Ok(x) => serde_json::from_str(&x).expect(&x),
+            Err(err) => {
+                panic!("Panic error: {:?}", err);
+            }
+        };
+    
+        assert_eq!(result.status, 201);
+        let sub_account_unmanaged_api_key = result.apiKey;
+        assert!(crate::is_api_key(&sub_account_unmanaged_api_key));
+        assert_eq!(result.responseCode, "SUCC");
+
+        let result: crate::structs::subaccounts::RegenerateSubAccountAPITokenReturn = match &x.regenerate_sub_account_api_token(&sub_account_managed_api_key) {
+            Ok(x) => serde_json::from_str(&x).expect(&x),
+            Err(err) => {
+                panic!("Panic error: {:?}", err);
+            }
+        };
+    
+        assert_eq!(result.status, 200);
+        assert_eq!(result.responseCode, "SUCC");
+
+        let result: crate::structs::subaccounts::DeleteSubAccountReturn = match &x.delete_subaccount(&sub_account_managed_api_key) {
+            Ok(x) => serde_json::from_str(&x).expect(&x),
+            Err(err) => {
+                panic!("Panic error: {:?}", err);
+            }
+        };
+    
+        assert_eq!(result.status, 200);
+        assert_eq!(result.responseCode, "SUCC");
+
+        let result: crate::structs::subaccounts::DeleteSubAccountReturn = match &x.delete_subaccount(&sub_account_unmanaged_api_key) {
+            Ok(x) => serde_json::from_str(&x).expect(&x),
+            Err(err) => {
+                panic!("Panic error: {:?}", err);
+            }
+        };
+    
+        assert_eq!(result.status, 200);
+        assert_eq!(result.responseCode, "SUCC");
+    }
+
     #[test]
     fn test_io() {
         println!("To be filled out later");

src/structs/mod.rs

@@ -4,3 +4,4 @@ pub mod identification;
 pub mod phrases;
 pub mod users;
 pub mod verification;
+pub mod subaccounts;

src/structs/subaccounts.rs

@@ -0,0 +1,32 @@
+#![allow(non_snake_case)]
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct CreateSubAccountReturn {
+    pub message: String,
+    pub status: u16,
+    pub timeTaken: String,
+    pub password: String,
+    pub apiToken: String,
+    pub apiKey: String,
+    pub email: String,
+    pub responseCode: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RegenerateSubAccountAPITokenReturn {
+    pub message: String,
+    pub status: u16,
+    pub timeTaken: String,
+    pub apiToken: String,
+    pub responseCode: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct DeleteSubAccountReturn {
+    pub message: String,
+    pub status: u16,
+    pub timeTaken: String,
+    pub responseCode: String,
+}