Add send_device_info

Cargo.toml

@@ -75,6 +75,7 @@ rumqttc = { version = "0.20.0" }
 cuid = { version = "1.3.1" }
 shadow-rs = "0.21.0"
 dotenv = "0.15.0"
+mac_address = "1.1.5"
 
 [dev-dependencies]
 rstest = { version = "0.17.0" }

src/main.rs

@@ -20,6 +20,8 @@ use crate::config::ServerConfig;
 use crate::network::Network;
 use dotenv::dotenv;
 use handlers::Command;
+use mac_address::get_mac_address;
+use std::env;
 
 mod config;
 mod controllers;
@@ -180,6 +182,7 @@ async fn main() -> std::io::Result<()> {
 
     // NOTE: hub initilize
     hub_initilize(did.did_document.id.clone()).await;
+    send_device_info(did.did_document.id.clone()).await;
 
     let sock_path = runtime_dir.clone().join("nodex.sock");
 
@@ -323,6 +326,28 @@ async fn hub_initilize(did: String) {
     };
 }
 
+async fn send_device_info(did: String) {
+    const VERSION: &str = env!("CARGO_PKG_VERSION");
+    const OS: &str = env::consts::OS;
+    let mac_address: String = match get_mac_address() {
+        Ok(Some(ma)) => ma.to_string(),
+        Ok(None) => String::from("No MAC address found."),
+        Err(_) => String::from("No MAC address found."),
+    };
+
+    let hub = Hub::new();
+    match hub
+        .send_device_info(did, mac_address, VERSION.to_string(), OS.to_string())
+        .await
+    {
+        Ok(()) => (),
+        Err(e) => {
+            log::error!("{:?}", e);
+            panic!()
+        }
+    };
+}
+
 use env_logger::fmt::Color;
 use log::Level;
 

src/nodex/utils/hub_client.rs

@@ -7,6 +7,9 @@ use reqwest::{
 };
 use sha2::Sha256;
 
+use crate::services::internal::didcomm_encrypted::DIDCommEncryptedService;
+use serde_json::json;
+
 type HmacSha256 = Hmac<Sha256>;
 
 pub struct HubClientConfig {
@@ -82,8 +85,8 @@ impl HubClient {
         }
     }
 
-    pub async fn post(&self, _path: &str, body: &str) -> Result<reqwest::Response, NodeXError> {
-        let url = self.base_url.join(_path);
+    pub async fn post(&self, path: &str, body: &str) -> Result<reqwest::Response, NodeXError> {
+        let url = self.base_url.join(path);
         let headers = self.auth_headers(body.to_string());
         if let Err(e) = headers {
             log::error!("{:?}", e);
@@ -105,6 +108,49 @@ impl HubClient {
         }
     }
 
+    pub async fn send_device_info(
+        &self,
+        path: &str,
+        to_did: &str,
+        mac_address: &str,
+        version: &str,
+        os: &str,
+    ) -> Result<reqwest::Response, NodeXError> {
+        let message = json!({
+            "mac_address": mac_address,
+            "version": version,
+            "os": os,
+        });
+        let payload = match DIDCommEncryptedService::generate(to_did, &json!(message), None).await {
+            Ok(v) => v,
+            Err(e) => {
+                log::error!("{:?}", e);
+                return Err(NodeXError {});
+            }
+        };
+        let payload = match serde_json::to_string(&payload) {
+            Ok(v) => v,
+            Err(e) => {
+                log::error!("{:?}", e);
+                return Err(NodeXError {});
+            }
+        };
+        let url = self.base_url.join(path);
+        match self
+            .instance
+            .post(&url.unwrap().to_string())
+            .body(payload.to_string())
+            .send()
+            .await
+        {
+            Ok(v) => Ok(v),
+            Err(e) => {
+                log::error!("{:?}", e);
+                Err(NodeXError {})
+            }
+        }
+    }
+
     #[allow(dead_code)]
     pub async fn put(&self, _path: &str) -> Result<reqwest::Response, NodeXError> {
         let url = self.base_url.join(_path);

src/services/hub.rs

@@ -18,6 +18,14 @@ struct RegisterDeviceRequest {
     project_id: String,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+struct SendDeviceInfoRequest {
+    device_did: String,
+    mac_address: String,
+    version: String,
+    os: String,
+}
+
 impl Hub {
     pub fn new() -> Self {
         let server_config = server_config();
@@ -59,4 +67,31 @@ impl Hub {
             }
         }
     }
+
+    pub async fn send_device_info(
+        &self,
+        to_did: String,
+        mac_address: String,
+        version: String,
+        os: String,
+    ) -> Result<(), NodeXError> {
+        let res = match self
+            .http_client
+            .send_device_info("/v1/device_info", &to_did, &mac_address, &version, &os)
+            .await
+        {
+            Ok(v) => v,
+            Err(e) => {
+                log::error!("{:?}", e);
+                return Err(NodeXError {});
+            }
+        };
+        match res.json::<EmptyResponse>().await {
+            Ok(_) => Ok(()),
+            Err(e) => {
+                log::error!("{:?}", e);
+                Err(NodeXError {})
+            }
+        }
+    }
 }