loading modules and renders now uses serde to deserialise toml

src/server.rs

@@ -127,12 +127,42 @@ pub enum ModuleKind {
     Extern(),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Deserialize, Serialize)]
-pub struct Render {
+pub enum Render {
+    WebComponent{
         id: String, 
         webroot: String,
         main: String,
         folder: String,
+    },
+    RenderView{
+        id: String,
+        main: String,
+        folder: String,
+    },
+}
+
+impl Render {
+    fn get_id(&self) -> String {
+        match self {
+            Render::WebComponent{id, webroot, main, folder} => id.to_owned(),
+            Render::RenderView{id, main, folder} => id.to_owned(),
+        }
+    }
+
+    fn get_folder(&self) -> String {
+        match self {
+            Render::WebComponent{id, webroot, main, folder} => folder.to_owned(),
+            Render::RenderView{id, main, folder} => folder.to_owned(),
+        }
+    }
+
+    fn get_main(&self) -> String {
+        match self {
+            Render::WebComponent{id, webroot, main, folder} => main.to_owned(),
+            Render::RenderView{id, main, folder} => main.to_owned(),
+        }
+    }
 }
 
 trait SendMize<T> where T: Into<MizeMessage> {
@@ -198,53 +228,45 @@ pub async fn run_server(args: Vec<String>) {
     let itemstore = crate::server::itemstore::Itemstore::new(mize_folder.clone() + "/db").await.expect("error creating itemstore");
 
     //load modules and renders
-    let ren_mods = std::fs::read_dir(mize_folder.clone() + "/mr")
+    let mr_folders = std::fs::read_dir(mize_folder.clone() + "/mr")
         .expect("error reading the modules-renders dir in the mize-folder")
         .filter(|entry| entry.as_ref().unwrap().file_type().unwrap().is_dir());
     
+    let mut renders_toml: Vec<toml::Value> = Vec::new();
+
+    for mr_folder in mr_folders {
+
+        let mr_folder = match mr_folder {
+            Err(_) => {MizeError::new(11).extra_msg("Error unwrapping DirEntry").handle(); continue;},
+            Ok(idk) => idk,
+        };
+
+        let mr_string = match fs::read_to_string(format!("{}/mize.toml", mr_folder.path().display())) {
+            Err(_) => {MizeError::new(11).extra_msg("Error parsing mize.toml file to a toml string").handle(); continue;},
+            Ok(idk) => idk,
+        };
+
+        let mr_data = match mr_string.parse::<toml::Value>() {
+            Err(_) => {MizeError::new(11).extra_msg("Error parsing mize.toml string to toml::Value").handle(); continue;},
+            Ok(idk) => idk,
+        };
+
+        if let Some(local_renders) = mr_data.get("render") {
+            if let toml::Value::Array(arr) = local_renders {
+                renders_toml.extend(arr.clone());
+            }
+        }
+    }
+
     let mut renders: Vec<Render> = Vec::new();
 
-    for ren_mod in ren_mods {
+    for render_toml in renders_toml {
-        let ren_mod = ren_mod.unwrap();
+        let render = match Render::deserialize(render_toml) {
-        if let Ok(toml_string) = fs::read_to_string(format!("{}/mize.toml", ren_mod.path().display())){
+            Ok(render) => render,
-            let data = toml_string.parse::<toml::Value>()
+            Err(err) => {MizeError::new(11).handle(); continue;}
-                .expect(&format!("error while parsing the mize.toml file in {}", ren_mod.path().display()));
-
-            //set renders
-            let render_arr = match data.get("render").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) {
-                toml::Value::Array(arr) => arr,
-                _ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())}
         };
-
+        renders.push(render);
-            for render in render_arr {
-                let id = match render.get("id").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) {
-                    toml::Value::String(val) => val,
-                    _ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())}
-                };
-
-                let webroot = match render.get("webroot").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) {
-                    toml::Value::String(val) => val,
-                    _ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())}
-                };
-
-                let main = match render.get("main").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) {
-                    toml::Value::String(val) => val,
-                    _ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())}
-                };
-
-                let webroot = webroot.clone();
-                let main = main.clone();
-                let id = id.clone();
-                let folder = format!("{}", ren_mod.file_name().into_string().expect("filename has non utf8 chars in it......"));
-
-                renders.push(Render {id, webroot, main, folder});
-            };
-
-            //set modules
-            //later...
     }
-    }
-
 
     // Collection of all the things, that most functions need
     let mutexes: Mutexes = Mutexes {
@@ -283,23 +305,25 @@ async fn axum_server(mize_folder: String, mutexes: Mutexes) {
     let serve_client = get_service(ServeDir::new("js-client/src")).handle_error(handle_error);
 
     let mut app = Router::new()
-        .route("/==api==/socket", get(websocket_handler))
+        .route("/api/socket", get(websocket_handler))
-        .route("/==api==/render/:id", get(get_render_main))
+        .route("/api/render/:id", get(get_render_main))
 //        .route("/$api/file", get(get_file_handler))
 //        .merge(SpaRouter::new("/$api/client", "js-client/src").index_file("main.html"))
-        .nest_service("/==api==/client", serve_client)
+        .nest_service("/api/client", serve_client)
         .with_state(mutexes.clone())
         .fallback(render_item);
 
     let renders = mutexes.renders.lock().await;
 
     for render in &*renders {
-        let url_path = String::from("/==api==/render/") + &render.id + "/webroot";
+        if let Render::WebComponent { id, webroot, main, folder } = render {
-        let file_path = mutexes.mize_folder.clone() + "/modules-renders/" + &render.folder[..] + "/" + &render.webroot.clone()[..];
+            let url_path = String::from("/api/render/") + &id + "/webroot";
+            let file_path = mutexes.mize_folder.clone() + "/modules-renders/" + &folder[..] + "/" + &webroot.clone()[..];
             let serve_dir = get_service(ServeDir::new(&file_path)).handle_error(handle_error);
 
             app = app.nest_service(&url_path, serve_dir);
         }
+    }
     drop(renders);
 
     let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
@@ -323,11 +347,10 @@ async fn render_item(uri: Uri) -> impl IntoResponse {
 async fn get_render_main(extract::Path(id): extract::Path<String>, State(mutexes): State<Mutexes>) -> http::Response<String> {
     let renders = &*mutexes.renders.lock().await;
 
-    let render = renders.iter().filter(|&render| render.id == id).nth(0)
+    let render = renders.iter().filter(|&render| render.get_id() == id).nth(0)
-        .unwrap_or(renders.iter().filter(|&render| render.id == "first").nth(0).expect("there is no first render"));
+        .unwrap_or(renders.iter().filter(|&render| render.get_id() == "mize-mmejs").nth(0).expect("mize-mmejs"));
 
-    let file_name = mutexes.mize_folder.clone() + "/mr/" + &render.folder + "/" + &render.main;
+    let file_name = mutexes.mize_folder.clone() + "/mr/" + &render.get_folder() + "/" + &render.get_main();
-    println!("filenamd: {}", file_name);
 
     Response::builder()
         .header("content-type", "application/javascript")