chore: add policy and rol + checkinfo out formats

src/defs.rs

@@ -1,4 +1,5 @@
-use std::collections::{BTreeMap};
+use serde::{Serialize, Deserialize};
+use std::collections::{HashMap, BTreeMap};
 use app_env::{appenv::AppEnv, AppStore};
 use app_auth::{AuthStore};
 use kloud::{defs::KloudStore, datacontext::DataContext};
@@ -11,6 +12,8 @@ use connectors::defs::{AppDataConn};
 use clds::clouds::defs::{
 	CloudEnv,
 	Cloud,
+  SrvcsHostInfOut,
+	InfoStatus,
 };
 use kloud::kloud::Kloud;
 
@@ -73,4 +76,13 @@ pub async fn load_key() -> String {
   }
   key
 }
+pub type MapCheckInfo =	BTreeMap<String,Vec<SrvcsHostInfOut>>;
+
+#[derive(Clone, Debug, Serialize,  Deserialize, Default)]
+pub struct KldCheck {
+	pub name: String,
+	pub cloud: HashMap<String, MapCheckInfo>,
+	pub apps: HashMap<String, MapCheckInfo>,
+	pub infos: Vec<InfoStatus>,
+}
 

src/handlers/h_home.rs

@@ -13,109 +13,152 @@ use app_auth::{UserCtx};
 // 		KloudQueryConfigFilters,
 // 	},
 // };
-use clds::defs::{KloudCheckHome};
+use clds::defs::{KloudCheckHome,CloudCheckItem};
-use clds::clouds::defs::{Cloud,SrvcsHostInfo,App,AppsrvcInfo,TskSrvc,TsksrvcInfo};
+use clds::status::{get_statusinfo_fileslist,load_statusinfo};
-use crate::defs::{DataDBs}; // ,CollsData};
+use clds::clouds::defs::{Cloud,SrvcsHostInfOut,AppOut,AppsrvcInfo,AppsrvcInfOut, TskSrvcOut, TsksrvcInfo, TsksrvcInfOut};
+use crate::defs::{KldCheck, MapCheckInfo, DataDBs}; // ,CollsData};
 use clds::clouds::on_clouds::{get_cloud_check,get_apps_check};
+use app_env::appenv::{Rol,Policy};
 
