First commit with draft.

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..4e89a98
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+/target
+/Cargo.lock
+*.~*~
+examples/*.toml
\ No newline at end of file

diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644 (file)
index 0000000..4c5e1b8
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "zakgrid"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+
+[dependencies]
+
+
+[dev-dependencies]
+serde = "1"
+serde_derive = "1"
+config = "0.13"
+
+actix-web = "4"

diff --git a/examples/app.toml.dist b/examples/app.toml.dist
new file mode 100644 (file)
index 0000000..44041c4
--- /dev/null
+++ b/examples/app.toml.dist
@@ -0,0 +1,3 @@
+[http]
+bind_ip="10.0.0.101"
+bind_port=9090

diff --git a/examples/grid.rs b/examples/grid.rs
new file mode 100644 (file)
index 0000000..99516f8
--- /dev/null
+++ b/examples/grid.rs
@@ -0,0 +1,118 @@
+extern crate zakgrid;
+
+use config::{Config, ConfigError};
+use serde_derive::Deserialize;
+
+use actix_web::{
+    body::BoxBody,
+    dev::ServiceResponse,
+    error,
+    http::{header::ContentType, StatusCode},
+    middleware::{self, ErrorHandlerResponse, ErrorHandlers},
+    web, App, Error, HttpResponse, HttpServer, Responder, Result,
+};
+
+#[derive(Debug, Deserialize)]
+#[allow(unused)]
+struct Http {
+       bind_ip: String,
+       bind_port: u16,
+}
+
+#[derive(Debug, Deserialize)]
+#[allow(unused)]
+struct Settings {
+       http: Http,
+}
+
+impl Settings {
+       fn new() -> Result<Self, ConfigError> {
+               let s = Config::builder()
+                       .add_source(config::File::with_name("examples/app"))
+                       .build()?;
+
+               s.try_deserialize()
+       }
+}
+
+struct AppState {
+       settings: Settings,
+}
+
+async fn index(
+    data: web::Data<AppState>,
+) -> Result<impl Responder, Error> {
+
+       let mut grid = zakgrid::Grid::new();
+
+       let mut s = format!("before: {}\n", grid.header_tmpl);
+
+       grid.header_tmpl = String::from("new header");
+
+       s.push_str(format!("after: {}\n", grid.header_tmpl).as_str());
+
+       let mut col = zakgrid::Column::new("col name");
+
+       s.push_str(format!("column added: {}", col.name()).as_str());
+
+       Ok(HttpResponse::Ok().body(s))
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+
+       let appstate: AppState = AppState {
+               settings: Settings::new().unwrap(),
+       };
+
+       // Print out our settings
+       println!(
+               "{:?}",
+               appstate.settings
+       );
+
+    println!("Listening on: {}:{}, open browser and visit have a try!", appstate.settings.http.bind_ip, appstate.settings.http.bind_port);
+    HttpServer::new(move || {
+        App::new()
+            .app_data(web::Data::new(AppState {
+                               settings: Settings::new().unwrap(),
+                       }))
+            .wrap(middleware::Logger::default()) // enable logger
+            .service(web::resource("/").route(web::get().to(index)))
+            .service(web::scope("").wrap(error_handlers()))
+    })
+    .bind((appstate.settings.http.bind_ip, appstate.settings.http.bind_port))?
+    .run()
+    .await
+}
+
+// Custom error handlers, to return HTML responses when an error occurs.
+fn error_handlers() -> ErrorHandlers<BoxBody> {
+    ErrorHandlers::new().handler(StatusCode::NOT_FOUND, not_found)
+}
+
+// Error handler for a 404 Page not found error.
+fn not_found<B>(res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<BoxBody>> {
+    let response = get_error_response(&res, "Page not found");
+    Ok(ErrorHandlerResponse::Response(ServiceResponse::new(
+        res.into_parts().0,
+        response.map_into_left_body(),
+    )))
+}
+
+// Generic error handler.
+fn get_error_response<B>(res: &ServiceResponse<B>, error: &str) -> HttpResponse {
+    let request = res.request();
+
+    // Provide a fallback to a simple plain text response in case an error occurs during the
+    // rendering of the error page.
+    let fallback = |e: &str| {
+        HttpResponse::build(res.status())
+            .content_type(ContentType::plaintext())
+            .body(e.to_string())
+    };
+
+    HttpResponse::build(res.status())
+            .content_type(ContentType::html())
+            .body("")
+}

diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644 (file)
index 0000000..5e2e86c
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,47 @@
+pub enum Align {
+       Left,
+       Center,
+       Right
+}
+
+pub struct Column {
+       name: String,
+       title: String,
+       align: Align,
+       hidden: bool,
+}
+
+impl Column {
+       pub fn new(name: &str) -> Column {
+               Column {
+                       name: String::from(name),
+                       title: String::new(),
+                       align: Align::Left,
+                       hidden: false,
+               }
+       }
+
+       pub fn name(&self) -> String {
+               format!("{}", self.name)
+       }
+}
+
+pub struct Grid {
+       pub header_tmpl: String,
+       header_row_tmpl: String,
+       row_tmpl: String,
+       row_col_tmpl: String,
+       columns: Vec<Column>,
+}
+
+impl Grid {
+       pub fn new() -> Grid {
+               Grid {
+                       header_tmpl: String::new(),
+                       header_row_tmpl: String::new(),
+                       row_tmpl: String::new(),
+                       row_col_tmpl: String::new(),
+                       columns: vec![]
+               }
+       }
+}