made merchant object oriented

src/container.rs

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

src/main.rs

@@ -2,7 +2,7 @@ use clap::Parser;
 use cli::cli::{Cli, Commands};
 use database::db::Db;
 use mysql::PooledConn;
-use service::{merchant_service, schema_service, filter_service::FilterService};
+use service::{schema_service, filter_service::FilterService};
 
 pub mod cli;
 pub mod database;
@@ -18,7 +18,8 @@ fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
 
     match args.mode {
         Commands::Merch { search } => {
-            merchant_service::get_merchant(&search.unwrap(), &mut conn);
+            let merchant_service = container::get_merchant_service(&mut conn);
+            merchant_service.get_merchant(&search.unwrap());
         }
         Commands::Schema { search } => {
             schema_service::get_columns(&search.unwrap(), &mut conn)

src/repository/merchant_repo.rs

@@ -2,19 +2,29 @@ use mysql::{params, prelude::Queryable, PooledConn};
 
 use crate::entity::merchant::Merchant;
 
-pub fn find_by_name_or_id(
-    search: &str,
-    conn: &mut PooledConn,
-) -> Result<Vec<Merchant>, mysql::Error> {
-    let stat = conn
+pub struct MerchantRepo<'a> {
+    db_pool: &'a mut PooledConn,
+}
+
+impl<'a> MerchantRepo<'a> {
+    pub fn new(db_pool: &'a mut PooledConn) -> Self {
+        Self { db_pool }
+    }
+
+    pub fn find_by_name_or_id(
+        self,
+        search: &str,
+    ) -> Result<Vec<Merchant>, mysql::Error> {
+        let stat = self.db_pool
         .prep("SELECT m_name, m_id FROM global_data.merchant WHERE m_id = :search OR m_name LIKE :search2;")
         .unwrap();
 
-    let search_like = format!("%{}%", search);
+        let search_like = format!("%{}%", search);
 
-    conn.exec_map(
-        stat,
-        params! {"search" => search, "search2" => search_like},
-        |(m_name, m_id)| Merchant { m_name, m_id },
-    )
+        self.db_pool.exec_map(
+            stat,
+            params! {"search" => search, "search2" => search_like},
+            |(m_name, m_id)| Merchant { m_name, m_id },
+        )
+    }
 }

src/service/merchant_service.rs

@@ -1,19 +1,31 @@
-use mysql::PooledConn;
+use crate::repository::merchant_repo::MerchantRepo;
 
-use crate::repository::merchant_repo;
-
-pub fn get_merchant(search: &str, conn: &mut PooledConn) {
-    let merchants = merchant_repo::find_by_name_or_id(search, conn);
-
-    match merchants {
-        Ok(merchants) => {
-            if merchants.is_empty() {
-                println!("Merchant not found!");
-            }
-            merchants.into_iter().for_each(|merchant| {
-                println!("Merchant: {}", merchant.m_name);
-            })
-        }
-        Err(err) => panic!("{}", err),
-    };
+pub struct MerchantService<'a> {
+    repo: MerchantRepo<'a>,
+}
+
+impl<'a> MerchantService<'a> {
+    pub fn new(repo: MerchantRepo<'a>) -> Self {
+        Self { repo }
+    }
+
+    pub fn get_merchant(self, search: &str) {
+        let merchants = self.repo.find_by_name_or_id(search);
+
+        match merchants {
+            Ok(merchants) => {
+                if merchants.is_empty() {
+                    println!("Merchant not found!");
+                }
+                merchants.into_iter().for_each(|merchant| {
+                    println!("{}", "-".repeat(150));
+                    println!("Merchant: {}", merchant.m_name);
+                    println!("M-ID: {}", merchant.m_id);
+                });
+
+                println!("{}", "-".repeat(150));
+            }
+            Err(err) => panic!("{}", err),
+        };
+    }
 }