first time database data in mogwai component

 [workspace]
-members = [ "ui", "server" ]
+members = [ "server", "ui" ]
 
 [profile.release]
 lto = true

@@ -2,4 +2,4 @@
 # see diesel.rs/guides/configuring-diesel-cli
 
 [print_schema]
-file = "src/schema.rs"
+file = "server/src/schema.rs"

@@ -15,3 +15,6 @@
 ## Free Artwork
 - [Designlooter](https://designlooter.com/ 'Designlooter')
 - [SVGRepo](https://www.svgrepo.com/ 'SVGRepo')
+
+## Send and async and using non Send types...
+- [Rust Send Story](https://procmarco.netlify.app/blog/2021-05-04-a-story-about-async-rust-and-using-send-types/ 'Rust Send story')

+-- This file should undo anything in `up.sql`
+DROP INDEX "markdown_diffs_id";
+DROP TABLE "markdown_diffs";
+DROP TABLE "markdowns";

+CREATE TABLE "markdowns" (
+	id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+	name VARCHAR(256) NOT NULL,
+	content TEXT NOT NULL,
+	number_of_versions INTEGER NOT NULL DEFAULT (1),
+	date_created TEXT NOT NULL,
+	date_updated TEXT NOT NULL
+);
+
+-- This holds compressed reverse patches to markdown.content.
+-- The markdown.content field always holds the latest version.
+-- This way we can always restore every version we had in the past.
+-- The date_created here should be set to the value of
+-- markdown.date_updated when the patch was created. This diff_id
+-- is always current last max diff_id for given markdown_id plus 1.
+CREATE TABLE "markdown_diffs" (
+	markdown_id INTEGER NOT NULL,
+	diff_id INTEGER NOT NULL,
+	diff BLOB NOT NULL,
+	date_created TEXT NOT NULL,
+	PRIMARY KEY (markdown_id, diff_id)
+);
+
+INSERT INTO
+	"markdowns"(name, content, date_created, date_updated)
+VALUES
+	( "md-example"
+        , "# Ein sehr schöner Titel
+
+## Ein sinnloser Text
+
+Hier kommt ganz viel Text der irgendwie auch was machen soll, aber Zeilen
+sollen auch im <pre> Eingabefeld automatisch umbrechen.
+
+Ein neuner Paragraph beginnt nach einer Leerzeile.  
+Ein Umbruch entsteht wie gewohnt durch 2 spaces am Ende einer
+Zeile.
+
+## Fußnoten
+
+Vllt. kann man sogar so was wie Fussnoten[^1] in den Markdown Text
+einbinden... diese kann man dann irgendwo einbauen...
+
+---
+
+[^1]: Zum Beispiel so...
+
+[^2]: Oder so...
+
+## inline html ist im Moment auch ok.
+
+<pre>Lustigerweise geht auch inline html</pre>
+
+## Listen for fun
+
+- ein Liste
+    - mehr Liste
+    - diesmal als Subliste.
+- und was auch immer...
+    1. und nun Verschachtelt.
+        1. Numeriert.
+        2. huhuhu
+        3. wie bitte.
+    2. juhu
+- noch mehr Liste
+
+## Preformated Text
+
+```Hier kommt der code```
+
+Und hier der Paragraph mit `inline code` der auch sehr schön aussehen kann.
+
+## Hervorhebungen
+
+Man kann Text auch sehr schön formatieren. So ist es z.B. möglich
+*Worte kursiv zu stellen* oder man kann **sie auch fett schreiben**.
+Als spezielles feature kann der von mir verwendete Parser auch
+~~Texte durchstreichen~~.
+
+Nur wenn man Text <u>unterstreichen</u> will muss man auf inline html
+zurückgreifen.
+
+## Blockquotes und horizontale Linie
+
+> Dies sollte jetzt als quote erkennbar sein.
+>
+>> Auch diese sind schachtelbar
+>
+> Und weiter gehts.
+
+---
+
+> Aber dies ist ein neuer quote.
+
+## Links
+
+Ein link kann inline geschrieben werden, so wie diese zu
+[Heise.de](https://heise.de/ 'Heise.de') oder als Referenz am Ende des Textes
+wie diese nach [Telepolis][lnk1].
+
+## Bilder koennte man auch einbinden.
+
+Wie Links lassen sich auch Bilder wie mein
+![Gravatar](https://www.gravatar.com/avatar/fd016c954ec4ed3a4315eeed6c8b97b8)
+in den Text ein.
+
+Im Fließtext sieht das allerdings ein bisschen dumm aus es sei denn man hat
+entsprechend angepasste styles. Besser scheint mir daher Bilder nur zwischen
+Paragraphen zu plazieren.
+
+![Gravatar](https://www.gravatar.com/avatar/fd016c954ec4ed3a4315eeed6c8b97b8)
+
+Etwas so wie hier.
+
+## Tabellen sollten auch gehen...
+
+Die folgenden Beispiele kommen von [markdown.land][lnk2]:
+
+| Item         | Price     | # In stock |
+|--------------|-----------|------------|
+| Juicy Apples | 1.99      | *8*        |
+| Bananas      | **1.89**  | 5234       |
+
+Man braucht sie nicht schön zu formatieren.
+
+Item | Price | # In stock
+---|---|---
+Juicy Apples | 1.99 | 739
+Bananas | 1.89 | 6
+
+und die Spaltenausrichtung kann man auch einstellen:
+
+| Item         | Price | # In stock |
+|--------------|:-----:|-----------:|
+| Juicy Apples |  1.99 |        739 |
+| Bananas      |  1.8900 |          6 |
+
+[lnk1]: https://heise.de/tp/ 'Telepolis'
+[lnk2]: https://markdown.land/markdown-table 'markdown.land'"
+	, "Today"
+	, "Today" );

@@ -36,3 +36,5 @@ serde_json = "1.0"
 anyhow = "1.0"
 chrono = "0.4.15"
 listenfd = "0.3"
+diffy = "0.2"
+flate2 = "^1.0"

@@ -6,15 +6,71 @@ mod models;
 mod routes;
 mod schema;
 
+use std::io::Write;
+use crate::routes::markdown::get_markdowns;
+use crate::routes::other::*;
+use crate::routes::user::*;
+
 use actix_web::{guard, web, App, HttpResponse, HttpServer};
 use diesel::r2d2::{self, ConnectionManager};
 use diesel::SqliteConnection;
+use diffy::create_patch;
+use flate2::Compression;
+use flate2::write::{DeflateEncoder, DeflateDecoder};
 use listenfd::ListenFd;
 
 pub(crate) type Pool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
 
+const ORIGINAL :&str = r"This is a long Multiline text to
+see if we can create a small patch set from
+a longer text.
+
+This paragraph will be kept without modification. The reason I
+try this is to see if the diff becomes smaller than storing a
+compressed new version of this text...
+
+So this whole paragraph is obsolete. It will be removed in the
+modified text.
+
+There is probably a threshold up to what amount of text is needed
+to make the diff smaller.
+";
+
+const MODIFIED :&str = r"This is a long multiline text to
+see if we can create a small patch set from
+a longer text.
+
+This paragraph will be kept without modification. The reason I
+try this is to see if the diff becomes smaller than storing a
+compressed new version of this text...
+
+This is the replacement for the previous paragraph.
+
+There is probably a threshold up to what amount of text is needed
+to make the diff smaller.
+";
+
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
+    /* just some playing with diffy */
+    let patch = format!("{}", create_patch(ORIGINAL, MODIFIED));
+    println!("{} - {}", patch.len(), patch);
+
+    let mut encoder = DeflateEncoder::new(Vec::new(), Compression::best());
+    encoder.write_all(patch.as_bytes()).unwrap();
+    let compressed = encoder.finish().unwrap();
+    println!("{} - {:?}", compressed.len(), compressed);
+
+    let mut decoder = DeflateDecoder::new(Vec::new());
+    decoder.write_all(compressed.as_ref()).unwrap();
+    let decompressed = decoder.finish().unwrap();
+    let decompressed = match std::str::from_utf8(decompressed.as_ref()) {
+        Ok(v) => v,
+        Err(e) => panic!("Invalid UTF-8 sequence: {}", e),
+    };
+    println!("{} - {}", decompressed.len(), decompressed);
+    /* ======= */
+
     let mut listenfd = ListenFd::from_env();
 
     dotenv::dotenv().ok();
@@ -28,24 +84,33 @@ async fn main() -> std::io::Result<()> {
         App::new() . data(database_pool.clone())
                    . service(actix_files::Files::new("/static", "./static"))
                    . service( web::scope("/api/v0")
+                            . service( web::resource("/markdowns")
+                                     . route(web::get().to(get_markdowns))
+                                     )
                             . service( web::resource("/users")
-                                     . route(web::get().to(routes::get_users))
-                                     . route(web::put().to(routes::create_user)))
+                                     . route(web::get().to(get_users))
+                                     . route(web::put().to(create_user))
+                                     )
                             . service( web::resource("/users/{id}")
-                                     . route(web::delete().to(routes::delete_user))
-                                     . route(web::get().to(routes::get_user))
-                                     . route(web::put().to(routes::update_user))))
+                                     . route(web::delete().to(delete_user))
+                                     . route(web::get().to(get_user))
+                                     . route(web::put().to(update_user))
+                                     )
+                            )
                    . service( web::scope("")
-                            . route("/", web::get().to(routes::root))
-                            . route("/index", web::get().to(routes::root))
-                            . route("/index.html", web::get().to(routes::root))
-                            . route("/favicon", web::get().to(routes::favicon))
-                            . route("/favicon.ico", web::get().to(routes::favicon)))
-                   . default_service(web::resource("")
-                            . route(web::get().to(routes::p404))
+                            . route("/", web::get().to(root))
+                            . route("/index", web::get().to(root))
+                            . route("/index.html", web::get().to(root))
+                            . route("/favicon", web::get().to(favicon))
+                            . route("/favicon.ico", web::get().to(favicon))
+                            )
+                   . default_service( web::resource("")
+                            . route( web::get().to(p404) )
                             . route( web::route()
-                                   . guard(guard::Not(guard::Get()))
-                                   . to(HttpResponse::MethodNotAllowed)))
+                                   . guard( guard::Not(guard::Get()) )
+                                   . to(HttpResponse::MethodNotAllowed)
+                                   )
+                            )
     });
 
     let server = match listenfd.take_tcp_listener(0).unwrap() {

+use std::sync::Arc;
+use crate::schema::*;
+use crate::error::Error;
+use crate::Pool;
+use diesel::prelude::*;
+use diesel::{
+    dsl::{delete, insert_into, update},
+    RunQueryDsl
+};
+use serde::{Deserialize, Serialize};
+
+
+#[derive(Debug, Serialize, Deserialize, Queryable, Identifiable)]
+pub struct Markdown {
+    pub id: i32,
+    pub name: String,
+    pub content: String,
+    pub number_of_versions: i32,
+    pub date_created: String,
+    pub date_updated: String,
+}
+
+#[derive(Debug, Insertable)]
+#[table_name = "markdowns"]
+pub struct MarkdownNew<'a> {
+    pub name: &'a str,
+    pub content: &'a str,
+    pub number_of_versions: i32,
+    pub date_created: &'a str,
+    pub date_updated: &'a str,
+}
+
+#[derive(Debug, Serialize, Deserialize, AsChangeset)]
+#[table_name="markdowns"]
+pub struct MarkdownJson {
+    pub name: String,
+    pub content: String,
+    pub number_of_versions: i32,
+}
+
+pub(crate) enum Action {
+    Created(Markdown),
+    Found(Markdown),
+}
+
+
+pub(crate) fn create_markdown( pool: Arc<Pool>
+                             , item: MarkdownJson ) -> Result<Action, Error> {
+    use crate::schema::markdowns::dsl::*;
+    let db_connection = pool.get()?;
+
+    match markdowns . filter(name.eq(&item.name))
+                    . first::<Markdown>(&db_connection)
+    {
+        Ok(result) => Ok(Action::Found(result)),
+        Err(_)     => {
+            let now = chrono::Local::now().naive_local();
+            let new_markdown = MarkdownNew {
+                name:               &item.name,
+                content:            &item.content,
+                number_of_versions: item.number_of_versions,
+                date_created:       &format!("{}", now),
+                date_updated:       &format!("{}", now),
+            };
+
+            Ok(Action::Created(db_connection.transaction(|| {
+                insert_into(markdowns) . values(&new_markdown)
+                                       . execute(&db_connection)?;
+
+                markdowns . order(id.desc())
+                          . first::<Markdown>(&db_connection)
+            })?))
+        }
+    }
+}
+
+pub(crate) fn get_markdowns(pool: Arc<Pool>) -> Result<Vec<Markdown>, Error>
+{
+    use crate::schema::markdowns::dsl::*;
+    let db_connection = pool.get()?;
+    Ok(markdowns.load::<Markdown>(&db_connection)?)
+}
+
+pub(crate) fn get_markdown( pool:  Arc<Pool>
+                          , ident: i32 ) -> Result<Markdown, Error>
+{
+    use crate::schema::markdowns::dsl::*;
+    let db_connection = pool.get()?;
+    Ok(markdowns.find(ident).first::<Markdown>(&db_connection)?)
+}
+
+pub(crate) fn delete_markdown( pool: Arc<Pool>
+                             , ident: i32 ) -> Result<usize, Error>
+{
+    use crate::schema::markdowns::dsl::*;
+    let db_connection = pool.get()?;
+    Ok(delete(markdowns.find(ident)).execute(&db_connection)?)
+}
+
+pub(crate) fn update_markdown( pool: Arc<Pool>
+                             , ident: i32
+                             , item: MarkdownJson ) -> Result<Markdown, Error>
+{
+    use crate::schema::markdowns::dsl::*;
+    let db_connection = pool.get()?;
+    let mut markdown = markdowns.find(ident).first::<Markdown>(&db_connection)?;
+    let now = chrono::Local::now().naive_local();
+
+    update(markdowns.find(ident)).set(&item).execute(&db_connection)?;
+    markdown.name               = item.name;
+    markdown.content            = item.content;
+    markdown.number_of_versions = item.number_of_versions;
+    markdown.date_updated       = format!("{}", now);
+
+    Ok(markdown)
+}

