add & update template

src/main.rs

@@ -63,7 +63,9 @@ async fn main() -> std::io::Result<()> {
                             .service(service::get_page_data)
                             .service(service::update_page)
                             .service(service::files::post_files)
-                            .service(service::files::delete_static_file),
+                            .service(service::files::delete_static_file)
+                            .service(service::add_template)
+                            .service(service::update_template),
                     ),
             )
             .service(service::files::favicon)

src/service/website.rs

-use crate::website::{Page, WebSite};
+use crate::website::{Page, PageTemplate, WebSite};
 use actix_web::{
     get, post, put,
     web::{Data, Json},
@@ -23,7 +23,7 @@ pub async fn add_page(
         .expect("Couldn't acquire website write lock")
         .add_page(add_page_data.parent_page_id, add_page_data.new_page.clone())
     {
-        Ok(()) => HttpResponse::Ok().finish(),
+        Ok(()) => HttpResponse::Created().finish(),
         Err(msg) => {
             HttpResponse::BadRequest().body(format!("Error adding new page to website - {}", msg))
         }
@@ -53,11 +53,11 @@ pub async fn update_page(
     updated_page: Json<Page>,
 ) -> HttpResponse {
     let id = id.into_inner();
-    let updated_page = updated_page.into_inner();
+
     match website
         .write()
         .expect("Couldn't acquire website write lock")
-        .update_page(id, updated_page)
+        .update_page(id, updated_page.into_inner())
     {
         Ok(page) => HttpResponse::Ok().json(page),
         Err(msg) => {
@@ -65,3 +65,46 @@ pub async fn update_page(
         }
     }
 }
+
+#[post("/add-template")]
+pub async fn add_template(
+    website: Data<RwLock<WebSite>>,
+    new_template: Json<PageTemplate>,
+) -> HttpResponse {
+    match website
+        .write()
+        .expect("Couldn't acquire website write lock")
+        .add_template(new_template.into_inner())
+    {
+        Ok(template) => HttpResponse::Created().json(template),
+        Err(msg) => HttpResponse::BadRequest().body(format!("Error adding new template {}", msg)),
+    }
+}
+
+#[post("/update-template")]
+pub async fn update_template(
+    website: Data<RwLock<WebSite>>,
+    updated_template: Json<PageTemplate>,
+) -> HttpResponse {
+    let updated = {
+        let mut ws = website
+            .write()
+            .expect("Couldn't acquire website write lock");
+        match ws.update_template(updated_template.into_inner()) {
+            Ok(template) => template.clone(),
+            Err(msg) => {
+                return HttpResponse::BadRequest().body(format!("Error updating template {}", msg))
+            }
+        }
+    };
+
+    WebSite::update_page_rec_after_template_update(
+        &mut website
+            .write()
+            .expect("Couldn't acquire website write lock")
+            .root_page,
+        &updated,
+    );
+
+    HttpResponse::Ok().json(updated)
+}

src/website/mod.rs

@@ -3,5 +3,5 @@ mod html;
 mod page;
 mod website;
 
-pub use page::Page;
+pub use page::*;
 pub use website::*;

src/website/page.rs

@@ -249,6 +249,17 @@ impl Page {
         Ok(())
     }
 
+    pub fn update_template(&mut self, template: &PageTemplate) {
+        self.template = Some(template.clone());
+        self.template_name = template.name.to_owned();
+    }
+
+    pub fn update_template_if_same_name(&mut self, template: &PageTemplate) {
+        if self.template_name.eq(&template.name) {
+            self.update_template(template);
+        }
+    }
+
     pub fn set_template(&mut self, template: PageTemplate) {
         self.template = Some(template);
     }
@@ -286,6 +297,7 @@ impl Page {
             .find(|t| t.name == self.template_name)
             .expect("Page template not found")
     }
+
     fn write_to_static_file(
         &self,
         url: &PathBuf,

src/website/website.rs

@@ -19,7 +19,7 @@ pub struct WebSiteBuilder(WebSiteData);
 #[derive(Debug, Clone)]
 pub struct WebSite {
     last_generated_page_id: usize,
-    root_page: Page,
+    pub root_page: Page,
     pub static_files_manager: StaticFilesManager,
     templates: Vec<PageTemplate>,
 }
@@ -229,6 +229,83 @@ impl WebSite {
             None => Err(format!("Page with id {} was not found", id)),
         }
     }
+
+    fn validate_add_template(&self, template: &PageTemplate) -> Result<(), String> {
+        if !self.get_template(&template.name).is_none() {
+            return Err(format!(
+                "A template named \"{}\" already exists",
+                template.name
+            ));
+        }
+
+        if PageTemplate::get_page_body_placeholder(&mut template.clone().contents).is_err() {
+            return Err(format!(
+                "Page body container was not found in template named \"{}\"",
+                template.name
+            ));
+        }
+
+        Ok(())
+    }
+
+    fn validate_update_template(&self, template: &PageTemplate) -> Result<(), String> {
+        if self.get_template(&template.name).is_none() {
+            return Err(format!(
+                "Templated named \"{}\" was not found.",
+                template.name
+            ));
+        }
+
+        if PageTemplate::get_page_body_placeholder(&mut template.clone().contents).is_err() {
+            return Err(format!(
+                "Page body container was not found in template named \"{}\"",
+                template.name
+            ));
+        }
+
+        Ok(())
+    }
+
+    fn get_template(&self, name: &String) -> Option<&PageTemplate> {
+        self.templates.iter().find(|t| t.name.eq(name))
+    }
+
+    fn get_template_mut(&mut self, name: &String) -> Option<&mut PageTemplate> {
+        self.templates.iter_mut().find(|t| t.name.eq(name))
+    }
+
+    pub fn add_template(&mut self, new_template: PageTemplate) -> Result<&PageTemplate, String> {
+        match self.validate_add_template(&new_template) {
+            Ok(()) => {
+                let name = new_template.name.to_owned();
+                self.templates.push(new_template);
+                Ok(self.get_template(&name).unwrap())
+            }
+            Err(msg) => Err(msg),
+        }
+    }
+
+    pub fn update_template(
+        &mut self,
+        updated_template: PageTemplate,
+    ) -> Result<&PageTemplate, String> {
+        match self.validate_update_template(&updated_template) {
+            Ok(()) => {
+                let template = self.get_template_mut(&updated_template.name).unwrap();
+                *template = updated_template;
+
+                Ok(template)
+            }
+            Err(msg) => Err(msg),
+        }
+    }
+
+    pub fn update_page_rec_after_template_update(page: &mut Page, template: &PageTemplate) {
+        page.update_template_if_same_name(template);
+        for sp in page.sub_pages.iter_mut() {
+            Self::update_page_rec_after_template_update(sp, template);
+        }
+    }
 }
 
 #[cfg(test)]
@@ -320,4 +397,79 @@ mod test_website {
 
         remove_test_dir(&test_dir);
     }
+
+    #[test]
+    fn add_template() {
+        let test_template: &'static str = "
+{
+    \"name\": \"TEST ADD TEMPLATE\",
+    \"layout\": {},
+    \"contents\": [
+        {
+            \"tag\": \"div\",
+            \"attrs\": {
+                \"class\": \"page-template\"
+            },
+            \"contents\": [
+                {
+                    \"tag\": \"header\",
+                    \"contents\": [
+                        {
+                            \"tag\": \"nav\"
+                        }
+                    ]
+                },
+                {
+                    \"tag\": \"div\",
+                    \"attrs\": {
+                        \"id\": \"page-body\"
+                    }
+                },
+                {
+                    \"tag\": \"footer\"
+                }
+            ]
+        }
+    ]
+}
+        ";
+
+        let test_dir = PathBuf::from("./test");
+        let mut ws = test_website(&test_dir);
+
+        let new_template: PageTemplate = serde_json::from_str(test_template).unwrap();
+
+        let add_template_res = ws.add_template(new_template);
+        assert!(add_template_res.is_ok());
+
+        let added_template = add_template_res.unwrap();
+        assert_eq!(added_template.name, "TEST ADD TEMPLATE");
+
+        remove_test_dir(&test_dir);
+    }
+
+    #[test]
+    fn test_update_template() {
+        let test_dir = PathBuf::from("./test");
+        let ws = test_website(&test_dir);
+        let (updated, mut ws) = {
+            let mut ws = ws;
+            let mut template = ws
+                .get_template(&"TEST TEMPLATE".to_string())
+                .unwrap()
+                .clone();
+
+            template.contents[0].tag = "changed_tag".to_owned();
+
+            let updated = ws.update_template(template).unwrap();
+            assert_eq!(updated.contents[0].tag, "changed_tag");
+            (updated.clone(), ws)
+        };
+
+        WebSite::update_page_rec_after_template_update(&mut ws.root_page, &updated);
+        for p in ws.get_all_pages_as_vec() {
+            assert_eq!(p.template.as_ref().unwrap().contents[0].tag, "changed_tag");
+        }
+        remove_test_dir(&test_dir);
+    }
 }