Refactor users management (#2)

* Create UserBackend trait

src/data/users_file_entity.rs

@@ -1,42 +1,11 @@
+use crate::actors::users_actor::UsersBackend;
 use crate::data::entity_manager::EntityManager;
 use crate::data::user::{User, UserID};
 use crate::utils::err::Res;
 use crate::utils::time::time;
 use std::net::IpAddr;
 
-fn hash_password<P: AsRef<[u8]>>(pwd: P) -> Res<String> {
-    Ok(bcrypt::hash(pwd, bcrypt::DEFAULT_COST)?)
-}
-
-fn verify_password<P: AsRef<[u8]>>(pwd: P, hash: &str) -> bool {
-    match bcrypt::verify(pwd, hash) {
-        Ok(r) => r,
-        Err(e) => {
-            log::warn!("Failed to verify password! {:?}", e);
-            false
-        }
-    }
-}
-
 impl EntityManager<User> {
-    pub fn find_by_username_or_email(&self, u: &str) -> Option<User> {
-        for entry in self.iter() {
-            if entry.username.eq(u) || entry.email.eq(u) {
-                return Some(entry.clone());
-            }
-        }
-        None
-    }
-
-    pub fn find_by_user_id(&self, id: &UserID) -> Option<User> {
-        for entry in self.iter() {
-            if entry.uid.eq(id) {
-                return Some(entry.clone());
-            }
-        }
-        None
-    }
-
     /// Update user information
     fn update_user<F>(&mut self, id: &UserID, update: F) -> bool
     where
@@ -54,8 +23,46 @@ impl EntityManager<User> {
 
         true
     }
+}
 
-    pub fn change_user_password(&mut self, id: &UserID, password: &str, temporary: bool) -> bool {
+fn hash_password<P: AsRef<[u8]>>(pwd: P) -> Res<String> {
+    Ok(bcrypt::hash(pwd, bcrypt::DEFAULT_COST)?)
+}
+
+fn verify_password<P: AsRef<[u8]>>(pwd: P, hash: &str) -> bool {
+    match bcrypt::verify(pwd, hash) {
+        Ok(r) => r,
+        Err(e) => {
+            log::warn!("Failed to verify password! {:?}", e);
+            false
+        }
+    }
+}
+
+impl UsersBackend for EntityManager<User> {
+    fn find_by_username_or_email(&self, u: &str) -> Option<User> {
+        for entry in self.iter() {
+            if entry.username.eq(u) || entry.email.eq(u) {
+                return Some(entry.clone());
+            }
+        }
+        None
+    }
+
+    fn find_by_user_id(&self, id: &UserID) -> Option<User> {
+        for entry in self.iter() {
+            if entry.uid.eq(id) {
+                return Some(entry.clone());
+            }
+        }
+        None
+    }
+
+    fn get_entire_users_list(&self) -> Vec<User> {
+        self.cloned()
+    }
+
+    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) => {
@@ -72,13 +79,13 @@ impl EntityManager<User> {
         })
     }
 
-    pub fn verify_user_password(&self, user: &UserID, password: &str) -> bool {
+    fn verify_user_password(&self, user: &UserID, password: &str) -> bool {
         self.find_by_user_id(user)
             .map(|u| verify_password(password, &u.password))
             .unwrap_or(false)
     }
 
-    pub 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) -> bool {
         self.update_user(id, |mut user| {
             user.last_successful_2fa.insert(ip, time());
 
@@ -89,10 +96,35 @@ impl EntityManager<User> {
         })
     }
 
-    pub fn clear_2fa_login_history(&mut self, id: &UserID) -> bool {
+    fn clear_2fa_login_history(&mut self, id: &UserID) -> bool {
         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) {
+            None => {
+                log::warn!(
+                    "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
+            }
+        }
+    }
+
+    fn update_or_insert_user(&mut self, user: User) -> Res {
+        self.update_or_push(user)
+    }
 }