added filter configs

src/cli/cli.rs

@@ -25,6 +25,10 @@ pub enum Commands {
         search: Option<String>,
     },
     Filter {
-        filter_id: usize
+        filter_id: usize,
+        #[arg(short, long)]
+        all: bool,
+        #[arg(short, long)]
+        config: bool,
     }
 }

src/entity/filter_config.rs

@@ -0,0 +1,9 @@
+#[derive(Debug, PartialEq)]
+pub struct FilterConfig {
+    pub attribute: String,
+    pub value1: String,
+    pub value2: Option<String>,
+    pub name: String,
+    pub upd_ts: mysql::Value,
+}
+

src/entity/filter_log.rs

@@ -0,0 +1,8 @@
+#[derive(Debug, PartialEq, Eq)]
+pub struct FilterLog {
+    pub run_ts: String,
+    pub error_code: String,
+    pub error_msg: String,
+    pub mysql_error: String,
+}
+

src/entity/mod.rs

@@ -1,3 +1,5 @@
 pub mod merchant;
 pub mod schema;
 pub mod filter;
+pub mod filter_log;
+pub mod filter_config;

src/main.rs

@@ -22,8 +22,12 @@ fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
         Commands::Schema { search } => {
             schema_service::get_columns(&search.unwrap(), &mut conn)
         },
-        Commands::Filter { filter_id } => {
+        Commands::Filter { filter_id, config, all } => {
-            filter_service::get_filter(&filter_id, &mut conn)
+            if config {
+                filter_service::get_filter_configs(filter_id, &mut conn)
+            } else {
+                filter_service::get_filter(&filter_id, all, &mut conn)
+            }
         },
     }
 

src/repository/filter_repo.rs

@@ -1,6 +1,6 @@
 use mysql::{params, prelude::Queryable, PooledConn};
 
-use crate::entity::filter::Filter;
+use crate::entity::{filter::Filter, filter_config::FilterConfig};
 
 pub fn find_by_id(filter_id: &usize, conn: &mut PooledConn) -> Result<Vec<Filter>, mysql::Error> {
     let stat = conn
@@ -24,3 +24,33 @@ pub fn find_by_id(filter_id: &usize, conn: &mut PooledConn) -> Result<Vec<Filter
         },
     )
 }
+
+pub fn find_filter_configs(
+    filter_id: usize,
+    conn: &mut PooledConn,
+) -> Result<Vec<FilterConfig>, mysql::Error> {
+    let stat = conn
+        .prep(
+            "
+            SELECT t1.attribute, t1.value1, IF(t1.value2 is null or t1.value2 = '', 'EMPTY', t1.value2) as value2, t2.name, t1.upd_ts
+            FROM filter_config t1
+            JOIN global_data.effi_user t2 on t1.upd_user = t2.user_id
+            WHERE t1.filter_id = :filter_id
+        ",
+        )
+        .unwrap();
+
+    conn.exec_map(
+        stat,
+        params! {"filter_id" => filter_id},
+        |(attribute, value1, value2, name, upd_ts)| {
+            FilterConfig {
+                attribute,
+                value1,
+                value2,
+                name,
+                upd_ts,
+            }
+        },
+    )
+}

src/service/filter_service.rs

@@ -1,8 +1,10 @@
 use mysql::PooledConn;
+use crate::{
+    entity::{filter::Filter, filter_config::FilterConfig},
+    repository::filter_repo,
+};
 
-use crate::repository::filter_repo;
+pub fn get_filter(filter_id: &usize, all: bool, conn: &mut PooledConn) {
-
-pub fn get_filter(filter_id: &usize, conn: &mut PooledConn) {
     let result = filter_repo::find_by_id(filter_id, conn);
 
     match result {
@@ -10,15 +12,48 @@ pub fn get_filter(filter_id: &usize, conn: &mut PooledConn) {
             if filters.is_empty() {
                 println!("Filter not found!");
             } else {
-                filters.into_iter().for_each(|filter| {
+                filters.into_iter().for_each(|filter: Filter| {
-                    println!("{}", "-".repeat(100));
+                    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);
                 });
-                println!("{}", "-".repeat(100));
+
+                if all {
+                    get_filter_configs(*filter_id, conn)
+                } else {
+                    println!("{}", "-".repeat(150));
+                }
+            }
+        }
+        Err(err) => panic!("{}", err),
+    };
+}
+
+pub fn get_filter_configs(filter_id: usize, conn: &mut PooledConn) {
+    let result = filter_repo::find_filter_configs(filter_id, conn);
+
+    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.as_sql(true),
+                            filter_config.name
+                        );
+                    });
+                println!("{}", "-".repeat(150));
             }
         }
         Err(err) => panic!("{}", err),