mathias
/
rcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

error handling improved, start with env

main
Mathias Rothenhaeusler 2025-03-17 15:18:03 +01:00
parent 441ce5c630
commit 42aa8228b8
9 changed files with 189 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/cli/command.rs
View File

@ -35,11 +35,15 @@ pub enum Commands {
}, },
Page { Page {
// #[arg(short, long)] // #[arg(short, long)]
page_id: usize page_id: usize,
}, },
Job { Job {
job_id: usize, job_id: usize,
#[arg(short, long)] #[arg(short, long)]
log: bool, log: bool,
} },
Env {
env: Option<String>,
target: Option<String>,
},
} }

25
src/cli/controller.rs
View File

@ -2,8 +2,8 @@ use crate::{
container, container,
database::db::Db, database::db::Db,
service::{ service::{
file_service::FileService, filter_service::FilterService, job_service::JobService, env_service::EnvService, file_service::FileService, filter_service::FilterService,
merchant_service::MerchantService, schema_service::SchemaService, job_service::JobService, merchant_service::MerchantService, schema_service::SchemaService,
}, },
}; };
@ -21,11 +21,11 @@ pub fn process_args(args: Cli, db: Db) -> Result<(), Box<dyn std::error::Error>>
match args.mode { match args.mode {
Commands::Merch { search } => { Commands::Merch { search } => {
let mut merchant_service: MerchantService = container::get_merchant_service(db); let mut merchant_service: MerchantService = container::get_merchant_service(db);
merchant_service.get_merchant(&search.ok_or(CommandError::EmptySearch())?); merchant_service.get_merchant(&search.ok_or(CommandError::EmptySearch())?)?;
} }
Commands::Schema { search } => { Commands::Schema { search } => {
let mut schema_service: SchemaService = container::get_schema_service(db); let mut schema_service: SchemaService = container::get_schema_service(db);
schema_service.get_columns(&search.ok_or(CommandError::EmptySearch())?) schema_service.get_columns(&search.ok_or(CommandError::EmptySearch())?)?;
} }
Commands::Filter { Commands::Filter {
filter_id, filter_id,
@ -35,25 +35,30 @@ pub fn process_args(args: Cli, db: Db) -> Result<(), Box<dyn std::error::Error>>
} => { } => {
let mut filter_service: FilterService = container::get_filter_service(db); let mut filter_service: FilterService = container::get_filter_service(db);
if config { if config {
filter_service.get_filter_configs(&filter_id) filter_service.get_filter_configs(&filter_id)?;
} else if log { } else if log {
filter_service.get_filter_log(&filter_id, all) filter_service.get_filter_log(&filter_id, all)?;
} else { } else {
filter_service.get_filter(&filter_id, all) filter_service.get_filter(&filter_id, all)?;
} }
} }
Commands::Page { page_id } => { Commands::Page { page_id } => {
let mut file_service: FileService = container::get_page_service(db); let mut file_service: FileService = container::get_page_service(db);
file_service.get_page(&page_id); file_service.get_page(&page_id)?;
} }
Commands::Job { job_id, log } => { Commands::Job { job_id, log } => {
let mut job_service: JobService = container::get_job_service(db); let mut job_service: JobService = container::get_job_service(db);
if log { if log {
job_service.get_job_log(&job_id); job_service.get_job_log(&job_id)?;
} else { } else {
job_service.get_job_by_id(&job_id); job_service.get_job_by_id(&job_id)?;
} }
} }
Commands::Env { env, target } => {
EnvService::set_environment()?;
println!("{:?}, {:?}", env, target);
}
} }
Ok(()) Ok(())

10
src/container.rs
View File

