Refactor users management (#8)

* Update users backend interface signatures

src/actors/users_actor.rs

@@ -1,28 +1,30 @@
-use actix::{Actor, Context, Handler, Message, MessageResult};
 use std::net::IpAddr;
 
+use actix::{Actor, Context, Handler, Message, MessageResult};
+
 use crate::data::user::{FactorID, GeneralSettings, GrantedClients, TwoFactor, User, UserID};
 use crate::utils::err::Res;
 
 /// User storage interface
 pub trait UsersSyncBackend {
-    fn find_by_username_or_email(&self, u: &str) -> Option<User>;
-    fn find_by_user_id(&self, id: &UserID) -> Option<User>;
-    fn get_entire_users_list(&self) -> Vec<User>;
+    fn find_by_username_or_email(&self, u: &str) -> Res<Option<User>>;
+    fn find_by_user_id(&self, id: &UserID) -> Res<Option<User>>;
+    fn get_entire_users_list(&self) -> Res<Vec<User>>;
     fn create_user_account(&mut self, settings: GeneralSettings) -> Res<UserID>;
     fn set_general_user_settings(&mut self, settings: GeneralSettings) -> Res;
-    fn change_user_password(&mut self, id: &UserID, password: &str, temporary: bool) -> bool;
-    fn verify_user_password(&self, user: &UserID, password: &str) -> bool;
-    fn add_2fa_factor(&mut self, user: &UserID, factor: TwoFactor) -> bool;
-    fn remove_2fa_factor(&mut self, user: &UserID, factor: FactorID) -> bool;
-    fn save_new_successful_2fa_authentication(&mut self, id: &UserID, ip: IpAddr) -> bool;
-    fn clear_2fa_login_history(&mut self, id: &UserID) -> bool;
-    fn delete_account(&mut self, id: &UserID) -> bool;
-    fn set_granted_2fa_clients(&mut self, id: &UserID, clients: GrantedClients) -> bool;
+    fn change_user_password(&mut self, id: &UserID, password: &str, temporary: bool) -> Res;
+    fn verify_user_password(&self, user: &UserID, password: &str) -> Res<bool>;
+    fn add_2fa_factor(&mut self, user: &UserID, factor: TwoFactor) -> Res;
+    fn remove_2fa_factor(&mut self, user: &UserID, factor: FactorID) -> Res;
+    fn save_new_successful_2fa_authentication(&mut self, id: &UserID, ip: IpAddr) -> Res;
+    fn clear_2fa_login_history(&mut self, id: &UserID) -> Res;
+    fn delete_account(&mut self, id: &UserID) -> Res;
+    fn set_granted_2fa_clients(&mut self, id: &UserID, clients: GrantedClients) -> Res;
 }
 
 #[derive(Debug)]
 pub enum LoginResult {
+    Error,
     AccountNotFound,
     InvalidPassword,
     AccountDisabled,
@@ -55,11 +57,8 @@ pub struct FindUserByUsername(pub String);
 pub struct FindUserByUsernameResult(pub Option<User>);
 
 #[derive(Message)]
-#[rtype(GetAllUsersResult)]
-pub struct GetAllUsersRequest;
-
-#[derive(Debug)]
-pub struct GetAllUsersResult(pub Vec<User>);
+#[rtype(result = "Vec<User>")]
+pub struct GetAllUsers;
 
 #[derive(Message)]
 #[rtype(result = "Option<UserID>")]
@@ -125,9 +124,17 @@ impl Handler<LoginRequest> for UsersActor {
 
     fn handle(&mut self, msg: LoginRequest, _ctx: &mut Self::Context) -> Self::Result {
         match self.manager.find_by_username_or_email(&msg.login) {
-            None => MessageResult(LoginResult::AccountNotFound),
-            Some(user) => {
-                if !self.manager.verify_user_password(&user.uid, &msg.password) {
+            Err(e) => {
+                log::error!("Failed to find user! {}", e);
+                MessageResult(LoginResult::Error)
+            }
+            Ok(None) => MessageResult(LoginResult::AccountNotFound),
+            Ok(Some(user)) => {
+                if self
+                    .manager
+                    .verify_user_password(&user.uid, &msg.password)
+                    .unwrap_or(false)
+                {
                     return MessageResult(LoginResult::InvalidPassword);
                 }
 
@@ -159,8 +166,16 @@ impl Handler<ChangePasswordRequest> for UsersActor {
     type Result = <ChangePasswordRequest as actix::Message>::Result;
 
     fn handle(&mut self, msg: ChangePasswordRequest, _ctx: &mut Self::Context) -> Self::Result {
-        self.manager
+        match self
+            .manager
             .change_user_password(&msg.user_id, &msg.new_password, msg.temporary)
+        {
+            Ok(_) => true,
+            Err(e) => {
+                log::error!("Failed to change user password! {:?}", e);
+                false
+            }
+        }
     }
 }
 
@@ -168,7 +183,13 @@ impl Handler<Add2FAFactor> for UsersActor {
     type Result = <Add2FAFactor as actix::Message>::Result;
 
     fn handle(&mut self, msg: Add2FAFactor, _ctx: &mut Self::Context) -> Self::Result {
-        self.manager.add_2fa_factor(&msg.0, msg.1)
+        match self.manager.add_2fa_factor(&msg.0, msg.1) {
+            Ok(_) => true,
+            Err(e) => {
+                log::error!("Failed to add 2FA factor! {}", e);
+                false
+            }
+        }
     }
 }
 
@@ -176,7 +197,13 @@ impl Handler<Remove2FAFactor> for UsersActor {
     type Result = <Remove2FAFactor as actix::Message>::Result;
 
     fn handle(&mut self, msg: Remove2FAFactor, _ctx: &mut Self::Context) -> Self::Result {
-        self.manager.remove_2fa_factor(&msg.0, msg.1)
+        match self.manager.remove_2fa_factor(&msg.0, msg.1) {
+            Ok(_) => true,
+            Err(e) => {
+                log::error!("Failed to remove 2FA factor! {}", e);
+                false
+            }
+        }
     }
 }
 
@@ -184,22 +211,46 @@ impl Handler<AddSuccessful2FALogin> for UsersActor {
     type Result = <AddSuccessful2FALogin as actix::Message>::Result;
 
     fn handle(&mut self, msg: AddSuccessful2FALogin, _ctx: &mut Self::Context) -> Self::Result {
-        self.manager
+        match self
+            .manager
             .save_new_successful_2fa_authentication(&msg.0, msg.1)
+        {
+            Ok(_) => true,
+            Err(e) => {
+                log::error!("Failed to save successful 2FA authentication! {}", e);
+                false
+            }
+        }
     }
 }
 
 impl Handler<Clear2FALoginHistory> for UsersActor {
     type Result = <Clear2FALoginHistory as actix::Message>::Result;
     fn handle(&mut self, msg: Clear2FALoginHistory, _ctx: &mut Self::Context) -> Self::Result {
-        self.manager.clear_2fa_login_history(&msg.0)
+        match self.manager.clear_2fa_login_history(&msg.0) {
+            Ok(_) => true,
+            Err(e) => {
+                log::error!(
+                    "Failed to clear 2FA login history of user {:?} ! {}",
+                    msg.0,
+                    e
+                );
+                false
+            }
+        }
     }
 }
 
 impl Handler<SetGrantedClients> for UsersActor {
     type Result = <SetGrantedClients as actix::Message>::Result;
     fn handle(&mut self, msg: SetGrantedClients, _ctx: &mut Self::Context) -> Self::Result {
-        self.manager.set_granted_2fa_clients(&msg.0, msg.1)
+        match self.manager.set_granted_2fa_clients(&msg.0, msg.1) {
+            Ok(_) => true,
+            Err(e) => {
+                log::error!("Failed to set granted 2FA clients! {}", e);
+                false
+            }
+        }
     }
 }
 
@@ -207,7 +258,13 @@ impl Handler<GetUserRequest> for UsersActor {
     type Result = MessageResult<GetUserRequest>;
 
     fn handle(&mut self, msg: GetUserRequest, _ctx: &mut Self::Context) -> Self::Result {
-        MessageResult(GetUserResult(self.manager.find_by_user_id(&msg.0)))
+        MessageResult(GetUserResult(match self.manager.find_by_user_id(&msg.0) {
+            Ok(r) => r,
+            Err(e) => {
+                log::error!("Failed to find user by id! {}", e);
+                None
+            }
+        }))
     }
 }
 
@@ -215,7 +272,12 @@ impl Handler<VerifyUserPasswordRequest> for UsersActor {
     type Result = <VerifyUserPasswordRequest as actix::Message>::Result;
 
     fn handle(&mut self, msg: VerifyUserPasswordRequest, _ctx: &mut Self::Context) -> Self::Result {
-        self.manager.verify_user_password(&msg.0, &msg.1)
+        self.manager
+            .verify_user_password(&msg.0, &msg.1)
+            .unwrap_or_else(|e| {
+                log::error!("Failed to verify user password! {}", e);
+                false
+            })
     }
 }
 
@@ -224,16 +286,27 @@ impl Handler<FindUserByUsername> for UsersActor {
 
     fn handle(&mut self, msg: FindUserByUsername, _ctx: &mut Self::Context) -> Self::Result {
         MessageResult(FindUserByUsernameResult(
-            self.manager.find_by_username_or_email(&msg.0),
+            self.manager
+                .find_by_username_or_email(&msg.0)
+                .unwrap_or_else(|e| {
+                    log::error!("Failed to find user by username or email! {}", e);
+                    None
+                }),
         ))
     }
 }
 
-impl Handler<GetAllUsersRequest> for UsersActor {
-    type Result = MessageResult<GetAllUsersRequest>;
+impl Handler<GetAllUsers> for UsersActor {
+    type Result = <GetAllUsers as actix::Message>::Result;
 
-    fn handle(&mut self, _msg: GetAllUsersRequest, _ctx: &mut Self::Context) -> Self::Result {
-        MessageResult(GetAllUsersResult(self.manager.get_entire_users_list()))
+    fn handle(&mut self, _msg: GetAllUsers, _ctx: &mut Self::Context) -> Self::Result {
+        match self.manager.get_entire_users_list() {
+            Ok(r) => r,
+            Err(e) => {
+                log::error!("Failed to get entire users list! {}", e);
+                vec![]
+            }
+        }
     }
 }
 
@@ -255,6 +328,12 @@ impl Handler<DeleteUserRequest> for UsersActor {
     type Result = <DeleteUserRequest as actix::Message>::Result;
 
     fn handle(&mut self, msg: DeleteUserRequest, _ctx: &mut Self::Context) -> Self::Result {
-        self.manager.delete_account(&msg.0)
+        match self.manager.delete_account(&msg.0) {
+            Ok(_) => true,
+            Err(e) => {
+                log::error!("Failed to delete user account! {}", e);
+                false
+            }
+        }
     }
 }