+pub(crate) mod user;
+pub(crate) mod markdown;

+use crate::models::markdown;
+use crate::Pool;
+
+use actix_web::{Error, HttpResponse, web};
+use anyhow::Result;
+
+pub async fn get_markdowns(pool: web::Data<Pool>)
+    -> Result<HttpResponse, Error>
+{
+    Ok(web::block(move || markdown::get_markdowns(pool.into_inner()))
+       . await
+       . map(|markdowns| HttpResponse::Ok().json(markdowns))
+       . map_err(|_| HttpResponse::InternalServerError())?)
+}

+pub(crate) mod markdown;
+pub(crate) mod other;
+pub(crate) mod user;

+use actix_web::Error;
+use anyhow::Result;
+
+pub async fn root() -> Result<actix_files::NamedFile, Error> {
+    Ok(actix_files::NamedFile::open("static/index.html")?)
+}
+
+pub async fn p404() -> Result<actix_files::NamedFile, Error> {
+    Ok(actix_files::NamedFile::open("static/404.html")?)
+}
+
+pub async fn favicon() -> Result<actix_files::NamedFile, Error> {
+    Ok(actix_files::NamedFile::open("static/favicon.ico")?)
+}

-use crate::models::{self, Action};
+use crate::models::user::{self, Action};
 use crate::Pool;
 
 use actix_web::{Error, HttpResponse, web};
 use anyhow::Result;
 