@ -12,25 +12,25 @@ use crate::{
pub fn get_filter_service(pool: Db) -> FilterService { pub fn get_filter_service(pool: Db) -> FilterService {
let repo = FilterRepo::new(pool); let repo = FilterRepo::new(pool);
return FilterService::new(repo); FilterService::new(repo)
} }
pub fn get_merchant_service(pool: Db) -> MerchantService { pub fn get_merchant_service(pool: Db) -> MerchantService {
let repo = MerchantRepo::new(pool); let repo = MerchantRepo::new(pool);
return MerchantService::new(repo); MerchantService::new(repo)
} }
pub fn get_schema_service(pool: Db) -> SchemaService { pub fn get_schema_service(pool: Db) -> SchemaService {
let repo = SchemaRepo::new(pool); let repo = SchemaRepo::new(pool);
return SchemaService::new(repo); SchemaService::new(repo)
} }
pub fn get_page_service(pool: Db) -> FileService { pub fn get_page_service(pool: Db) -> FileService {
let repo = FileRepo::new(pool); let repo = FileRepo::new(pool);
return FileService::new(repo); FileService::new(repo)
} }
pub(crate) fn get_job_service(pool: Db) -> JobService { pub(crate) fn get_job_service(pool: Db) -> JobService {
let repo = JobRepo::new(pool); let repo = JobRepo::new(pool);
return JobService::new(repo); JobService::new(repo)
} }

30
src/service/file_service.rs
View File

@ -13,24 +13,20 @@ impl FileService {
Self { repo } Self { repo }
} }
pub fn get_page(&mut self, page_id: &usize) { pub fn get_page(&mut self, page_id: &usize) -> Result<(), Box<dyn std::error::Error>> {
let result = self.repo.find_page(page_id); let page = self.repo.find_page(page_id)?;
match result { if page.is_empty() {
Ok(page) => { println!("No page found.");
if page.is_empty() { } else {
println!("No page found."); page.into_iter().for_each(|page: Page| {
} else { println!("{}", "-".repeat(self.get_width()));
page.into_iter().for_each(|page: Page| { println!("M-ID: {}", page.m_id);
println!("{}", "-".repeat(self.get_width())); println!("FileName: {}", page.file);
println!("M-ID: {}", page.m_id); println!("Title: {}", page.title);
println!("FileName: {}", page.file); });
println!("Title: {}", page.title); println!("{}", "-".repeat(self.get_width()));
});
println!("{}", "-".repeat(self.get_width()));
}
}
Err(err) => panic!("{}", err),
} }
Ok(())
} }
} }

188
src/service/filter_service.rs
View File

