Refactor users management (#8)

* Update users backend interface signatures

src/data/users_file_entity.rs

@@ -1,27 +1,28 @@
+use std::net::IpAddr;
+
 use crate::actors::users_actor::UsersSyncBackend;
 use crate::data::entity_manager::EntityManager;
 use crate::data::user::{FactorID, GeneralSettings, GrantedClients, TwoFactor, User, UserID};
 use crate::utils::err::{new_error, Res};
 use crate::utils::time::time;
-use std::net::IpAddr;
 
 impl EntityManager<User> {
     /// Update user information
-    fn update_user<F>(&mut self, id: &UserID, update: F) -> bool
+    fn update_user<F>(&mut self, id: &UserID, update: F) -> Res
     where
         F: FnOnce(User) -> User,
     {
-        let user = match self.find_by_user_id(id) {
-            None => return false,
+        let user = match self.find_by_user_id(id)? {
+            None => return new_error(format!("Failed to find user {:?}", id)),
             Some(user) => user,
         };
 
         if let Err(e) = self.replace_entries(|u| u.uid.eq(id), &update(user)) {
             log::error!("Failed to update user information! {:?}", e);
-            return false;
+            return Err(e);
         }
 
-        true
+        Ok(())
     }
 }
 
@@ -40,26 +41,26 @@ fn verify_password<P: AsRef<[u8]>>(pwd: P, hash: &str) -> bool {
 }
 
 impl UsersSyncBackend for EntityManager<User> {
-    fn find_by_username_or_email(&self, u: &str) -> Option<User> {
+    fn find_by_username_or_email(&self, u: &str) -> Res<Option<User>> {
         for entry in self.iter() {
             if entry.username.eq(u) || entry.email.eq(u) {
-                return Some(entry.clone());
+                return Ok(Some(entry.clone()));
             }
         }
-        None
+        Ok(None)
     }
 
-    fn find_by_user_id(&self, id: &UserID) -> Option<User> {
+    fn find_by_user_id(&self, id: &UserID) -> Res<Option<User>> {
         for entry in self.iter() {
             if entry.uid.eq(id) {
-                return Some(entry.clone());
+                return Ok(Some(entry.clone()));
             }
         }
-        None
+        Ok(None)
     }
 
-    fn get_entire_users_list(&self) -> Vec<User> {
-        self.cloned()
+    fn get_entire_users_list(&self) -> Res<Vec<User>> {
+        Ok(self.cloned())
     }
 
     fn create_user_account(&mut self, settings: GeneralSettings) -> Res<UserID> {
@@ -73,25 +74,14 @@ impl UsersSyncBackend for EntityManager<User> {
     }
 
     fn set_general_user_settings(&mut self, settings: GeneralSettings) -> Res {
-        let res = self.update_user(&settings.uid.clone(), |mut user| {
+        self.update_user(&settings.uid.clone(), |mut user| {
             user.update_general_settings(settings);
             user
-        });
-
-        match res {
-            true => Ok(()),
-            false => new_error("Failed to update user general settings!".to_string()),
-        }
+        })
     }
 
-    fn change_user_password(&mut self, id: &UserID, password: &str, temporary: bool) -> bool {
-        let new_hash = match hash_password(password) {
-            Ok(h) => h,
-            Err(e) => {
-                log::error!("Failed to hash user password! {}", e);
-                return false;
-            }
-        };
+    fn change_user_password(&mut self, id: &UserID, password: &str, temporary: bool) -> Res {
+        let new_hash = hash_password(password)?;
 
         self.update_user(id, |mut user| {
             user.password = new_hash;
@@ -101,27 +91,28 @@ impl UsersSyncBackend for EntityManager<User> {
         })
     }
 
-    fn verify_user_password(&self, user: &UserID, password: &str) -> bool {
-        self.find_by_user_id(user)
+    fn verify_user_password(&self, user: &UserID, password: &str) -> Res<bool> {
+        Ok(self
+            .find_by_user_id(user)?
             .map(|u| verify_password(password, &u.password))
-            .unwrap_or(false)
+            .unwrap_or(false))
     }
 
-    fn add_2fa_factor(&mut self, id: &UserID, factor: TwoFactor) -> bool {
+    fn add_2fa_factor(&mut self, id: &UserID, factor: TwoFactor) -> Res {
         self.update_user(id, |mut user| {
             user.two_factor.push(factor);
             user
         })
     }
 
-    fn remove_2fa_factor(&mut self, id: &UserID, factor_id: FactorID) -> bool {
+    fn remove_2fa_factor(&mut self, id: &UserID, factor_id: FactorID) -> Res {
         self.update_user(id, |mut user| {
             user.two_factor.retain(|f| f.id != factor_id);
             user
         })
     }
 
-    fn save_new_successful_2fa_authentication(&mut self, id: &UserID, ip: IpAddr) -> bool {
+    fn save_new_successful_2fa_authentication(&mut self, id: &UserID, ip: IpAddr) -> Res {
         self.update_user(id, |mut user| {
             user.last_successful_2fa.insert(ip, time());
 
@@ -132,35 +123,28 @@ impl UsersSyncBackend for EntityManager<User> {
         })
     }
 
-    fn clear_2fa_login_history(&mut self, id: &UserID) -> bool {
+    fn clear_2fa_login_history(&mut self, id: &UserID) -> Res {
         self.update_user(id, |mut user| {
             user.last_successful_2fa = Default::default();
             user
         })
     }
 
-    fn delete_account(&mut self, id: &UserID) -> bool {
-        let user = match self.find_by_user_id(id) {
+    fn delete_account(&mut self, id: &UserID) -> Res {
+        let user = match self.find_by_user_id(id)? {
             None => {
-                log::warn!(
+                return new_error(format!(
                     "Could not delete account {:?} because it was not found!",
                     id
-                );
-                return false;
+                ));
             }
             Some(s) => s,
         };
 
-        match self.remove(&user) {
-            Ok(_) => true,
-            Err(e) => {
-                log::error!("Failed to update delete account! {:?}", e);
-                false
-            }
-        }
+        self.remove(&user)
     }
 
-    fn set_granted_2fa_clients(&mut self, id: &UserID, clients: GrantedClients) -> bool {
+    fn set_granted_2fa_clients(&mut self, id: &UserID, clients: GrantedClients) -> Res {
         self.update_user(id, |mut user| {
             user.authorized_clients = clients.to_user();
             user