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 {
// #[arg(short, long)]
page_id: usize
page_id: usize,
},
Job {
job_id: usize,
#[arg(short, long)]
log: bool,
}
},
Env {
env: Option<String>,
target: Option<String>,
},
}

25
src/cli/controller.rs
View File

@ -2,8 +2,8 @@ use crate::{
container,
database::db::Db,
service::{
file_service::FileService, filter_service::FilterService, job_service::JobService,
merchant_service::MerchantService, schema_service::SchemaService,
env_service::EnvService, file_service::FileService, filter_service::FilterService,
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 {
Commands::Merch { search } => {
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 } => {
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 {
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);
if config {
filter_service.get_filter_configs(&filter_id)
filter_service.get_filter_configs(&filter_id)?;
} else if log {
filter_service.get_filter_log(&filter_id, all)
filter_service.get_filter_log(&filter_id, all)?;
} else {
filter_service.get_filter(&filter_id, all)
filter_service.get_filter(&filter_id, all)?;
}
}
Commands::Page { page_id } => {
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 } => {
let mut job_service: JobService = container::get_job_service(db);
if log {
job_service.get_job_log(&job_id);
job_service.get_job_log(&job_id)?;
} 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(())

10
src/container.rs
View File

@ -12,25 +12,25 @@ use crate::{
pub fn get_filter_service(pool: Db) -> FilterService {
let repo = FilterRepo::new(pool);
return FilterService::new(repo);
FilterService::new(repo)
}
pub fn get_merchant_service(pool: Db) -> MerchantService {
let repo = MerchantRepo::new(pool);
return MerchantService::new(repo);
MerchantService::new(repo)
}
pub fn get_schema_service(pool: Db) -> SchemaService {
let repo = SchemaRepo::new(pool);
return SchemaService::new(repo);
SchemaService::new(repo)
}
pub fn get_page_service(pool: Db) -> FileService {
let repo = FileRepo::new(pool);
return FileService::new(repo);
FileService::new(repo)
}
pub(crate) fn get_job_service(pool: Db) -> JobService {
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 }
}
pub fn get_page(&mut self, page_id: &usize) {
let result = self.repo.find_page(page_id);
pub fn get_page(&mut self, page_id: &usize) -> Result<(), Box<dyn std::error::Error>> {
let page = self.repo.find_page(page_id)?;
match result {
Ok(page) => {
if page.is_empty() {
println!("No page found.");
} else {
page.into_iter().for_each(|page: Page| {
println!("{}", "-".repeat(self.get_width()));
println!("M-ID: {}", page.m_id);
println!("FileName: {}", page.file);
println!("Title: {}", page.title);
});
println!("{}", "-".repeat(self.get_width()));
}
}
Err(err) => panic!("{}", err),
if page.is_empty() {
println!("No page found.");
} else {
page.into_iter().for_each(|page: Page| {
println!("{}", "-".repeat(self.get_width()));
println!("M-ID: {}", page.m_id);
println!("FileName: {}", page.file);
println!("Title: {}", page.title);
});
println!("{}", "-".repeat(self.get_width()));
}
Ok(())
}
}

188
src/service/filter_service.rs
View File

@ -17,104 +17,106 @@ impl FilterService {
Self { repo }
}
pub fn get_filter(&mut self, filter_id: &usize, all: bool) {
let result = self.repo.find_by_id(filter_id);
pub fn get_filter(
&mut self,
filter_id: &usize,
all: bool,
) -> Result<(), Box<dyn std::error::Error>> {
let filters = 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(self.get_width()));
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 filters.is_empty() {
println!("Filter not found!");
} else {
filters.into_iter().for_each(|filter: Filter| {
println!("{}", "-".repeat(self.get_width()));
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(self.get_width()));
if all {
self.get_filter_configs(filter_id)?
} else {
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) {
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),
println!("{}", "-".repeat(self.get_width()));
})
}
Ok(())
}
}

54
src/service/job_service.rs
View File

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

29
src/service/merchant_service.rs
View File

@ -13,23 +13,20 @@ impl MerchantService {
Self { repo }
}
pub fn get_merchant(&mut self, search: &str) {
let merchants = self.repo.find_by_name_or_id(search);
pub fn get_merchant(&mut self, search: &str) -> Result<(), Box<dyn std::error::Error>> {
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(self.get_width()));
println!("Merchant: {}", merchant.m_name);
println!("M-ID: {}", merchant.m_id);
});
if merchants.is_empty() {
println!("Merchant not found!");
}
merchants.into_iter().for_each(|merchant| {
println!("{}", "-".repeat(self.get_width()));
println!("Merchant: {}", merchant.m_name);
println!("M-ID: {}", merchant.m_id);
});
println!("{}", "-".repeat(self.get_width()));
}
Err(err) => panic!("{}", err),
};
println!("{}", "-".repeat(self.get_width()));
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 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 {
Self { repo }
}
pub fn get_columns(&mut self, column: &str) {
let columns = self.repo.find_by_column(column);
pub fn get_columns(&mut self, column: &str) -> Result<(), Box<dyn std::error::Error>> {
let columns = self.repo.find_by_column(column)?;
match columns {
Ok(columns) => {
if columns.is_empty() {
println!("No column found!");
} else {
columns.into_iter().for_each(|column| {
println!("{}", "-".repeat(self.get_width()));
println!("Table name: {}", column.table_name);
println!("Column name: {}", column.column_name);
println!("Type: {}", column.column_type);
});
println!("{}", "-".repeat(self.get_width()));
}
}
Err(err) => panic!("{err}"),
if columns.is_empty() {
println!("No column found!");
} else {
columns.into_iter().for_each(|column| {
println!("{}", "-".repeat(self.get_width()));
println!("Table name: {}", column.table_name);
println!("Column name: {}", column.column_name);
println!("Type: {}", column.column_type);
});
println!("{}", "-".repeat(self.get_width()));
}
Ok(())
}
}