Added Rest and Updated Native App API (#4)

* Added Rest and Updated Native App API

* cargo fmt

* remove protocols

* cargo fmt

* cargo clippy

* cargo fmt

Author: BCNelson

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "cSpell.words": [
+        "chrono",
+        "reqwest"
+    ]
+}

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "homeassistant"
-description = "This is a library for connecting to the Home Assistent API"
+description = "This is a library for connecting to the Home Assistant API"
 version = "0.2.0"
 authors = ["Bradley Nelson <[email protected]>"]
 edition = "2018"
@@ -15,3 +15,4 @@ license = "Apache-2.0"
 futures = "0.3"
 reqwest = { version = "0.10", features = ["json"] }
 serde = { version = "1.0", features = ["derive"] }
+chrono = "0.4"

src/errors.rs

@@ -7,6 +7,11 @@ pub enum Error {
     Config(String),
     Refresh(),
     NoAuth(),
+    PoisonError(
+        std::sync::PoisonError<
+            std::sync::RwLockReadGuard<'static, std::option::Option<crate::Token>>,
+        >,
+    ),
 }
 
 impl From<reqwest::Error> for Error {
@@ -15,14 +20,31 @@ impl From<reqwest::Error> for Error {
     }
 }
 
+impl
+    From<
+        std::sync::PoisonError<
+            std::sync::RwLockReadGuard<'static, std::option::Option<crate::Token>>,
+        >,
+    > for Error
+{
+    fn from(
+        error: std::sync::PoisonError<
+            std::sync::RwLockReadGuard<'static, std::option::Option<crate::Token>>,
+        >,
+    ) -> Self {
+        Error::PoisonError(error)
+    }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Error::Request(inner) => write!(f, "{}", inner),
             Error::Config(inner) => write!(f, "{}", inner),
             Error::HaApi(inner) => write!(f, "{}", inner),
+            Error::PoisonError(inner) => write!(f, "{}", inner),
             Error::Refresh() => write!(f, "Tried to refresh a long lived access token"),
-            Error::NoAuth() => write!(f, "There are no Authentication Credentals"),
+            Error::NoAuth() => write!(f, "There are no Authentication Credentials"),
         }
     }
 }

src/lib.rs

@@ -1,24 +1,49 @@
 use crate::types::*;
+use std::convert::TryFrom;
+use std::sync::{Arc, RwLock, Weak};
 use std::time;
 
 pub mod errors;