-pub async fn root() -> Result<actix_files::NamedFile, Error> {
-    Ok(actix_files::NamedFile::open("static/index.html")?)
-}
-
-pub async fn p404() -> Result<actix_files::NamedFile, Error> {
-    Ok(actix_files::NamedFile::open("static/404.html")?)
-}
-
-pub async fn favicon() -> Result<actix_files::NamedFile, Error> {
-    Ok(actix_files::NamedFile::open("static/favicon.ico")?)
-}
-
 pub async fn create_user( pool: web::Data<Pool>
-                        , item: web::Json<models::UserJson> )
+                        , item: web::Json<user::UserJson> )
     -> Result<HttpResponse, Error>
 {
     let pool = pool.into_inner();
     let item = item.into_inner();
 
-    Ok(web::block(move || models::create_user(pool, item))
+    Ok(web::block(move || user::create_user(pool, item))
        . await
        . map(|action| {
            match action {
@@ -36,7 +24,7 @@ pub async fn create_user( pool: web::Data<Pool>
 pub async fn get_users(pool: web::Data<Pool>)
     -> Result<HttpResponse, Error>
 {
-    Ok(web::block(move || models::get_users(pool.into_inner()))
+    Ok(web::block(move || user::get_users(pool.into_inner()))
        . await
        . map(|users| HttpResponse::Ok().json(users))
        . map_err(|_| HttpResponse::InternalServerError())?)
@@ -48,7 +36,7 @@ pub async fn get_user(pool: web::Data<Pool>, id: web::Path<i32>)
     let pool = pool.into_inner();
     let id   = id.into_inner();
 
-    Ok(web::block(move || models::get_user(pool, id))
+    Ok(web::block(move || user::get_user(pool, id))
        . await
        . map(|user| HttpResponse::Ok().json(user))
        . map_err(|_| HttpResponse::InternalServerError())?)
@@ -60,7 +48,7 @@ pub async fn delete_user(pool: web::Data<Pool>, id: web::Path<i32>)
     let pool = pool.into_inner();
     let id   = id.into_inner();
 
-    Ok(web::block(move || models::delete_user(pool, id))
+    Ok(web::block(move || user::delete_user(pool, id))
        . await
        . map(|_| HttpResponse::NoContent().finish())
        . map_err(|_| HttpResponse::InternalServerError())?)
@@ -68,14 +56,14 @@ pub async fn delete_user(pool: web::Data<Pool>, id: web::Path<i32>)
 
 pub async fn update_user( pool: web::Data<Pool>
                         , id:   web::Path<i32>
-                        , item: web::Json<models::UserJson> )
+                        , item: web::Json<user::UserJson> )
     -> Result<HttpResponse, Error>
 {
     let pool = pool.into_inner();
     let id   = id.into_inner();
     let item = item.into_inner();
 
-    Ok(web::block(move || models::update_user(pool, id, item))
+    Ok(web::block(move || user::update_user(pool, id, item))
        . await
        . map(|user| HttpResponse::Ok().json(user))
        . map_err(|_| HttpResponse::InternalServerError())?)

 table! {
+    markdown_diffs (markdown_id, diff_id) {
+        markdown_id -> Integer,
+        diff_id -> Integer,
+        diff -> Binary,
+        date_created -> Text,
+    }
+}
+
+table! {
+    markdowns (id) {
+        id -> Integer,
+        name -> Text,
+        content -> Text,
+        number_of_versions -> Integer,
+        date_created -> Text,
+        date_updated -> Text,
+    }
+}
+
+table! {
     users (id) {
         id -> Integer,
         name -> Text,
@@ -6,3 +26,9 @@ table! {
         date_created -> Text,
     }
 }
+
+allow_tables_to_appear_in_same_query!(
+    markdown_diffs,
+    markdowns,
+    users,
+);

@@ -22,6 +22,10 @@
   width: 100%;
   overflow-y: scroll;
   overflow-x: hidden;
+  background: #ffffff;
+  border-radius: .35em;
+  border: 2px solid #bbb;
+  padding: 4px;
 }
 
 .input > div:last-child {

@@ -18,7 +18,7 @@ log = "^0.4"
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = "^1.0"
 wasm-bindgen = "^0.2"
-wasm-bindgen-futures = "0.4"
+wasm-bindgen-futures = "^0.4"
 
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires
@@ -26,6 +26,7 @@ wasm-bindgen-futures = "0.4"
 # code size when deploying.
 console_error_panic_hook = { version = "0.1.6", optional = true }
 wee_alloc = { version = "0.4.2", optional = true }
+js-sys = "^0.3"
 
 [dependencies.mogwai]
 version = "^0.5"

-pub(crate) const MD_EXAMPLE :&str = r"# Ein sehr schöner Titel
+pub(crate) const _MD_EXAMPLE :&str = r"# Ein sehr schöner Titel
 
 ## Ein sinnloser Text
 

 mod data;
 
+use js_sys::JsString;
 use log::Level;
 use mogwai::prelude::*;
-use web_sys::{RequestInit, RequestMode, Request, Response, console};
+use web_sys::{RequestInit, RequestMode, Request, Response};
+use serde::{Deserialize, Serialize};
 use std::panic;
 use wasm_bindgen::prelude::*;
 
-
 #[derive(Clone)]
 enum AppLogic {
     Update,
@@ -23,21 +24,37 @@ fn md_to_html(source: &str) -> String {
     html_output
 }
 
-async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
-                     , tx_view: broadcast::Sender<String>
-                     , mut rx_dom: broadcast::Receiver<Dom> ) {
+#[derive(Debug, Serialize, Deserialize)]
+pub struct MarkdownJson {
+    pub name: String,
+    pub content: String,
+    pub number_of_versions: i32,
+}
+
+pub type MarkdownsJson = Vec<MarkdownJson>;
+
+async fn md_from_db() -> String {
     let window = web_sys::window().unwrap();
     let mut opts = RequestInit::new();
     opts.method("GET").mode(RequestMode::Cors);
-    let request = Request::new_with_str_and_init("/api/v0/users", &opts).unwrap();
+
+    let request = Request::new_with_str_and_init("/api/v0/markdowns", &opts).unwrap();
     request.headers().set("Accept", "application/json").unwrap();
 
     let response = JsFuture::from(window.fetch_with_request(&request))
                  . await.unwrap()
                  . dyn_into::<Response>().unwrap();
-    let data = JsFuture::from(response.json().unwrap()).await.unwrap();
-    console::log_1(&data);
+    let data = String::from( JsFuture::from(response.text().unwrap())
+                           . await.unwrap()
+                           . dyn_into::<JsString>().unwrap() );
+    let data :MarkdownsJson = serde_json::from_str(data.as_str()).unwrap();
 
+    String::from(&data[0].content)
+}
+
+async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
+                     , tx_view: broadcast::Sender<String>
+                     , mut rx_dom: broadcast::Receiver<Dom> ) {
     let dom = rx_dom.next().await.unwrap();
     let mut show_edit = false;
 
@@ -84,8 +101,10 @@ async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
 fn editor_view( tx_logic: broadcast::Sender<AppLogic>
               , rx_view: broadcast::Receiver<String>
               , tx_dom: broadcast::Sender<Dom>
+              , init_data: &str
 ) -> ViewBuilder<Dom> {
     let ns = "http://www.w3.org/2000/svg";
+
     builder! {
         <div class="input"
              style:width="33%"
@@ -94,7 +113,7 @@ fn editor_view( tx_logic: broadcast::Sender<AppLogic>
             <div contenteditable="true"
                  style:cursor="text"
                  style:display=("none", rx_view)>
-                <pre>{data::MD_EXAMPLE}</pre>
+                <pre>{init_data}</pre>
             </div>
             <div>
                 <button on:click=tx_logic . sink()
@@ -118,14 +137,16 @@ fn editor_view( tx_logic: broadcast::Sender<AppLogic>
 }
 
 #[wasm_bindgen(start)]
-pub fn main() -> Result<(), JsValue> {
+pub async fn main() -> Result<(), JsValue> {
     panic::set_hook(Box::new(console_error_panic_hook::hook));
     console_log::init_with_level(Level::Trace).unwrap();
 
+    let data = md_from_db().await;
+
     let (tx_dom, rx_dom) = broadcast::bounded(1);
     let (tx_logic, rx_logic) = broadcast::bounded(1);
     let (tx_view, rx_view) = broadcast::bounded(1);
-    let comp = Component::from( editor_view(tx_logic, rx_view, tx_dom) )
+    let comp = Component::from( editor_view(tx_logic, rx_view, tx_dom, data.as_str()) )
              . with_logic( editor_logic(rx_logic, tx_view, rx_dom) );
 
     let page = Component::from(builder! {{comp}});