@ -17,104 +17,106 @@ impl FilterService {
Self { repo } Self { repo }
} }
pub fn get_filter(&mut self, filter_id: &usize, all: bool) { pub fn get_filter(
let result = self.repo.find_by_id(filter_id); &mut self,
filter_id: &usize,
all: bool,
) -> Result<(), Box<dyn std::error::Error>> {
let filters = self.repo.find_by_id(filter_id)?;
match result { if filters.is_empty() {
Ok(filters) => { println!("Filter not found!");
if filters.is_empty() { } else {
println!("Filter not found!"); filters.into_iter().for_each(|filter: Filter| {
} else { println!("{}", "-".repeat(self.get_width()));
filters.into_iter().for_each(|filter: Filter| { println!("Module ID: {}", filter.filter_module_id);
println!("{}", "-".repeat(self.get_width())); println!("FileName: {}", filter.file_name);
println!("Module ID: {}", filter.filter_module_id); println!("Description: {}", filter.description);
println!("FileName: {}", filter.file_name); println!("ModuleNo: {}", filter.filter_module_no);
println!("Description: {}", filter.description); println!("FilterUser: {}", filter.filter_user);
println!("ModuleNo: {}", filter.filter_module_no); });
println!("FilterUser: {}", filter.filter_user);
});
if all { if all {
self.get_filter_configs(filter_id) self.get_filter_configs(filter_id)?
} else { } else {
println!("{}", "-".repeat(self.get_width())); println!("{}", "-".repeat(self.get_width()));
}
};
Ok(())
}
pub fn get_filter_configs(
&mut self,
filter_id: &usize,
) -> Result<(), Box<dyn std::error::Error>> {
let filter_configs = self.repo.find_filter_configs(filter_id)?;
if filter_configs.is_empty() {
println!("No filter configs found!");
} else {
println!("{}", "-".repeat(self.get_width()));
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(self.get_width()));
};
Ok(())
}
pub fn get_filter_log(
&mut self,
filter_id: &usize,
all: bool,
) -> Result<(), Box<dyn std::error::Error>> {
let filter_log = self.repo.find_filter_log(filter_id)?;
if filter_log.is_empty() {
println!("No filter log found!");
} else {
println!("{}", "-".repeat(self.get_width()));
filter_log.into_iter().for_each(|filter_log: FilterLog| {
println!(
"TS: {} Error Code: {}",
filter_log.run_ts, filter_log.error_code
);
match filter_log.error_code.as_str() {
"WARNING" => {
println!("{}", filter_log.error_msg.yellow());
if all {
println!("{}", filter_log.mysql_error.yellow());
}
}
"ERROR" => {
println!("{}", filter_log.error_msg.red());
if all {
println!("{}", filter_log.mysql_error.red());
}
}
"DEBUG" => {
println!("{}", filter_log.error_msg.green());
if all {
println!("{}", filter_log.error_msg.green())
}
}
_ => {
println!("{}", filter_log.error_msg);
} }
} }
}
Err(err) => panic!("{}", err),
};
}
pub fn get_filter_configs(&mut self, filter_id: &usize) { println!("{}", "-".repeat(self.get_width()));
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(self.get_width()));
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(self.get_width()));
}
}
Err(err) => panic!("{}", err),
};
}
pub fn get_filter_log(&mut self, filter_id: &usize, all: bool) {
let result = self.repo.find_filter_log(filter_id);
match result {
Ok(filter_log) => {
if filter_log.is_empty() {
println!("No filter log found!");
} else {
println!("{}", "-".repeat(self.get_width()));
filter_log.into_iter().for_each(|filter_log: FilterLog| {
println!(
"TS: {} Error Code: {}",
filter_log.run_ts, filter_log.error_code
);
match filter_log.error_code.as_str() {
"WARNING" => {
println!("{}", filter_log.error_msg.yellow());
if all {
println!("{}", filter_log.mysql_error.yellow());
}
}
"ERROR" => {
println!("{}", filter_log.error_msg.red());
if all {
println!("{}", filter_log.mysql_error.red());
}
}
"DEBUG" => {
println!("{}", filter_log.error_msg.green());
if all {
println!("{}", filter_log.error_msg.green())
}
}
_ => {
println!("{}", filter_log.error_msg);
}
}
println!("{}", "-".repeat(self.get_width()));
})
}
}
Err(err) => panic!("{}", err),
} }
Ok(())
} }
} }

54
src/service/job_service.rs
View File

