changes to how renders and webcomponents are loaded

src/server.rs

@@ -127,42 +127,22 @@ pub enum ModuleKind {
     Extern(),
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Debug)]
-pub enum Render {
+pub struct Render {
-    WebComponent{
+    #[serde(rename="type")]
-        id: String, 
+    render_type: RenderType,
-        webroot: String,
+    webroot: String,
-        main: String,
+    name: String,
-        folder: String,
+    main: String,
-    },
+    folder: String,
-    RenderView{
-        id: String,
-        main: String,
-        folder: String,
-    },
 }
 
-impl Render {
+#[derive(Deserialize, Serialize, Debug)]
-    fn get_id(&self) -> String {
+pub enum RenderType {
-        match self {
+    #[serde(rename="json-ui")]
-            Render::WebComponent{id, webroot, main, folder} => id.to_owned(),
+    JsonUi,
-            Render::RenderView{id, main, folder} => id.to_owned(),
+    #[serde(rename="webcomponent")]
-        }
+    WebComponent,
-    }
-
-    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> {
@@ -227,46 +207,7 @@ pub async fn run_server(args: Vec<String>) {
     //create the itemstore
     let itemstore = crate::server::itemstore::Itemstore::new(mize_folder.clone() + "/db").await.expect("error creating itemstore");
 
-    //load modules and renders
+    let renders = load_mr(mize_folder.clone()).expect("Error loading Modules and Renders");
-    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 render_toml in renders_toml {
-        let render = match Render::deserialize(render_toml) {
-            Ok(render) => render,
-            Err(err) => {MizeError::new(11).handle(); continue;}
-        };
-        renders.push(render);
-    }
 
     // Collection of all the things, that most functions need
     let mutexes: Mutexes = Mutexes {
@@ -316,12 +257,15 @@ async fn axum_server(mize_folder: String, mutexes: Mutexes) {
     let renders = mutexes.renders.lock().await;
 
     for render in &*renders {
-        if let Render::WebComponent { id, webroot, main, folder } = render {
+        match render.render_type {
-            let url_path = String::from("/api/render/") + &id + "/webroot";
+            RenderType::JsonUi => {},
-            let file_path = mutexes.mize_folder.clone() + "/modules-renders/" + &folder[..] + "/" + &webroot.clone()[..];
+            RenderType::WebComponent => {
-            let serve_dir = get_service(ServeDir::new(&file_path)).handle_error(handle_error);
+                let url_path = String::from("/api/render/") + &render.name + "/webroot";
+                let file_path = mutexes.mize_folder.clone() + "/mr/" + &render.folder[..] + "/" + &render.webroot.clone()[..];
+                let serve_dir = get_service(ServeDir::new(&file_path)).handle_error(handle_error);
 
-            app = app.nest_service(&url_path, serve_dir);
+                app = app.nest_service(&url_path, serve_dir);
+            },
         }
     }
     drop(renders);
@@ -347,15 +291,25 @@ 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.get_id() == id).nth(0)
+    let render = renders.iter().filter(|&render| render.name == id).nth(0)
-        .unwrap_or(renders.iter().filter(|&render| render.get_id() == "mize-mmejs").nth(0).expect("mize-mmejs"));
+        .unwrap_or(renders.iter().filter(|&render| render.name == "mize-mmejs").nth(0).expect("mize-mmejs"));
 
-    let file_name = mutexes.mize_folder.clone() + "/mr/" + &render.get_folder() + "/" + &render.get_main();
+    let file_path = mutexes.mize_folder.clone() + "/mr/" + &render.folder + "/" + &render.main;
 
-    Response::builder()
+    match render.render_type {
-        .header("content-type", "application/javascript")
+        RenderType::JsonUi => {
-        .status(StatusCode::OK)
+            return Response::builder()
-        .body(fs::read_to_string(file_name).unwrap()).unwrap()
+                .header("content-type", "application/json")
+                .status(StatusCode::OK)
+                .body(fs::read_to_string(file_path).unwrap()).unwrap();
+        },
+        RenderType::WebComponent => {
+            return Response::builder()
+                .header("content-type", "application/javascript")
+                .status(StatusCode::OK)
+                .body(fs::read_to_string(file_path).unwrap()).unwrap();
+        },
+    }
 }
 
 async fn websocket_handler(
@@ -514,5 +468,75 @@ async fn handle_websocket_connection(
     };
 }
 
+fn load_mr(mize_folder: String) -> Result<Vec<Render>, MizeError> {
+    //load modules and renders
+
+    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: Vec<Render> = 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 mut 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_mut("render") {
+            if let Some(arr) = local_renders.as_array_mut(){
+                //add folder to local_renders
+                for mut el in arr.iter_mut() {
+                    if let Some(table) = el.as_table_mut(){
+                        table.insert("folder".to_owned(), toml::Value::String(mr_folder.file_name().into_string().unwrap()));
+                        table.insert("type".to_owned(), toml::Value::String("json-ui".to_owned()));
+                    }
+
+                    let render = match Render::deserialize(el.clone()) {
+                        Ok(render) => render,
+                        Err(err) => {MizeError::new(11).extra_msg(&format!("{}", err)).handle(); continue;}
+                    };
+
+                    renders.push(render);
+                }
+            }
+        }
+
+        if let Some(local_webcomponents) = mr_data.get_mut("webcomponent") {
+            if let Some(arr) = local_webcomponents.as_array_mut(){
+                //add folder to local_renders
+                for mut el in arr.iter_mut() {
+                    if let Some(table) = el.as_table_mut(){
+                        table.insert("folder".to_owned(), toml::Value::String(mr_folder.file_name().into_string().unwrap()));
+                        table.insert("type".to_owned(), toml::Value::String("webcomponent".to_owned()));
+                        table.insert("webroot".to_owned(), toml::Value::String("".to_owned()));
+                    }
+
+                    let render = match Render::deserialize(el.clone()) {
+                        Ok(render) => render,
+                        Err(err) => {MizeError::new(11).extra_msg(&format!("{}", err)).handle(); continue;}
+                    };
+
+                    renders.push(render);
+                }
+            }
+        }
+
+    }
+
+    return Ok((renders));
+}
+
 
 

src/server/proto.rs

@@ -39,14 +39,10 @@ pub struct BinMessage {
     pub raw: Vec<u8>,
 }
 
-#[derive(From, Clone, Debug, Serialize, Deserialize)]
+#[derive(From, Clone, Debug, Deserialize)]
-#[serde(tag = "cat")]
 pub enum JsonMessage {
-    #[serde(rename="err")]
     ErrMsg(ErrMessage),
-    #[serde(rename="item")]
     ForItem(ItemMessage),
-    #[serde(rename="arr")]
     ForArr(ArrayMessage),
 }
 
@@ -66,25 +62,25 @@ pub struct ArrayMessage {
 #[derive(From, Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "cmd")]
 pub enum ItemMessage {
-    #[serde(rename="get")]
+    #[serde(rename="item.get")]
     Get(GetItemMessage),
-    #[serde(rename="get-sub")]
+    #[serde(rename="item.get-sub")]
     GetSub(GetSubMessage),
-    #[serde(rename="give")]
+    #[serde(rename="item.give")]
     Give(GiveItemMessage),
-    #[serde(rename="create")]
+    #[serde(rename="item.create")]
     Create(CreateItemMessage),
-    #[serde(rename="created-id")]
+    #[serde(rename="item.created-id")]
     CreatedId(CreatedIdMessage),
-    #[serde(rename="delete")]
+    #[serde(rename="item.delete")]
     Delete(DeleteItemMessage),
-    #[serde(rename="sub")]
+    #[serde(rename="item.sub")]
     Sub(SubItemMessage),
-    #[serde(rename="unsub")]
+    #[serde(rename="item.unsub")]
     Unsub(UnsubItemMessage),
-    #[serde(rename="update-req")]
+    #[serde(rename="item.update-req")]
     UpdateRequest(UpdateRequestMessage),
-    #[serde(rename="update")]
+    #[serde(rename="item.update")]
     Update(UpdateMessage),
 }
 
@@ -270,7 +266,6 @@ impl<'de> Deserialize<'de> for MizeId {
                     //scip the #
                     let mod_name: String = iter.clone().take_while(|ch| ch != &'#' || ch != &'/').collect();
                     let id: String = iter.collect();
-                    println!("in deserialize..... mod_name: --{}-- id: --{}--", mod_name.clone(), id.clone());
                     return Ok(MizeId::Module { mod_name, id});
                 } else {
                     let id: u64 = match v.parse(){
@@ -295,6 +290,29 @@ impl<'de> Deserialize<'de> for MizeId {
     }
 }
 
+
+impl Serialize for JsonMessage {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer 
+    {
+
+        match self {
+            JsonMessage::ErrMsg(err_msg) => {
+                ErrMessage::serialize(&err_msg, serializer)
+            },
+
+            JsonMessage::ForArr(arr_msg) => {
+                ArrayMessage::serialize(&arr_msg, serializer)
+            },
+
+            JsonMessage::ForItem(item_msg) => {
+                ItemMessage::serialize(&item_msg, serializer)
+            },
+        }
+    }
+}
+
 //###//===================================================
 // functions