Used r2d2 for db connection pool.

src/webui/services.rs

@@ -1,27 +1,51 @@
-use std::path::PathBuf;
+use crate::services::{SessionService, UserService};
+
+use actix_web::{error, Result};
+use r2d2::PooledConnection;
 use r2d2_sqlite::SqliteConnectionManager;
-use crate::services::{SessionService};
-use crate::util::{CustomResult, Error, SQLiteConnectionFactory};
+
+use std::path::PathBuf;
 
 pub type DbPool = r2d2::Pool<SqliteConnectionManager>;
 
-pub fn creat_db_pool(path: & PathBuf) -> DbPool {
+pub fn creat_db_pool(path: &PathBuf) -> DbPool {
     let manager = SqliteConnectionManager::file(path);
     r2d2::Pool::new(manager).unwrap()
 }
 
+#[derive(Clone)]
 struct ServicesCache {
     session_service: SessionService,
 }
 
-pub struct Services {}
+#[derive(Clone)]
+pub struct Services {
+    pool: DbPool,
+    cache: ServicesCache,
+}
 
 impl Services {
-
-    pub fn get_authentication_service(dbPool: & DbPool) -> CustomResult<SessionService> {
-        let mut conn = dbPool.get().unwrap();
-        SessionService::from_conn(&mut conn)
+    pub fn new(pool: DbPool) -> Services {
+        let mut conn = pool.get().unwrap();
+        let session_service = SessionService::from_conn(&mut conn).unwrap();
+        let cache = ServicesCache { session_service };
+        Services { pool, cache }
     }
 
+    pub fn get_connection(&self) -> Result<PooledConnection<SqliteConnectionManager>> {
+        self.pool
+            .get()
+            .map_err(|_e| error::ErrorBadRequest("Cannot get DB connection."))
+    }
 
+    pub fn get_authentication_service(&self) -> Result<SessionService> {
+        Ok(self.cache.session_service.clone())
+    }
+
+    pub fn get_user_service<'a>(
+        &'a self,
+        conn: &'a PooledConnection<SqliteConnectionManager>,
+    ) -> Result<UserService> {
+        Ok(UserService::new(conn))
+    }
 }