nutcas3
diff --git a/‎.github/workflows/codeql.yml‎
Lines changed: 1 addition & 1 deletion b/‎.github/workflows/codeql.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 1 deletion b/‎.gitignore‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎Cargo.toml‎
Lines changed: 34 additions & 0 deletions b/‎Cargo.toml‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎src/api.rs‎
Lines changed: 192 additions & 0 deletions b/‎src/api.rs‎
Lines changed: 192 additions & 0 deletions
diff --git a/‎src/auth.rs‎
Lines changed: 45 additions & 0 deletions b/‎src/auth.rs‎
Lines changed: 45 additions & 0 deletions
diff --git a/‎src/config.rs‎
Lines changed: 35 additions & 0 deletions b/‎src/config.rs‎
Lines changed: 35 additions & 0 deletions
diff --git a/‎src/error.rs‎
Lines changed: 33 additions & 0 deletions b/‎src/error.rs‎
Lines changed: 33 additions & 0 deletions
diff --git a/‎src/lib.rs‎
Lines changed: 30 additions & 0 deletions b/‎src/lib.rs‎
Lines changed: 30 additions & 0 deletions
@@ -26,7 +26,7 @@ jobs:
       matrix:
         include:
         - language: rust
-          build-mode: autobuild
+          build-mode: none
 
     steps:
     - name: Checkout repository
 
@@ -1,2 +1,2 @@
 Cargo.lock
