added container

src/container.rs

@@ -0,0 +1,10 @@
+use mysql::PooledConn;
+
+use crate::{
+    repository::filter_repo::FilterRepo, service::filter_service::FilterService,
+};
+
+pub fn get_filter_service(pool: &mut PooledConn) -> FilterService {
+    let repo = FilterRepo::new(pool);
+    return FilterService::new(repo);
+}

src/main.rs

@@ -2,13 +2,14 @@ use clap::Parser;
 use cli::cli::{Cli, Commands};
 use database::db::Db;
 use mysql::PooledConn;
-use service::{merchant_service, schema_service, filter_service};
+use service::{merchant_service, schema_service, filter_service::FilterService};
 
 pub mod cli;
 pub mod database;
 pub mod entity;
 pub mod repository;
 pub mod service;
+pub mod container;
 
 fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
     let args = Cli::parse();
@@ -23,10 +24,11 @@ fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
             schema_service::get_columns(&search.unwrap(), &mut conn)
         },
         Commands::Filter { filter_id, config, all } => {
+            let mut filter_service: FilterService = container::get_filter_service(&mut conn);
             if config {
-                filter_service::get_filter_configs(&filter_id, &mut conn)
+                filter_service.get_filter_configs(&filter_id)
             } else {
-                filter_service::get_filter(&filter_id, all, &mut conn)
+                filter_service.get_filter(&filter_id, all)
             }
         },
     }

src/repository/filter_repo.rs

@@ -13,7 +13,7 @@ impl<'a> FilterRepo<'a> {
     }
 
     pub fn find_by_id(
-        self,
+        &mut self,
         filter_id: &usize,
     ) -> Result<Vec<Filter>, mysql::Error> {
         let stat = self.db_pool
@@ -39,7 +39,7 @@ impl<'a> FilterRepo<'a> {
     }
 
     pub fn find_filter_configs(
-        self,
+        &mut self,
         filter_id: &usize,
     ) -> Result<Vec<FilterConfig>, mysql::Error> {
         let stat = self.db_pool

src/service/filter_service.rs

@@ -2,62 +2,69 @@ use crate::{
     entity::{filter::Filter, filter_config::FilterConfig},
     repository::filter_repo::FilterRepo,
 };
-use mysql::PooledConn;
 
-pub fn get_filter(filter_id: &usize, all: bool, conn: &mut PooledConn) {
+pub struct FilterService<'a> {
-    let repo: FilterRepo = FilterRepo::new(conn);
+    repo: FilterRepo<'a>,
-    let result = repo.find_by_id(filter_id);
+}
 
-    match result {
+impl<'a> FilterService<'a> {
-        Ok(filters) => {
+    pub fn new(repo: FilterRepo<'a>) -> Self {
-            if filters.is_empty() {
+        Self { repo }
-                println!("Filter not found!");
+    }
-            } else {
-                filters.into_iter().for_each(|filter: Filter| {
-                    println!("{}", "-".repeat(150));
-                    println!("Module ID:    {}", filter.filter_module_id);
-                    println!("FileName:     {}", filter.file_name);
-                    println!("Description:  {}", filter.description);
-                    println!("ModuleNo:     {}", filter.filter_module_no);
-                    println!("FilterUser:   {}", filter.filter_user);
-                });
 
-                if all {
+    pub fn get_filter(&mut self, filter_id: &usize, all: bool) {
-                    get_filter_configs(filter_id, conn)
+        let result = self.repo.find_by_id(filter_id);
+
+        match result {
+            Ok(filters) => {
+                if filters.is_empty() {
+                    println!("Filter not found!");
                 } else {
+                    filters.into_iter().for_each(|filter: Filter| {
+                        println!("{}", "-".repeat(150));
+                        println!("Module ID:    {}", filter.filter_module_id);
+                        println!("FileName:     {}", filter.file_name);
+                        println!("Description:  {}", filter.description);
+                        println!("ModuleNo:     {}", filter.filter_module_no);
+                        println!("FilterUser:   {}", filter.filter_user);
+                    });
+
+                    if all {
+                        self.get_filter_configs(filter_id)
+                    } else {
+                        println!("{}", "-".repeat(150));
+                    }
+                }
+            }
+            Err(err) => panic!("{}", err),
+        };
+    }
+
+    pub fn get_filter_configs(&mut self, filter_id: &usize) {
+        let result = self.repo.find_filter_configs(filter_id);
+
+        match result {
+            Ok(filter_configs) => {
+                if filter_configs.is_empty() {
+                    println!("No filter configs found!");
+                } else {
+                    println!("{}", "-".repeat(150));
+                    filter_configs
+                        .into_iter()
+                        .for_each(|filter_config: FilterConfig| {
+                            println!(
+                                "{0: <25} | {1: <20} | {2: <20} | {3: <10} | {4: <10}",
+                                filter_config.attribute,
+                                filter_config.value1,
+                                filter_config.value2.unwrap_or("n/a".to_string()),
+                                filter_config.upd_ts,
+                                filter_config.name
+                            );
+                        });
                     println!("{}", "-".repeat(150));
                 }
             }
-        }
+            Err(err) => panic!("{}", err),
-        Err(err) => panic!("{}", err),
+        };
-    };
+    }
-}
-
-pub fn get_filter_configs(filter_id: &usize, conn: &mut PooledConn) {
-    let repo: FilterRepo = FilterRepo::new(conn);
-    let result = repo.find_filter_configs(filter_id);
-
-    match result {
-        Ok(filter_configs) => {
-            if filter_configs.is_empty() {
-                println!("No filter configs found!");
-            } else {
-                println!("{}", "-".repeat(150));
-                filter_configs
-                    .into_iter()
-                    .for_each(|filter_config: FilterConfig| {
-                        println!(
-                            "{0: <25} | {1: <20} | {2: <20} | {3: <10} | {4: <10}",
-                            filter_config.attribute,
-                            filter_config.value1,
-                            filter_config.value2.unwrap_or("n/a".to_string()),
-                            filter_config.upd_ts,
-                            filter_config.name
-                        );
-                    });
-                println!("{}", "-".repeat(150));
-            }
-        }
-        Err(err) => panic!("{}", err),
-    };
 }