-pub async fn get_tsks_apps_check(reqenv: &ReqEnv, cld_indx: usize, _auth: UserCtx, role: &str) -> String {
+pub fn tsks_info_on_role(role: String, tsksrvcs: Vec<TsksrvcInfo>) -> Vec<TsksrvcInfOut> {
+	tsksrvcs.into_iter().map(|tsk| {
+		let srvc = match role.as_str() {
+			"admin" => 
+				TskSrvcOut {
+					name: tsk.srvc.name.to_owned(),
+					path: tsk.srvc.path.to_owned(),
+					req: tsk.srvc.req.to_owned(),
+					target: tsk.srvc.target.to_owned(),
+					liveness: tsk.srvc.liveness.to_owned(),
+					critical: tsk.srvc.critical.to_owned(),
+				},
+			_ => 
+				TskSrvcOut {
+					name: tsk.srvc.name.to_owned(),
+					path: String::from(""),
+					req: String::from(""),
+					target: tsk.srvc.target.to_owned(),
+					liveness: String::from(""),
+					critical: tsk.srvc.critical.to_owned(),
+				},
+		};
+		TsksrvcInfOut {
+			name: tsk.name.to_owned(),
+			info: tsk.info.to_owned(),
+			srvc
+		}
+	}).collect()
+}
+pub fn app_info_on_role(role: String, appsrvcs: Vec<AppsrvcInfo>) -> Vec<AppsrvcInfOut> {
+	appsrvcs.into_iter().map(|app| {
+		let srvc = match role.as_str() {
+      "admin" => 
+				AppOut {
+					name: app.srvc.name.to_owned(),
+					path: app.srvc.path.to_owned(),
+					req: app.srvc.req.to_owned(),
+					target: app.srvc.target.to_owned(),
+					liveness: app.srvc.liveness.to_owned(),
+					critical: app.srvc.critical.to_owned(),
+				},
+			_ => 
+				AppOut {
+					name: app.srvc.name.to_owned(),
+					path: String::from(""),
+					req: String::from(""),
+					target: app.srvc.target.to_owned(),
+					liveness: String::from(""),
+					critical: app.srvc.critical.to_owned(),
+				},
+		};
+		AppsrvcInfOut {
+			name: app.name.to_owned(),
+			info: app.info.to_owned(),
+			srvc
+		}
+	}).collect()
+}
+pub fn collect_clouds_check_items(role: &str, items: &Vec<CloudCheckItem> ) -> BTreeMap<String,Vec<SrvcsHostInfOut>> {
+	let mut m_items = BTreeMap::new();
+	items.iter().for_each(|itm| {
+		let liveness: Vec<SrvcsHostInfOut>;
+		liveness = itm.liveness.to_owned().into_iter().map(|it| { 
+			SrvcsHostInfOut {
+				hostname: format!("{}",&it.hostname),
+				tsksrvcs:  tsks_info_on_role(role.to_owned(), it.tsksrvcs),
+				appsrvcs: app_info_on_role(role.to_owned(), it.appsrvcs),
+			}
+		}).collect();
+		m_items.insert(format!("{}",&itm.name),liveness);
+	});
+	m_items
+}
+pub async fn get_tsks_apps_check(reqenv: &ReqEnv,_auth: UserCtx, role: &str) -> String {
 	let result_apps = get_apps_check(&reqenv).await;
 	// println!("Result apps: {}",&result_apps);
   let res_apps: Vec<KloudCheckHome> = serde_json::from_str(&result_apps).unwrap_or_else(|e| {
 		println!("Error serde apps json: {}",e);
 	 	Vec::new()
 	});
-	// let mut list_groups = String::from("");
-  let mut grp_apps_hash: HashMap<String, BTreeMap<String,Vec<SrvcsHostInfo>>> = HashMap::new();
-	if let Some(kld) = res_apps.get(cld_indx) {
-		for grp in &kld.groups {
-			// if !list_groups.is_empty() {
-      //   list_groups.push(',');
-      // }
-      // list_groups.push_str(&grp.name);
-			let mut m_items = BTreeMap::new();
-      for itm in &grp.items {
-				let liveness: Vec<SrvcsHostInfo>;
-				if role.is_empty() {
-					liveness = itm.liveness.to_owned().into_iter().map(|it| { 
-					  SrvcsHostInfo {
-							hostname: format!("{}",&it.hostname),
-							tsksrvcs: it.tsksrvcs.to_owned(),
-							appsrvcs: it.appsrvcs.into_iter().map(|ap| {
-								AppsrvcInfo {
-									name: ap.name.to_owned(),
-									info: ap.info.to_owned(),
-									srvc: App {
-									  name: ap.srvc.name.to_owned(),
-										path: String::from(""),
-										req: String::from(""),
-										target: ap.srvc.target.to_owned(),
-										liveness: String::from(""),
-										critical: ap.srvc.critical.to_owned(),
-									}
-								}
-							}).collect()
-						}
-					}).collect();
-				} else {
-					liveness = itm.liveness.to_owned();
-				}
-        m_items.insert(format!("{}",&itm.name),liveness);
-			}
-      grp_apps_hash.insert(format!("{}",grp.name),m_items);
-		}
-  }
 	let result_cloud = get_cloud_check(&reqenv).await;
 	// println!("Result cloud: {}",&result_cloud);
   let res_cloud: Vec<KloudCheckHome> = serde_json::from_str(&result_cloud).unwrap_or_else(|e| {
 		println!("Error serde apps json: {}",e);
 	 	Vec::new()
 	});
-	let mut grp_cloud_hash: HashMap<String, BTreeMap<String,Vec<SrvcsHostInfo>>> = HashMap::new();
+	let mut kld_check: Vec<KldCheck> = Vec::new();
-	if let Some(kld) = res_cloud.get(cld_indx) {
+	res_apps.iter().for_each(|kld| {
-		for grp in &kld.groups {
+	  // let mut list_groups = String::from("");
-			let mut m_items = BTreeMap::new();
+    let mut grp_check_hash: HashMap<String, MapCheckInfo> = HashMap::new();
-      for itm in &grp.items {
+	  kld.groups.iter().for_each(|grp| {
-				let liveness: Vec<SrvcsHostInfo>;
+			// if !list_groups.is_empty() {
-				if role.is_empty() {
+      //   list_groups.push(',');
-					liveness = itm.liveness.to_owned().into_iter().map(|it| { 
+      // }
-					  SrvcsHostInfo {
+      // list_groups.push_str(&grp.name);
-							hostname: format!("{}",&it.hostname),
+      grp_check_hash.insert(format!("{}",grp.name),collect_clouds_check_items(&role,&grp.items));
-							appsrvcs: it.appsrvcs.to_owned(),
+		});
-							tsksrvcs: it.tsksrvcs.into_iter().map(|tsk| {
+		kld_check.push(KldCheck {
-								TsksrvcInfo {
+			name: kld.name.to_owned(),
-									name: tsk.name.to_owned(),
+			cloud: HashMap::new(),
-									info: tsk.info.to_owned(),
+			apps: grp_check_hash,
-									srvc: TskSrvc {
+			infos: Vec::new(),
-									  name: tsk.srvc.name.to_owned(),
+		});
-										path: String::from(""),
+  });
-										req: String::from(""),
+	for kld in res_cloud {
-										target: tsk.srvc.target.to_owned(),
+    let mut grp_check_hash: HashMap<String, MapCheckInfo> = HashMap::new();
-										liveness: String::from(""),
+		kld.groups.iter().for_each(|grp| {
-										critical: tsk.srvc.critical.to_owned(),
+      grp_check_hash.insert(format!("{}",grp.name),collect_clouds_check_items(&role,&grp.items));
-									}
+		});
-								}
+		let kld_statusinfo_files: Vec<String> = get_statusinfo_fileslist(&reqenv.config().state_path,&kld.name).await.unwrap_or_else(|e|{
-							}).collect()
+			println!("Error on infos {}: {}",&kld.name,e);
-						}
+			Vec::new()
-					}).collect();
+		});
-				} else {
+		// dbg!(&kld_statusinfo_files);
-					liveness = itm.liveness.to_owned();
+	  let infos = load_statusinfo(&format!("{}/{}",&reqenv.config().state_path,&kld.name), kld_statusinfo_files).await;
+		//dbg!(&infos);
+		if kld_check.len() == 0 {
+			kld_check.push(KldCheck {
+				name: kld.name.to_owned(),
+				apps: HashMap::new(),
+				cloud: grp_check_hash,
+				infos, 
+			});
+		} else {
+			let mut kldix = 0;
+			kld_check.iter().enumerate().for_each(|(idx,k)| {
+				if k.name == kld.name {
+			     kldix = idx;
 				}
-        m_items.insert(format!("{}",&itm.name),liveness.to_owned());
+			});
-			}
+			kld_check[kldix].cloud = grp_check_hash.to_owned();
-      grp_cloud_hash.insert(format!("{}",grp.name),m_items);
+			kld_check[kldix].infos = infos.to_owned();
 		}
-  }
+  };
- 	// ctx.insert("groups_cloud".to_string(),&grp_cloud_hash);
+	// let result = format!("{}:{}{}:{}{}",r#"{"group_apps""#,&res_apps_json,r#","group_cloud""#,&res_cloud_json,r#"}"#);
-	let res_apps_json=serde_json::to_string(&grp_apps_hash).unwrap_or_else(|e|{
+	let result=serde_json::to_string(&kld_check).unwrap_or_else(|e|{
 		println!("Error serde from value: {}",e);
 		String::from("")
 	});
-	let res_cloud_json=serde_json::to_string(&grp_cloud_hash).unwrap_or_else(|e|{
-		println!("Error serde from value: {}",e);
-		String::from("")
-	});
-	let result = format!("{}:{}{}:{}{}",r#"{"group_apps""#,&res_apps_json,r#","group_cloud""#,&res_cloud_json,r#"}"#);
   result.to_owned()
 }
 pub async fn home(
@@ -145,7 +188,7 @@ pub async fn home(
 			//  dbg!("LANG: {} - {}",language, lang);
       let role = reqenv.req.user_role().await;
 			// reqenv.is_admin()
-			let result = get_tsks_apps_check(&reqenv,1,auth,&role).await;
+			let result = get_tsks_apps_check(&reqenv,auth,&role).await;
 			// let mut path = format!("{}/profiles/{}/{}/defs.yaml",reqenv.websrvr().resources_path,&prfx,&auth.user_id);
 			// if ! std::path::Path::new(&path).exists() {
 			// 	path = format!("{}/profiles/{}/defs.yaml",reqenv.websrvr().resources_path,&prfx);
@@ -164,32 +207,14 @@ pub async fn home(
 			Ok(warp::http::Response::builder()
 			.body(result.to_string())
 			.into_response())
-			/*
-			Ok(warp::reply::with_header(
-					warp::http::Response::new(result),
-						"Access-Control-Allow-Origin",
-						&allow_origin))
-			*/
-			//  warp::reply::json(&res),
-			// Ok(warp::reply::with_header(
-			//  warp::http::Response::new(result),
-			//    "Access-Control-Allow-Origin",
-			//    &allow_origin))
-			// Ok(warp::reply::json(&result))
 		},
 		Err(_e) => {
 			// let result = format!("Error: no credentials found");
 			// println!("{}",e);
-			let result = get_tsks_apps_check(&reqenv,1,UserCtx::default(),"").await;
+			let result = get_tsks_apps_check(&reqenv,UserCtx::default(),"").await;
 			Ok(warp::http::Response::builder()
 			.body(result.to_string())
 			.into_response())
-			/*
-			Ok(warp::reply::with_header(
-			warp::http::Response::new(result),
-			"Access-Control-Allow-Origin",
-			&allow_origin))
-			*/
 		}
 	}
 }