@ -16,43 +16,37 @@ impl JobService {
Self { repo } Self { repo }
} }
pub fn get_job_by_id(&mut self, job_id: &usize) { pub fn get_job_by_id(&mut self, job_id: &usize) -> Result<(), Box<dyn std::error::Error>> {
let result = self.repo.find_by_id(job_id); let result = self.repo.find_by_id(job_id)?;
match result { if result.is_empty() {
Ok(job) => { println!("Job not found!");
if job.is_empty() { } else {
println!("Job not found!"); result.into_iter().for_each(|job: Job| {
} else { println!("{}", "-".repeat(self.get_width()));
job.into_iter().for_each(|job: Job| { println!("FileName: {}", job.file_name);
println!("{}", "-".repeat(self.get_width())); println!("Description: {}", job.description);
println!("FileName: {}", job.file_name); });
println!("Description: {}", job.description);
});
println!("{}", "-".repeat(self.get_width())); println!("{}", "-".repeat(self.get_width()));
}
}
Err(err) => panic!("{}", err),
} }
Ok(())
} }
pub fn get_job_log(&mut self, job_id: &usize) { pub fn get_job_log(&mut self, job_id: &usize) -> Result<(), Box<dyn std::error::Error>> {
let result = self.repo.find_log(job_id); let result = self.repo.find_log(job_id)?;
match result { if result.is_empty() {
Ok(joblog) => { println!("Job log not found!");
if joblog.is_empty() { } else {
println!("Job log not found!"); result.into_iter().for_each(|joblog: JobLog| {
} else { println!("{0: <25} | {1: <20} ", joblog.upd_ts, joblog.content,);
joblog.into_iter().for_each(|joblog: JobLog| { });
println!("{0: <25} | {1: <20} ", joblog.upd_ts, joblog.content,);
});
println!("{}", "-".repeat(self.get_width())); println!("{}", "-".repeat(self.get_width()));
}
}
Err(err) => panic!("{}", err),
} }
Ok(())
} }
} }

29
src/service/merchant_service.rs
View File

@ -13,23 +13,20 @@ impl MerchantService {
Self { repo } Self { repo }
} }
pub fn get_merchant(&mut self, search: &str) { pub fn get_merchant(&mut self, search: &str) -> Result<(), Box<dyn std::error::Error>> {
let merchants = self.repo.find_by_name_or_id(search); let merchants = self.repo.find_by_name_or_id(search)?;
match merchants { if merchants.is_empty() {
Ok(merchants) => { println!("Merchant not found!");
if merchants.is_empty() { }
println!("Merchant not found!"); merchants.into_iter().for_each(|merchant| {
} println!("{}", "-".repeat(self.get_width()));
merchants.into_iter().for_each(|merchant| { println!("Merchant: {}", merchant.m_name);
println!("{}", "-".repeat(self.get_width())); println!("M-ID: {}", merchant.m_id);
println!("Merchant: {}", merchant.m_name); });
println!("M-ID: {}", merchant.m_id);
});
println!("{}", "-".repeat(self.get_width())); println!("{}", "-".repeat(self.get_width()));
}
Err(err) => panic!("{}", err), Ok(())
};
} }
} }

7
src/service/mod.rs
View File

@ -1,5 +1,6 @@
pub mod env_service;
pub mod file_service;
pub mod filter_service;
pub mod job_service;
pub mod merchant_service; pub mod merchant_service;
pub mod schema_service; pub mod schema_service;
pub mod filter_service;
pub mod file_service;
pub mod job_service;

31
src/service/schema_service.rs
View File

@ -12,24 +12,21 @@ impl SchemaService {
pub fn new(repo: SchemaRepo) -> Self { pub fn new(repo: SchemaRepo) -> Self {
Self { repo } Self { repo }
} }
pub fn get_columns(&mut self, column: &str) { pub fn get_columns(&mut self, column: &str) -> Result<(), Box<dyn std::error::Error>> {
let columns = self.repo.find_by_column(column); let columns = self.repo.find_by_column(column)?;
match columns { if columns.is_empty() {
Ok(columns) => { println!("No column found!");
if columns.is_empty() { } else {
println!("No column found!"); columns.into_iter().for_each(|column| {
} else { println!("{}", "-".repeat(self.get_width()));
columns.into_iter().for_each(|column| { println!("Table name: {}", column.table_name);
println!("{}", "-".repeat(self.get_width())); println!("Column name: {}", column.column_name);
println!("Table name: {}", column.table_name); println!("Type: {}", column.column_type);
println!("Column name: {}", column.column_name); });
println!("Type: {}", column.column_type); println!("{}", "-".repeat(self.get_width()));
});
println!("{}", "-".repeat(self.get_width()));
}
}
Err(err) => panic!("{err}"),
} }
Ok(())
} }
} }