Merge branch 'feature/check-account-status' into development

Author: setoelkahfi

crates/smbcloud-model/src/account.rs

@@ -48,6 +48,7 @@ pub struct SmbAuthorization {
     pub error_code: Option<ErrorCode>,
 }
 
+/// TODO: Move to ErrorResponse
 #[derive(Debug, Serialize_repr, Deserialize_repr, PartialEq)]
 #[repr(u32)]
 #[tsync]

crates/smbcloud-model/src/error_codes.rs

@@ -44,25 +44,49 @@ pub enum ErrorCode {
     // Account
     #[error("Unauthorized access.")]
     Unauthorized = 100,
+    #[error("Invalid params.")]
+    InvalidParams = 101,
+    // Account not ready errors.
+    #[error("Email not found.")]
+    EmailNotFound = 1000,
+    #[error("Email unverified.")]
+    EmailNotVerified = 1001,
+    #[error("Email confirmation failed.")]
+    EmailConfirmationFailed = 1002,
+    #[error("Password is unset.")]
+    PasswordNotSet = 1003,
+    #[error("GitHub email is not connected.")]
+    GitHubEmailNotConnected = 1004,
     #[error("Email already exists.")]
     EmailAlreadyExist = 1005,
+    #[error("Invalid password.")]
+    InvalidPassword = 1006,
     // Projects
     #[error("Project not found.")]
-    ProjectNotFound = 1000,
+    ProjectNotFound = 2000,
     #[error("Runner not supported.")]
-    UnsupportedRunner = 1001,
+    UnsupportedRunner = 2001,
 }
 
 impl ErrorCode {
     /// Cannot expose the ErrorCode enum directly to Ruby,
     /// so we need to get it from i32.
     pub fn from_i32(value: i32) -> Self {
         match value {
-            // Account
+            // Generic
             100 => ErrorCode::Unauthorized,
+            101 => ErrorCode::InvalidParams,
+            // Account not ready errors
+            1000 => ErrorCode::EmailNotFound,
+            1001 => ErrorCode::EmailNotVerified,
+            1002 => ErrorCode::EmailConfirmationFailed,
+            1003 => ErrorCode::PasswordNotSet,
+            1004 => ErrorCode::GitHubEmailNotConnected,
             1005 => ErrorCode::EmailAlreadyExist,
+            1006 => ErrorCode::InvalidPassword,
             // Projects
-            1000 => ErrorCode::ProjectNotFound,
+            2000 => ErrorCode::ProjectNotFound, // Projects
+            2001 => ErrorCode::UnsupportedRunner,
             // Generic errors
             5 => ErrorCode::Cancel,
             4 => ErrorCode::MissingConfig,
@@ -79,19 +103,28 @@ impl ErrorCode {
         debug!("Language code: {:?}, {}", l, self);
         match self {
             ErrorCode::Unknown => "Unknown error.",
-            ErrorCode::ProjectNotFound => "Project not found.",
+            // Networking
             ErrorCode::ParseError => "Parse error.",
             ErrorCode::NetworkError => {
                 "Network error. Please check your internet connection and try again."
             }
-            // Accounts
+            // Generic
             ErrorCode::Unauthorized => "Unauthorized access.",
+            ErrorCode::InvalidParams => "Invalid parameters.",
+            // Account not ready errors
+            ErrorCode::EmailNotFound => "Email not found.",
+            ErrorCode::EmailNotVerified => "Email not verified.",
+            ErrorCode::EmailConfirmationFailed => "Email confirmation faile.",
+            ErrorCode::PasswordNotSet => "Password is not set.",
+            ErrorCode::GitHubEmailNotConnected => "GitHub email is not connected.",
             ErrorCode::EmailAlreadyExist => "Email already exists.",
-
+            ErrorCode::InvalidPassword => "Invalid password.",
+            // CLI Generic errors
             ErrorCode::InputError => "Input error.",
             ErrorCode::MissingConfig => "Missing config.",
             ErrorCode::Cancel => "Cancelled operation.",
             // Projects
+            ErrorCode::ProjectNotFound => "Project not found.",
             ErrorCode::UnsupportedRunner => "Unsupported runner.",
         }
     }

crates/smbcloud-network/src/network.rs

@@ -52,7 +52,7 @@ pub async fn check_internet_connection() -> bool {
 pub async fn parse_error_response<T: DeserializeOwned>(
     response: Response,
 ) -> Result<T, ErrorResponse> {
-    let response_body = match response.text().await {
+    let error_response_body = match response.text().await {
         Ok(body) => body,
         Err(e) => {
             error!("Failed to get response body: {:?}", e);
@@ -66,13 +66,13 @@ pub async fn parse_error_response<T: DeserializeOwned>(
     if LOG_RESPONSE_BODY {
         println!();
         println!("Parse Error >>>>");
-        println!("{:?}", serde_json::to_string_pretty(&response_body));
+        println!("{:?}", serde_json::to_string_pretty(&error_response_body));
         println!("Parse Error >>>>");
         println!();
     }
 
-    let e = match serde_json::from_str::<ErrorResponse>(&response_body) {
-        Ok(json) => json,
+    let error_response = match serde_json::from_str::<T>(&error_response_body) {
+        Ok(error_response) => error_response,
         Err(e) => {
             error!("Failed to parse error response: {:?}", e);
             return Err(ErrorResponse::Error {
@@ -81,41 +81,28 @@ pub async fn parse_error_response<T: DeserializeOwned>(
             });
         }
     };
-    error!("Error response: {:?}", e);
-    Err(e)
+    // The parsing itself is succeed.
+    Ok(error_response)
 }
 
 pub async fn request_login(builder: RequestBuilder) -> Result<AccountStatus, ErrorResponse> {
     let response = builder.send().await;
     let response = match response {
         Ok(response) => response,
         Err(e) => {
-            error!("Failed to get response: {:?}", e);
+            error!("request_login: Failed to get response: {:?}", e);
             return Err(ErrorResponse::Error {
                 error_code: ErrorCode::NetworkError,
                 message: ErrorCode::NetworkError.message(None).to_string(),
             });
         }
     };
 
-    let response = match response.status() {
-        reqwest::StatusCode::OK
-        | reqwest::StatusCode::NOT_FOUND
-        | reqwest::StatusCode::UNPROCESSABLE_ENTITY => response,
-        status => {
-            error!(
-                "Response are neither OK, NOT_FOUND, or UNPROCESSABLE_ENTITY: {:?}",
-                status
-            );
-            return parse_error_response(response).await;
-        }
-    };
-
     if LOG_RESPONSE_BODY {
         println!();
-        println!("Parse >>>>");
+        println!("request_login: Parse >>>>");
         println!("{:?}", &response.status());
-        println!("Parse >>>>");
+        println!("request_login: Parse >>>>");
         println!();
     }
 
@@ -133,6 +120,30 @@ pub async fn request_login(builder: RequestBuilder) -> Result<AccountStatus, Err
             };
             Ok(AccountStatus::Ready { access_token })
         }
+        (StatusCode::OK, None) => {
+            // Silent login from oauth. Need improvement.
+            let error_response = match parse_error_response::<ErrorResponse>(response).await {
+                Ok(error) => error,
+                Err(_) => return Ok(AccountStatus::NotFound),
+            };
+            match error_response {
+                ErrorResponse::Error {
+                    error_code,
+                    message,
+                } => match error_code {
+                    ErrorCode::EmailNotVerified => Ok(AccountStatus::Incomplete {
+                        status: smbcloud_model::account::ErrorCode::EmailUnverified,
+                    }),
+                    ErrorCode::PasswordNotSet => Ok(AccountStatus::Incomplete {
+                        status: smbcloud_model::account::ErrorCode::PasswordNotSet,
+                    }),
+                    ErrorCode::Unknown => Ok(AccountStatus::Ready {
+                        access_token: "tokenization".to_string(),
+                    }),
+                    _ => Ok(AccountStatus::NotFound),
+                },
+            }
+        }
         (StatusCode::NOT_FOUND, _) => {
             // Account not found
             Ok(AccountStatus::NotFound)
@@ -193,6 +204,7 @@ pub async fn request<R: DeserializeOwned>(builder: RequestBuilder) -> Result<R,
         reqwest::StatusCode::OK | reqwest::StatusCode::CREATED => response,
         status => {
             error!("Failed to get response: {:?}", status);
+            // This should handle parsing the error response.
             return parse_error_response(response).await;
         }
     };

crates/smbcloud-networking-account/src/oauth/get_account_status.rs

@@ -0,0 +1,27 @@
+use {
+    reqwest::Client,
+    smbcloud_model::{error_codes::ErrorResponse, login::AccountStatus},
+    smbcloud_network::{environment::Environment, network::request_login},
+    smbcloud_networking::{
+        constants::PATH_ACCOUNT_STATUS, smb_base_url_builder, smb_client::SmbClient,
+    },
+};
+
+pub async fn get_account_status(
+    env: Environment,
+    client: SmbClient,
+    email: &str,
+) -> Result<AccountStatus, ErrorResponse> {
+    let builder = Client::new()
+        .get(build_url(env, &client, email))
+        .header("Accept", "application/json")
+        .header("Content-Type", "application/x-www-form-urlencoded");
+    request_login(builder).await
+}
+
+fn build_url(env: Environment, client: &SmbClient, email: &str) -> String {
+    let mut url_builder = smb_base_url_builder(env, client);
+    url_builder.add_route(PATH_ACCOUNT_STATUS);
+    url_builder.add_param("email", email);
+    url_builder.build()
+}

crates/smbcloud-networking-account/src/oauth/mod.rs

@@ -1,3 +1,4 @@
+pub mod get_account_status;
 pub mod get_consent_url;
 pub mod get_profile;
 pub mod get_token;

crates/smbcloud-networking/src/constants.rs

@@ -12,6 +12,7 @@ pub const SMB_USER_AGENT: &str = "smbcloud-cli";
 
 // Paths
 pub const PATH_USERS_CHECK_EMAIL: &str = "v1/check_email";
+pub const PATH_ACCOUNT_STATUS: &str = "v1/account_status";
 pub const PATH_USERS_ME: &str = "v1/me";
 pub const PATH_USERS: &str = "v1/users";
 pub const PATH_USERS_PASSWORD: &str = "v1/users/password";