-/target
+/target
@@ -0,0 +1,34 @@
+[package]
+name = "smile_id"
+version = "0.1.0"
+edition = "2021"
+authors = ["Nutcase <mauricee423@gmail.com>"]
+description = "Rust client for Smile ID's identity verification services across Africa"
+license = "MIT"
+
+repository = "https://github.com/nutcas3/smile-id-rust"
+readme = "README.md"
+keywords = ["identity", "verification", "kyc", "africa", "smile-id"]
+categories = ["api-bindings", "authentication"]
+
+[dependencies]
+reqwest = { version = "0.11", features = ["json", "blocking"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+thiserror = "1.0"
+hmac = "0.12"
+sha2 = "0.10"
+base64 = "0.21"
+chrono = "0.4"
+async-trait = "0.1"
+tokio = { version = "1", features = ["full"], optional = true }
+url = "2.3"
+
+[features]
+default = ["async"]
+async = ["tokio"]
+blocking = []
+
+[dev-dependencies]
+tokio-test = "0.4"
+mockito = "1.0"
@@ -0,0 +1,192 @@
+use chrono::Utc;
+use reqwest::{Client, ClientBuilder};
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+use std::time::Duration;
+
+use crate::auth::Auth;
+use crate::config::Config;
+use crate::error::{Error, Result};
+use crate::models::{ApiResponse, JobStatusRequest, JobStatusResponse};
+
+#[derive(Debug, Clone)]
+pub struct ApiClient {
+    client: Client,
+    auth: Auth,
+    config: Config,
+}
+
+impl ApiClient {
+    pub fn new(config: Config) -> Result<Self> {
+        let client = ClientBuilder::new()
+            .timeout(Duration::from_secs(config.timeout))
+            .build()
+            .map_err(Error::Http)?;
+
+        let auth = Auth::new(&config.api_key, &config.partner_id);
+
+        Ok(Self {
+            client,
+            auth,
+            config,
+        })
+    }
+
+    pub async fn get_job_status(
+        &self,
+        user_id: impl Into<String>,
+        job_id: impl Into<String>,
+        include_history: Option<bool>,
+        include_image_links: Option<bool>,
+    ) -> Result<JobStatusResponse> {
+        let request = JobStatusRequest {
+            user_id: user_id.into(),
+            job_id: job_id.into(),
+            include_history,
+            include_image_links,
+        };
+
+        let url = format!("{}/job_status", self.base_url());
+        self.post(&url, &request).await
+    }
+
+    pub async fn post<T, R>(&self, url: &str, payload: &T) -> Result<R>
+    where
+        T: Serialize + ?Sized,
+        R: DeserializeOwned,
+    {
+        let timestamp = Utc::now();
+        let json = serde_json::to_string(payload).map_err(Error::Json)?;
+        let signature = self.auth.generate_signature(&timestamp, &json)?;
+
+        let response = self
+            .client
+            .post(url)
+            .header("Content-Type", "application/json")
+            .header("X-Smile-Partner-ID", self.auth.partner_id())
+            .header("X-Smile-Signature", &signature)
+            .header("X-Smile-Timestamp", timestamp.to_rfc3339())
+            .body(json)
+            .send()
+            .await
+            .map_err(Error::Http)?;
+
+        let status = response.status();
+        let body = response.text().await.map_err(Error::Http)?;
+
+        if !status.is_success() {
+            return Err(Error::Api {
+                status_code: status.as_u16(),
+                message: body,
+            });
+        }
+
+        let api_response: ApiResponse<R> = serde_json::from_str(&body).map_err(Error::Json)?;
+
+        if api_response.status_code >= 400 {
+            return Err(Error::Api {
+                status_code: api_response.status_code,
+                message: api_response.message,
+            });
+        }
+
+        Ok(api_response.data)
+    }
+
+    pub fn base_url(&self) -> String {
+        format!("{}/v{}", self.config.base_url, self.config.version)
+    }
+}
+
+#[cfg(feature = "blocking")]
+pub mod blocking {
+    use super::*;
+
+    #[derive(Debug, Clone)]
+    pub struct ApiClient {
+        client: reqwest::blocking::Client,
+        auth: Auth,
+        config: Config,
+    }
+
+    impl ApiClient {
+        pub fn new(config: Config) -> Result<Self> {
+            let client = reqwest::blocking::ClientBuilder::new()
+                .timeout(Duration::from_secs(config.timeout))
+                .build()
+                .map_err(Error::Http)?;
+
+            let auth = Auth::new(&config.api_key, &config.partner_id);
+
+            Ok(Self {
+                client,
+                auth,
+                config,
+            })
+        }
+
+        pub fn get_job_status(
+            &self,
+            user_id: impl Into<String>,
+            job_id: impl Into<String>,
+            include_history: Option<bool>,
+            include_image_links: Option<bool>,
+        ) -> Result<JobStatusResponse> {
+            let request = JobStatusRequest {
+                user_id: user_id.into(),
+                job_id: job_id.into(),
+                include_history,
+                include_image_links,
+            };
+
+            let url = format!("{}/job_status", self.base_url());
+            self.post(&url, &request)
+        }
+
+        pub fn post<T, R>(&self, url: &str, payload: &T) -> Result<R>
+        where
+            T: Serialize + ?Sized,
+            R: DeserializeOwned,
+        {
+            let timestamp = Utc::now();
+            let json = serde_json::to_string(payload).map_err(Error::Json)?;
+            let signature = self.auth.generate_signature(&timestamp, &json)?;
+
+            let response = self
+                .client
+                .post(url)
+                .header("Content-Type", "application/json")
+                .header("X-Smile-Partner-ID", self.auth.partner_id())
+                .header("X-Smile-Signature", &signature)
+                .header("X-Smile-Timestamp", timestamp.to_rfc3339())
+                .body(json)
+                .send()
+                .map_err(Error::Http)?;
+
+            let status = response.status();
+            let body = response.text().map_err(Error::Http)?;
+
+            if !status.is_success() {
+                return Err(Error::Api {
+                    status_code: status.as_u16(),
+                    message: body,
+                });
+            }
+
+            let api_response: ApiResponse<R> = serde_json::from_str(&body).map_err(Error::Json)?;
+
+            if api_response.status_code >= 400 {
+                return Err(Error::Api {
+                    status_code: api_response.status_code,
+                    message: api_response.message,
+                });
+            }
+
+            Ok(api_response.data)
+        }
+
+        pub fn base_url(&self) -> String {
+            format!("{}/v{}", self.config.base_url, self.config.version)
+        }
+    }
+}
@@ -0,0 +1,45 @@
+use base64::{engine::general_purpose, Engine};
+use hmac::{Hmac, Mac};
+use sha2::Sha256;
+use chrono::{Utc, DateTime};
+use crate::error::{Error, Result};
+
+type HmacSha256 = Hmac<Sha256>;
+
+#[derive(Debug, Clone)]
+pub struct Auth {
+    api_key: String,
+    partner_id: String,
+}
+
+impl Auth {
+    pub fn new(api_key: impl Into<String>, partner_id: impl Into<String>) -> Self {
+        Self {
+            api_key: api_key.into(),
+            partner_id: partner_id.into(),
+        }
+    }
+    
+    pub fn generate_signature(&self, timestamp: &DateTime<Utc>, payload: &str) -> Result<String> {
+        let timestamp_str = timestamp.to_rfc3339();
+        let message = format!("{}{}{}", self.partner_id, timestamp_str, payload);
+        
+        let mut mac = HmacSha256::new_from_slice(self.api_key.as_bytes())
+            .map_err(|e| Error::Auth(format!("Failed to create HMAC: {}", e)))?;
+        
+        mac.update(message.as_bytes());
+        let result = mac.finalize();
+        let signature = general_purpose::STANDARD.encode(result.into_bytes());
+        
+        Ok(signature)
+    }
+    
+    pub fn verify_signature(&self, signature: &str, timestamp: &DateTime<Utc>, payload: &str) -> Result<bool> {
+        let expected_signature = self.generate_signature(timestamp, payload)?;
+        Ok(signature == expected_signature)
+    }
+    
+    pub fn partner_id(&self) -> &str {
+        &self.partner_id
+    }
+}
@@ -0,0 +1,35 @@
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub api_key: String,
+    pub partner_id: String,
+    pub base_url: String,
+    pub version: String,
+    pub timeout: u64,
+}
+
+impl Config {
+    pub fn new(api_key: impl Into<String>, partner_id: impl Into<String>) -> Self {
+        Self {
+            api_key: api_key.into(),
+            partner_id: partner_id.into(),
+            base_url: "https://api.usesmileid.com".to_string(),
+            version: "1.0".to_string(),
+            timeout: 30,
+        }
+    }
+    
+    pub fn with_base_url(mut self, base_url: impl Into<String>) -> Self {
+        self.base_url = base_url.into();
+        self
+    }
+    
+    pub fn with_version(mut self, version: impl Into<String>) -> Self {
+        self.version = version.into();
+        self
+    }
+    
+    pub fn with_timeout(mut self, timeout: u64) -> Self {
+        self.timeout = timeout;
+        self
+    }
+}
@@ -0,0 +1,33 @@
+use thiserror::Error;
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("HTTP error: {0}")]
+    Http(#[from] reqwest::Error),
+
+    #[error("JSON error: {0}")]
+    Json(#[from] serde_json::Error),
+
+    #[error("API error: {status_code} - {message}")]
+    Api {
+        status_code: u16,
+        message: String,
+    },
+
+    #[error("Authentication error: {0}")]
+    Auth(String),
+
+    #[error("Configuration error: {0}")]
+    Config(String),
+
+    #[error("Signature verification error: {0}")]
+    SignatureVerification(String),
+
+    #[error("Invalid parameter: {0}")]
+    InvalidParameter(String),
+
+    #[error("Other error: {0}")]
+    Other(String),
+}
@@ -0,0 +1,30 @@
+mod api;
+mod auth;
+mod config;
+mod error;
+mod models;
+mod products;
+mod utils;
+
+pub use api::ApiClient;
+pub use auth::Auth;
+pub use config::Config;
+pub use error::{Error, Result};
+pub use models::*;
+pub use products::*;
+
+pub mod prelude {
+    pub use crate::api::ApiClient;
+    pub use crate::auth::Auth;
+    pub use crate::config::Config;
+    pub use crate::error::{Error, Result};
+    pub use crate::products::*;
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`Cargo.lock`
`2`		`-/target`
	`2`	`+/target`