+pub mod native_app;
+pub mod rest;
 pub mod types;
 
 #[derive(Debug)]
 pub struct HomeAssistantAPI {
     instance_url: String,
-    token: Option<Token>,
-    client: reqwest::Client,
-    webhook_id: Option<String>,
-    cloudhook_url: Option<String>,
-    remote_ui_url: Option<String>,
+    token: Token,
     client_id: String,
+    self_reference: Weak<RwLock<Self>>,
 }
 
 #[derive(Debug, Clone)]
 pub enum Token {
     Oauth(OAuthToken),
     LongLived(LongLivedToken),
+    None,
+}
+
+impl Token {
+    pub fn as_string(&self) -> Result<String, errors::Error> {
+        match self {
+            Token::Oauth(token) => Ok(token.token.clone()),
+            Token::LongLived(token) => Ok(token.token.clone()),
+            Token::None => Err(errors::Error::NoAuth()),
+        }
+    }
+
+    pub fn need_refresh(&self) -> bool {
+        match self {
+            Token::Oauth(token) => {
+                match time::SystemTime::now().duration_since(token.token_expiration) {
+                    Ok(sec_left) => sec_left > time::Duration::from_secs(10),
+                    Err(_) => false,
+                }
+            }
+            Token::LongLived(_) => false,
+            Token::None => false,
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -34,20 +59,18 @@ pub struct LongLivedToken {
 }
 
 impl HomeAssistantAPI {
-    pub fn new(
-        instance_url: String,
-        client_id: String,
-        maybe_long_lived_token: Option<String>,
-    ) -> Self {
-        Self {
+    pub fn new(instance_url: String, client_id: String) -> Arc<RwLock<Self>> {
+        let token = Token::None;
+        let ret = Arc::new(RwLock::new(Self {
             instance_url,
-            token: maybe_long_lived_token.map(|token| Token::LongLived(LongLivedToken { token })),
-            client: reqwest::Client::new(),
-            webhook_id: None,
-            cloudhook_url: None,
-            remote_ui_url: None,
+            token,
             client_id,
-        }
+            self_reference: Weak::new(),
+        }));
+
+        ret.write().unwrap().self_reference = Arc::downgrade(&ret);
+
+        ret
     }
 
     pub fn set_oauth_token(
@@ -62,63 +85,18 @@ impl HomeAssistantAPI {
                 + time::Duration::from_secs(expires_in as u64),
             refresh_token,
         };
-        let oauth_token = Token::Oauth(oauth);
-        self.token = Some(oauth_token);
+        self.token = Token::Oauth(oauth);
     }
 
     pub fn set_long_lived_token(&mut self, token: String) {
-        let long_lived = Token::LongLived(LongLivedToken { token });
-        self.token = Some(long_lived)
-    }
-
-    pub fn set_webhook_info(
-        &mut self,
-        webhook_id: String,
-        cloudhook_url: Option<String>,
-        remote_ui_url: Option<String>,
-    ) {
-        self.webhook_id = Some(webhook_id);
-        self.cloudhook_url = cloudhook_url;
-        self.remote_ui_url = remote_ui_url;
-    }
-
-    pub fn need_refresh(&self) -> bool {
-        let token_result = self.token.as_ref().ok_or_else(|| {
-            errors::Error::Config("Refreshing token - expected a token to exist".to_string())
-        });
-
-        match token_result {
-            Ok(token) => match token {
-                Token::Oauth(token) => {
-                    match time::SystemTime::now().duration_since(token.token_expiration) {
-                        Ok(sec_left) => sec_left > time::Duration::from_secs(10),
-                        Err(_) => false,
-                    }
-                }
-                Token::LongLived(_) => false,
-            },
-            Err(_) => false,
-        }
+        self.token = Token::LongLived(LongLivedToken { token });
     }
 
-    pub async fn refresh_token(&mut self) -> Result<(), errors::Error> {
-        let token = self.token.clone(); // This is dump but I have to do it apparently
-        let refresh_token: String;
-        match token {
-            Some(token) => {
-                refresh_token = match token {
-                    Token::Oauth(oauth) => oauth.refresh_token,
-                    Token::LongLived(_) => {
-                        return Err(errors::Error::Refresh());
-                    }
-                };
-            }
-            None => return Err(errors::Error::NoAuth()),
-        }
+    pub async fn refresh_oauth_token(&mut self) -> Result<(), errors::Error> {
+        let refresh_token = String::from("test");
 
-        let response = self
-            .client
-            .post(format!("http://{}/auth/token", self.instance_url).as_str())
+        let response = reqwest::Client::new()
+            .post(format!("{}/auth/token", self.instance_url).as_str())
             .query(&[
                 ("grant_type", "refresh_token"),
                 ("client_id", &self.client_id),
@@ -146,9 +124,8 @@ impl HomeAssistantAPI {
             code,
             client_id,
         };
-        let resp = self
-            .client
-            .post(format!("http://{}/auth/token", self.instance_url).as_str())
+        let resp = reqwest::Client::new()
+            .post(format!("{}/auth/token", self.instance_url).as_str())
             .form(&request)
             .send()
             .await?;
@@ -173,109 +150,27 @@ impl HomeAssistantAPI {
         }
     }
 
-    pub async fn api_states(&self) -> Result<Vec<HaEntityState>, errors::Error> {
-        let endpoint = format!("http://{}/api/states", self.instance_url);
-        let token = self.get_token()?;
-        let resp = self
-            .client
-            .get(endpoint.as_str())
-            .header("Authorization", format!("Bearer {}", token))
-            .send()
-            .await?;
-
-        let api_states = resp.json::<Vec<HaEntityState>>().await?;
-        Ok(api_states)
-    }
-
-    pub async fn register_machine(
-        &mut self,
-        request: &RegisterDeviceRequest,
-    ) -> Result<RegisterDeviceResponse, errors::Error> {
-        if self.need_refresh() {
-            self.refresh_token().await?;
-        }
-        let endpoint = format!("http://{}/api/mobile_app/registrations", self.instance_url);
-        let token = self.get_token()?;
-        let resp = self
-            .client
-            .post(endpoint.as_str())
-            .header("Authorization", format!("Bearer {}", token))
-            .json(&request)
-            .send()
-            .await?;
-
-        let r: RegisterDeviceResponse = resp.json().await?;
-        self.set_webhook_info(
-            r.webhook_id.clone(),
-            r.cloud_hook_url.clone(),
-            r.remote_ui_url.clone(),
-        );
-        Ok(r)
-    }
-
-    pub async fn register_sensor(
-        &mut self,
-        request: &SensorRegistrationRequest,
-    ) -> Result<RegisterSensorResponse, errors::Error> {
-        if self.need_refresh() {
-            self.refresh_token().await?;
+    pub async fn get_rest_client(&self) -> rest::Rest {
+        match rest::Rest::try_from(self.self_reference.clone()) {
+            Ok(rest) => rest,
+            Err(_) => unreachable!(),
         }
-        let webhook_id = self
-            .webhook_id
-            .as_ref()
-            .ok_or_else(|| errors::Error::Config("expected webhook_id to exist".to_string()))?;
-        let token = self.get_token()?;
-        let endpoint = format!("http://{}/api/webhook/{}", self.instance_url, webhook_id);
-
-        let response = self
-            .client
-            .post(endpoint.as_str())
-            .header("Authorization", format!("Bearer {}", token))
-            .json(&request)
-            .send()
-            .await?;
-
-        let resp_json: RegisterSensorResponse = response.json().await?;
-        Ok(resp_json)
     }
 
-    pub async fn update_sensor(
-        &mut self,
-        sensor_data: SensorUpdateData,
-    ) -> Result<(), errors::Error> {
-        if self.need_refresh() {
-            self.refresh_token().await?;
+    pub async fn get_native_client_from_config(
+        &self,
+        config: native_app::NativeAppConfig,
+    ) -> native_app::NativeApp {
+        match native_app::NativeApp::from_config(config, self.self_reference.clone()) {
+            Ok(native_app) => native_app,
+            Err(_) => unreachable!(),
         }
-        let webhook_id = self
-            .webhook_id
-            .as_ref()
-            .ok_or_else(|| errors::Error::Config("missing webhook id".to_string()))?;
-
-        let endpoint = format!("{}/api/webhook/{}", self.instance_url, webhook_id);
-        let token = self.get_token()?;
-
-        let request = types::SensorUpdateRequest {
-            data: sensor_data,
-            r#type: String::from("update_sensor_states"),
-        };
-
-        self.client
-            .post(endpoint.as_str())
-            .header("Authorization", format!("Bearer {}", token))
-            .json(&request)
-            .send()
-            .await?;
-
-        Ok(())
     }
 
-    fn get_token(&self) -> Result<String, errors::Error> {
-        let token = self.token.as_ref().ok_or_else(|| {
-            errors::Error::Config("Get Token - expected a token to exist".to_string())
-        })?;
-        match token {
-            Token::Oauth(token) => Ok(token.token.clone()),
-            Token::LongLived(token) => Ok(token.token.clone()),
+    pub async fn get_native_client(&self) -> native_app::NativeApp {
+        match native_app::NativeApp::new(self.self_reference.clone()) {
+            Ok(native_app) => native_app,
+            Err(_) => unreachable!(),
         }
     }
 }