add IPC PWA example

FranBarInstance · FranBarInstance · commit 11fe5f504fd2 · 2025-09-15T12:21:22.000+02:00
diff --git a/examples/rust/pwa-actix-ipc/Cargo.toml b/examples/rust/pwa-actix-ipc/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "pwa-actix"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+neutralipcrs = "1.3.0-beta1"
+actix-web = "4.4"
+actix-files = "0.6"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1.0", features = ["full"] }
diff --git a/examples/rust/pwa-actix-ipc/README.md b/examples/rust/pwa-actix-ipc/README.md
@@ -0,0 +1,26 @@
+Neutral TS example with Actix Web
+=================================
+
+Example of using Neutral Template System with Web APP and different themes.
+
+Navigate to the examples/rust/pwa-actix directory and then:
+
+```
+cargo run --release
+```
+
+A server will be available on port 9090
+
+```
+http://127.0.0.1:9090/
+```
+
+Links
+-----
+
+Neutral TS template engine.
+
+- [Template docs](https://franbarinstance.github.io/neutralts-docs/docs/neutralts/doc/)
+- [Repository](https://github.com/FranBarInstance/neutralts)
+- [Crate](https://crates.io/crates/neutralts)
+- [Examples](https://github.com/FranBarInstance/neutralts-docs/tree/master/examples)
diff --git a/examples/rust/pwa-actix-ipc/src/constants.rs b/examples/rust/pwa-actix-ipc/src/constants.rs
@@ -0,0 +1,21 @@
+//! Constants
+//! See: https://github.com/FranBarInstance/neutralts-docs
+
+// Use cached templates
+pub const TEMPLATE_ROUTER: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../neutral/tpl/cache.ntpl");
+
+// Uncomment for no cached templates
+// pub const TEMPLATE_ROUTER: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../neutral/tpl/index.ntpl");
+
+// HTTP errors template
+pub const TEMPLATE_ERROR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../neutral/tpl/cache_error.ntpl");
+
+// static files
+pub const STATIC_FOLDER: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../neutral/static");
+
+// Default schema
+pub const DEFAULT_SCHEMA: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../neutral/data/schema.json");
+
+pub const LANG_KEY: &str = "lang";
+pub const THEME_KEY: &str = "theme";
+pub const SIMULATE_SECRET_KEY: &str = "69bdd1e4b4047d8f4e3";
diff --git a/examples/rust/pwa-actix-ipc/src/main.rs b/examples/rust/pwa-actix-ipc/src/main.rs
@@ -0,0 +1,109 @@
+//! Neutral TS example with Actix-web
+//! See: https://github.com/FranBarInstance/neutralts-docs
+
+use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Result};
+use actix_files::NamedFile;
+use serde_json::Value;
+use std::path::Path;
+use std::collections::HashMap;
+
+mod constants;
+mod schema;
+mod template;
+
+use constants::{STATIC_FOLDER, SIMULATE_SECRET_KEY};
+use schema::Schema;
+use template::Template;
+
+/// Catch all route handler - serves static files and dynamic content (GET only)
+///
+/// To prevent arbitrary routes contents-[route]-snippets.ntpl must exist,
+/// to create a simple view/route you wouldn't need a function or view, just create
+/// the contents-[route]-snippets.ntpl template file.
+///
+/// Following routes do not have a handler and are dispatched here:
+/// /simulate-...
+/// /help
+/// /login
+///
+/// /login is a container for /form-login (/form-login is loaded via ajax)
+async fn catch_all_get(req: HttpRequest, path: web::Path<String>) -> Result<HttpResponse> {
+    let route = path.into_inner();
+
+    // Serve static files directly
+    let file_path = Path::new(STATIC_FOLDER).join(&route);
+    if file_path.exists() && file_path.is_file() {
+        return Ok(NamedFile::open(file_path)?.into_response(&req));
+    }
+
+    // Serve dynamic content
+    let schema = Schema::new(&req, &route);
+    let template = Template::new(schema.get().clone());
+    template.render().map_err(|e| actix_web::error::ErrorInternalServerError(e))
+}
+
+/// Display form login (GET)
+async fn form_login_get(req: HttpRequest) -> Result<HttpResponse> {
+    let route = "form-login";
+    let schema = Schema::new(&req, route);
+
+    let template = Template::new(schema.get().clone());
+    template.render().map_err(|e| actix_web::error::ErrorInternalServerError(e))
+}
+
+/// Process login form in POST (Fake login)
+async fn form_login_post(req: HttpRequest, form: web::Form<HashMap<String, String>>) -> Result<HttpResponse> {
+    let route = "form-login";
+    let mut schema = Schema::new_with_post(&req, route, form);
+    let current_schema = schema.get_mut();
+
+    current_schema["data"]["send_form_login"] = Value::Number(serde_json::Number::from(1));
+
+    // Fake login, any user, password: 1234
+    let passwd = current_schema["data"]["CONTEXT"]["POST"]["passwd"]
+        .as_str()
+        .unwrap();
+
+    if passwd == "1234" {
+        current_schema["data"]["send_form_login_fails"] = Value::Null;
+        current_schema["data"]["CONTEXT"]["SESSION"] = Value::String(SIMULATE_SECRET_KEY.to_string());
+    } else {
+        current_schema["data"]["send_form_login_fails"] = Value::Number(serde_json::Number::from(1));
+    }
+
+    let template = Template::new(schema.get().clone());
+    template.render().map_err(|e| actix_web::error::ErrorInternalServerError(e))
+}
+
+// Home GET
+async fn home_get(req: HttpRequest) -> Result<HttpResponse> {
+    let route = "home";
+    let schema = Schema::new(&req, route);
+    let template = Template::new(schema.get().clone());
+    template.render().map_err(|e| actix_web::error::ErrorInternalServerError(e))
+}
+
+// Home POST
+async fn home_post(req: HttpRequest, form: web::Form<HashMap<String, String>>) -> Result<HttpResponse> {
+    let route = "home";
+    let schema = Schema::new_with_post(&req, route, form);
+    let template = Template::new(schema.get().clone());
+    template.render().map_err(|e| actix_web::error::ErrorInternalServerError(e))
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    println!("Starting Neutral TS PWA Actix server on http://127.0.0.1:9090");
+
+    HttpServer::new(|| {
+        App::new()
+            .route("/", web::get().to(home_get))
+            .route("/", web::post().to(home_post))
+            .route("/form-login", web::get().to(form_login_get))
+            .route("/form-login", web::post().to(form_login_post))
+            .route("/{path:.*}", web::get().to(catch_all_get))
+    })
+    .bind("127.0.0.1:9090")?
+    .run()
+    .await
+}
diff --git a/examples/rust/pwa-actix-ipc/src/schema.rs b/examples/rust/pwa-actix-ipc/src/schema.rs
@@ -0,0 +1,196 @@
+//! Schema
+//! See: https://github.com/FranBarInstance/neutralts-docs
+
+use actix_web::HttpRequest;
+use actix_web::web;
+use serde_json::{json, Value};
+use std::fs;
+use std::collections::HashMap;
+use crate::constants::{DEFAULT_SCHEMA, LANG_KEY, THEME_KEY};
+
+// It is important to distinguish between data coming from the user and data
+// coming from the application. "CONTEXT" has some security measures such as escaping.
+pub struct Schema {
+    req: HttpRequest,
+    route: String,
+    schema: Value,
+}
+
+impl Schema {
+    pub fn new(req: &HttpRequest, route: &str) -> Self {
+        let mut schema = Self {
+            req: req.clone(),
+            route: route.trim_matches('/').to_string(),
+            schema: Value::Null,
+        };
+        schema.default();
+        schema.populate_context(None);
+        schema.negotiate_language();
+        schema.set_theme();
+        schema
+    }
+
+    pub fn new_with_post(req: &HttpRequest, route: &str, form: web::Form<HashMap<String, String>>) -> Self {
+        let mut schema = Self {
+            req: req.clone(),
+            route: route.trim_matches('/').to_string(),
+            schema: Value::Null,
+        };
+        schema.default();
+        // Extraer el HashMap interno del Form
+        schema.populate_context(Some(form.into_inner()));
+        schema.negotiate_language();
+        schema.set_theme();
+        schema
+    }
+
+    fn default(&mut self) {
+        let schema_content = fs::read_to_string(DEFAULT_SCHEMA)
+            .expect("Failed to read default schema");
+        self.schema = serde_json::from_str(&schema_content)
+            .expect("Failed to parse default schema");
+
+        // Ensure required structure exists
+        if self.schema.get("data").is_none() {
+            self.schema["data"] = json!({});
+        }
+        if self.schema["data"].get("CONTEXT").is_none() {
+            self.schema["data"]["CONTEXT"] = json!({});
+        }
+        if self.schema["data"]["CONTEXT"].get("GET").is_none() {
+            self.schema["data"]["CONTEXT"]["GET"] = json!({});
+        }
+        if self.schema["data"]["CONTEXT"].get("POST").is_none() {
+            self.schema["data"]["CONTEXT"]["POST"] = json!({});
+        }
+        if self.schema["data"]["CONTEXT"].get("COOKIES").is_none() {
+            self.schema["data"]["CONTEXT"]["COOKIES"] = json!({});
+        }
+        if self.schema["data"]["CONTEXT"].get("HEADERS").is_none() {
+            self.schema["data"]["CONTEXT"]["HEADERS"] = json!({});
+        }
+    }
+
+    fn populate_context(&mut self, post_data: Option<HashMap<String, String>>) {
+        self.schema["data"]["CONTEXT"]["ROUTE"] = json!(self.route);
+
+        // Get Host header
+        if let Some(host) = self.req.headers().get("Host") {
+            if let Ok(host_str) = host.to_str() {
+                self.schema["data"]["CONTEXT"]["HEADERS"]["HOST"] = json!(host_str);
+            }
+        }
+
+        // Parse query parameters (GET)
+        if let Some(query) = self.req.uri().query() {
+            let params: Vec<&str> = query.split('&').collect();
+            for param in params {
+                if let Some(eq_pos) = param.find('=') {
+                    let key = &param[..eq_pos];
+                    let value = &param[eq_pos + 1..];
+                    self.schema["data"]["CONTEXT"]["GET"][key] = json!(value);
+                }
+            }
+        }
+
+        // Parse POST data if available
+        if let Some(post_params) = post_data {
+            for (key, value) in post_params {
+                self.schema["data"]["CONTEXT"]["POST"][key] = json!(value);
+            }
+        }
+
+        // Parse headers
+        for (key, value) in self.req.headers() {
+            if let Ok(value_str) = value.to_str() {
+                self.schema["data"]["CONTEXT"]["HEADERS"][key.as_str()] = json!(value_str);
+            }
+        }
+
+        // Parse cookies
+        if let Some(cookie_header) = self.req.headers().get("Cookie") {
+            if let Ok(cookie_str) = cookie_header.to_str() {
+                for cookie in cookie_str.split(';') {
+                    let cookie = cookie.trim();
+                    if let Some(eq_pos) = cookie.find('=') {
+                        let key = &cookie[..eq_pos];
+                        let value = &cookie[eq_pos + 1..];
+                        self.schema["data"]["CONTEXT"]["COOKIES"][key] = json!(value);
+                    }
+                }
+            }
+        }
+
+        // Fake session
+        let session = self.schema["data"]["CONTEXT"]["COOKIES"]
+            .get("SESSION")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+        if session.is_some() {
+            self.schema["data"]["CONTEXT"]["SESSION"] = json!(session.unwrap());
+        }
+    }
+
+    fn negotiate_language(&mut self) {
+        let languages = self.schema["data"]["site"]["validLanguages"].clone();
+        let empty_vec = vec![];
+        let languages_array = languages.as_array().unwrap_or(&empty_vec);
+        let languages_vec: Vec<String> = languages_array
+            .iter()
+            .filter_map(|v| v.as_str().map(|s| s.to_string()))
+            .collect();
+
+        // Get language from query params, cookies, or default to first language
+        let lang_from_get = self.schema["data"]["CONTEXT"]["GET"]
+            .get(LANG_KEY)
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
+        let lang_from_cookies = self.schema["data"]["CONTEXT"]["COOKIES"]
+            .get(LANG_KEY)
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
+        let current_lang = lang_from_get
+            .or(lang_from_cookies)
+            .filter(|lang| languages_vec.contains(lang))
+            .unwrap_or_else(|| languages_vec.first().cloned().unwrap_or_default());
+
+        self.schema["inherit"]["locale"]["current"] = json!(current_lang);
+    }
+
+    fn set_theme(&mut self) {
+        let theme_from_get = self.schema["data"]["CONTEXT"]["GET"]
+            .get(THEME_KEY)
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
+        let theme_from_cookies = self.schema["data"]["CONTEXT"]["COOKIES"]
+            .get(THEME_KEY)
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
+        let valid_themes = self.schema["data"]["site"]["validThemes"].clone();
+        let empty_vec = vec![];
+        let valid_themes_array = valid_themes.as_array().unwrap_or(&empty_vec);
+        let default_theme = valid_themes_array
+            .first()
+            .and_then(|v| v.as_str())
+            .unwrap_or("default");
+
+        let current_theme = theme_from_get
+            .or(theme_from_cookies)
+            .filter(|theme| valid_themes_array.contains(&json!(theme)))
+            .unwrap_or_else(|| default_theme.to_string());
+
+        self.schema["data"]["site"]["theme"] = json!(current_theme);
+    }
+
+    pub fn get_mut(&mut self) -> &mut Value {
+        &mut self.schema
+    }
+
+    pub fn get(&self) -> &Value {
+        &self.schema
+    }
+}
diff --git a/examples/rust/pwa-actix-ipc/src/template.rs b/examples/rust/pwa-actix-ipc/src/template.rs
