Make all patches choosable

@@ -14,3 +14,9 @@ pub struct MarkdownJson {
     pub date_created: String,
     pub date_updated: String,
 }
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct MarkdownDiffJson {
+    pub id: i32,
+    pub date_created: String,
+}

-use std::error::Error as StdError;
-use std::fmt;
+use std::{fmt::Display, pin::Pin};
 
 use diesel::result;
+use diffy::ParsePatchError;
 use r2d2;
 
+type ParentError = Option<Pin<Box<dyn std::error::Error>>>;
+
 #[derive(Debug)]
-pub(crate) enum Error {
-    DieselResult(result::Error),
-    DieselR2d2(r2d2::Error),
+pub(crate) struct Error {
+    source: ParentError,
+    message: String,
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Error::DieselR2d2(r)   => write!(f, "{}", r),
-            Error::DieselResult(r) => write!(f, "{}", r),
-        }
+unsafe impl Send for Error {}
+
+pub(crate) type Result<T> = std::result::Result<T, Error>;
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        self.source.as_deref()
     }
 }
 
-impl StdError for Error {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Error::DieselR2d2(r)   => Some(r),
-            Error::DieselResult(r) => Some(r),
+            Error { source: Some(source), message } =>
+                write!(f, "{}: {}", message, source),
+            Error { source: None, message } => write!(f, "{}", message),
         }
     }
 }
 
+impl From<&str> for Error {
+    fn from(message: &str) -> Self {
+        Self { source: None, message: String::from(message) }
+    }
+}
+
 impl From<result::Error> for Error {
-    fn from(error: result::Error) -> Self {
-        Error::DieselResult(error)
+    fn from(source: result::Error) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("Diesel Result Error")
+        }
     }
 }
 
 impl From<r2d2::Error> for Error {
-    fn from(error: r2d2::Error) -> Self {
-        Error::DieselR2d2(error)
+    fn from(source: r2d2::Error) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("Diesel Result Error")
+        }
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(source: std::io::Error) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("IO Error")
+        }
+    }
+}
+
+impl From<std::str::Utf8Error> for Error {
+    fn from(source: std::str::Utf8Error) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("IO Error")
+        }
+    }
+}
+
+impl From<ParsePatchError> for Error {
+    fn from(source: ParsePatchError) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("IO Error")
+        }
     }
 }

@@ -6,7 +6,7 @@ mod models;
 mod routes;
 mod schema;
 
-use crate::routes::markdown::{get_markdowns, update_markdown};
+use crate::routes::markdown::*;
 use crate::routes::other::*;
 use crate::routes::user::*;
 
@@ -40,6 +40,9 @@ async fn main() -> std::io::Result<()> {
                                      . route(web::get().to(get_markdown))
                                      . route(web::put().to(update_markdown))
                                      )
+                            . service( web::resource("/markdowns/{id}/patches")
+                                     . route(web::get().to(get_patches))
+                                     )
                             . service( web::resource("/users")
                                      . route(web::get().to(get_users))
                                      . route(web::put().to(create_user))

 use std::sync::Arc;
 use crate::schema::*;
-use crate::error::Error;
+use crate::error::*;
 use crate::Pool;
+use artshop_common::types::MarkdownDiffJson;
 use artshop_common::types::MarkdownJson;
 use diesel::prelude::*;
 use diesel::{
@@ -75,6 +76,25 @@ impl<'a> From<&'a MarkdownJson> for MarkdownChange<'a> {
     }
 }
 
+impl From<&MarkdownDiff> for MarkdownDiffJson {
+    fn from(md_diff: &MarkdownDiff) -> Self {
+        Self { id: md_diff.diff_id
+             , date_created: md_diff.date_created.to_owned()
+        }
+    }
+}
+
+impl MarkdownDiff {
+    pub(crate) fn get_diff_as_string(&self) -> Result<String> {
+        let mut decoder = DeflateDecoder::new(Vec::new());
+
+        decoder.write_all(self.diff.as_ref())?;
+        let decomp = decoder.finish()?;
+
+        Ok(String::from(std::str::from_utf8(decomp.as_ref())?))
+    }
+}
+
 pub(crate) enum _Action {
     Created(Markdown),
     Found(Markdown),
@@ -82,7 +102,7 @@ pub(crate) enum _Action {
 
 
 pub(crate) fn _create_markdown( pool: Arc<Pool>
-                             , item: MarkdownJson ) -> Result<_Action, Error> {
+                             , item: MarkdownJson ) -> Result<_Action> {
     use crate::schema::markdowns::dsl::*;
     let db_connection = pool.get()?;
 
@@ -111,7 +131,7 @@ pub(crate) fn _create_markdown( pool: Arc<Pool>
     }
 }
 
-pub(crate) fn get_markdowns(pool: Arc<Pool>) -> Result<Vec<Markdown>, Error>
+pub(crate) fn get_markdowns(pool: Arc<Pool>) -> Result<Vec<Markdown>>
 {
     use crate::schema::markdowns::dsl::*;
     let db_connection = pool.get()?;
@@ -120,10 +140,11 @@ pub(crate) fn get_markdowns(pool: Arc<Pool>) -> Result<Vec<Markdown>, Error>
 
 pub(crate) fn get_markdown( pool:  Arc<Pool>
                           , ident: &str
-                          , patch: Option<i32> ) -> Result<Markdown, Error>
+                          , patch: Option<i32> ) -> Result<Markdown>
 {
     use crate::schema::markdowns::dsl::*;
     use crate::schema::markdown_diffs::dsl::*;
+
     let db_connection = pool.get()?;
 
     let mut markdown = markdowns
@@ -131,17 +152,16 @@ pub(crate) fn get_markdown( pool:  Arc<Pool>
                      . first::<Markdown>(&db_connection)?;
 
     if let Some(patch) = patch {
-        let result = markdown_diffs . filter(markdown_id.eq(markdown.id))
-            . filter(diff_id.ge(patch))
-            . order(diff_id.desc())
-            . load::<MarkdownDiff>(&db_connection)?;
+        let result = markdown_diffs
+                   . filter(markdown_id.eq(markdown.id))
+                   . filter(diff_id.ge(patch))
+                   . order(diff_id.desc())
+                   . load::<MarkdownDiff>(&db_connection)?;
 
-        let mut decoder = DeflateDecoder::new(Vec::new());
         for patch in result {
-            decoder.write_all(patch.diff.as_ref()).unwrap();
-            let decomp = decoder.reset(Vec::new()).unwrap();
-            let decomp = Patch::from_str(
-                std::str::from_utf8(decomp.as_ref()).unwrap()).unwrap();
+            let patch_data = patch.get_diff_as_string()?;
+            let decomp = Patch::from_str(&patch_data)?;
+
             markdown.content = apply(&markdown.content, &decomp).unwrap();
             markdown.date_updated = patch.date_created;
         }
@@ -150,8 +170,27 @@ pub(crate) fn get_markdown( pool:  Arc<Pool>
     Ok(markdown)
 }
 
+pub(crate) fn get_patches( pool: Arc<Pool>
+                         , ident: &str ) -> Result<Vec<MarkdownDiffJson>> {
+    use crate::schema::markdowns::dsl::*;
+    use crate::schema::markdown_diffs::dsl::*;
+
+    let db_connection = pool.get()?;
+
+    let markdown = markdowns
+                 . filter(name.eq(ident))
+                 . first::<Markdown>(&db_connection)?;
+
+    Ok ( markdown_diffs . filter(markdown_id.eq(markdown.id))
+                        . order(diff_id.desc())
+                        . load::<MarkdownDiff>(&db_connection)?
+                        . iter()
+                        . map(|d| MarkdownDiffJson::from(d))
+                        . collect() )
+}
+
 pub(crate) fn _delete_markdown( pool: Arc<Pool>
-                             , ident: i32 ) -> Result<usize, Error>
+                             , ident: i32 ) -> Result<usize>
 {
     use crate::schema::markdowns::dsl::*;
     let db_connection = pool.get()?;
@@ -160,7 +199,7 @@ pub(crate) fn _delete_markdown( pool: Arc<Pool>
 
 pub(crate) fn update_markdown( pool: Arc<Pool>
                              , ident: String
-                             , mut item: MarkdownJson ) -> Result<Markdown, Error>
+                             , mut item: MarkdownJson ) -> Result<Markdown>
 {
     use crate::schema::markdowns::dsl::*;
     use crate::schema::markdown_diffs::dsl::*;

 use std::sync::Arc;
 use crate::schema::*;
-use crate::error::Error;
+use crate::error::*;
 use crate::Pool;
 use diesel::prelude::*;
 use diesel::{
@@ -40,7 +40,7 @@ pub(crate) enum Action {
 
 
 pub(crate) fn create_user( pool: Arc<Pool>
-                         , item: UserJson ) -> Result<Action, Error> {
+                         , item: UserJson ) -> Result<Action> {
     use crate::schema::users::dsl::*;
     let db_connection = pool.get()?;
 
@@ -67,7 +67,7 @@ pub(crate) fn create_user( pool: Arc<Pool>
     }
 }
 
-pub(crate) fn get_users(pool: Arc<Pool>) -> Result<Vec<User>, Error>
+pub(crate) fn get_users(pool: Arc<Pool>) -> Result<Vec<User>>
 {
     use crate::schema::users::dsl::*;
     let db_connection = pool.get()?;
@@ -75,7 +75,7 @@ pub(crate) fn get_users(pool: Arc<Pool>) -> Result<Vec<User>, Error>
 }
 
 pub(crate) fn get_user( pool:  Arc<Pool>
-                      , ident: i32 ) -> Result<User, Error>
+                      , ident: i32 ) -> Result<User>
 {
     use crate::schema::users::dsl::*;
     let db_connection = pool.get()?;
@@ -83,7 +83,7 @@ pub(crate) fn get_user( pool:  Arc<Pool>
 }
 
 pub(crate) fn delete_user( pool: Arc<Pool>
-                         , ident: i32 ) -> Result<usize, Error>
+                         , ident: i32 ) -> Result<usize>
 {
     use crate::schema::users::dsl::*;
     let db_connection = pool.get()?;
@@ -92,7 +92,7 @@ pub(crate) fn delete_user( pool: Arc<Pool>
 
 pub(crate) fn update_user( pool: Arc<Pool>
                          , ident: i32
-                         , item: UserJson ) -> Result<User, Error>
+                         , item: UserJson ) -> Result<User>
 {
     use crate::schema::users::dsl::*;
     let db_connection = pool.get()?;

@@ -37,6 +37,19 @@ pub async fn get_markdown( pool: web::Data<Pool>
       )
 }
 
+pub async fn get_patches( pool: web::Data<Pool>
+                        , name: web::Path<String>
+                        ) -> Result<HttpResponse, Error> {
+    let pool = pool.into_inner();
+    let name = name.into_inner();
+
+    Ok( web::block(move || markdown::get_patches(pool, name.as_str()))
+      . await
+      . map(|patches| HttpResponse::Ok().json(patches))
+      . map_err(|_| HttpResponse::InternalServerError())?
+      )
+}
+
 pub async fn update_markdown( pool: web::Data<Pool>
                             , name: web::Path<String>
                             , item: web::Json<MarkdownJson> )

 use std::fmt::Display;
 
-use artshop_common::types::MarkdownJson;
+use artshop_common::types::{MarkdownJson, MarkdownDiffJson};
 
 use super::super::error::*;
 use super::super::client::Client;
@@ -56,6 +56,16 @@ impl Markdown {
         }
     }
 
+    pub(crate) async fn patches(&self) -> Result<Vec<MarkdownDiffJson>> {
+        let url = format!("/api/v0/markdowns/{}/patches", self.json.name);
+        let (response, data) = self.client.get(url.as_str()).await?;
+
+        match response.status() {
+            200 => Ok(serde_json::from_str(&data)?),
+            status => Err(Self::status_error(status)),
+        }
+    }
+
     pub(crate) fn _to_html_string(&self) -> String {
         use pulldown_cmark::{Parser, Options, html};
 

@@ -15,21 +15,21 @@ enum AppLogic {
     Update,
     Toggle,
     Store,
-    Select(Option<i32>),
+    Select,
+    Choose(Option<i32>),
     Discard,
 }
 
 async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
-                     , tx_view: broadcast::Sender<String>
+                     , tx_logic: broadcast::Sender<AppLogic>
+                     , tx_toggle: broadcast::Sender<bool>
+                     , tx_patches: mpmc::Sender<ListPatch<ViewBuilder<Dom>>>
                      , mut rx_dom: broadcast::Receiver<Dom> )
 {
     let dom = rx_dom.next().await.unwrap();
     let mut show_edit = false;
     let mut md = Markdown::new("md-example").await.unwrap();
 
-    // TODO Only for experiments... remove when ready
-    md.read(Some(2)).await.unwrap();
-
     let container = match dom.inner_read() {
             Either::Left(dom_js) =>
                 Some( ( dom_js
@@ -117,19 +117,38 @@ async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
             AppLogic::Update => update(),
             AppLogic::Toggle => {
                 show_edit = ! show_edit;
-                match show_edit {
-                    true => tx_view . broadcast(String::from("block"))
-                                    . await.unwrap(),
-                    false => tx_view . broadcast(String::from("none"))
-                                     . await.unwrap(),
-                };
+                tx_toggle.broadcast(show_edit).await.unwrap();
             },
             AppLogic::Discard => {
                 set_md(md.json.content.as_str());
                 update();
             },
-            AppLogic::Select(_id) => {
-                md.read(None).await.unwrap();
+            AppLogic::Select => {
+                let patches = md
+                            . patches().await.unwrap()
+                            . into_iter()
+                            . map(|diff| {
+                                let id = Some(diff.id);
+                                let choose_filter = tx_logic
+                                    . sink()
+                                    . contra_map(move |_| AppLogic::Choose(id));
+                                builder! {
+                                    <li><button on:click=choose_filter
+                                                value=format!("{}", diff.id.to_owned())>
+                                    {diff.date_created.to_owned()}
+                                    </button></li>
+                                }});
+                let all = vec![builder! {
+                    <li><button on:click=tx_logic.sink().contra_map(|_| AppLogic::Choose(None))>
+                    "Current"
+                    </button></li>
+                }].into_iter().chain(patches);
+
+                let list_replace = ListPatch::splice(.., all);
+                tx_patches.send(list_replace).await.unwrap();
+            },
+            AppLogic::Choose(id) => {
+                md.read(id).await.unwrap();
                 set_md(md.json.content.as_str());
                 update();
             },
@@ -138,7 +157,8 @@ async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
 }
 
 fn editor_view( tx_logic: broadcast::Sender<AppLogic>
-              , rx_view: broadcast::Receiver<String>
+              , rx_toggle: broadcast::Receiver<bool>
+              , rx_patches: mpmc::Receiver<ListPatch<ViewBuilder<Dom>>>
               , tx_dom: broadcast::Sender<Dom>
               ) -> ViewBuilder<Dom>
 {
@@ -166,11 +186,16 @@ fn editor_view( tx_logic: broadcast::Sender<AppLogic>
                       . contra_map(|_| AppLogic::Toggle);
     let select_filter = tx_logic
                       . sink()
-                      . contra_map(|_e| AppLogic::Select(None));
+                      . contra_map(|_e| AppLogic::Select);
     let discard_filter = tx_logic
                        . sink()
                        . contra_map(|_| AppLogic::Discard);
 
+    let toggle_map = rx_toggle
+                   . map(|t| match t {
+                       true => String::from("block"),
+                       false => String::from("none") });
+
     builder! {
         <div class="input"
              style:width="33%"
@@ -178,12 +203,16 @@ fn editor_view( tx_logic: broadcast::Sender<AppLogic>
              capture:view=tx_dom.sink()>
             <div contenteditable="true"
                  style:cursor="text"
-                 style:display=("none", rx_view)>
+                 style:display=("none", toggle_map)>
                 <pre></pre>
             </div>
             <div>
                 <div>
+                    <div>
                     <button on:click=select_filter>{select_icon()}</button>
+                    <ul patch:children=rx_patches>
+                    </ul>
+                    </div>
                     <button on:click=store_filter>{save_icon()}</button>
                     <button on:click=discard_filter>{discard_icon()}</button>
                     <button on:click=toggle_filter>{edit_icon()}</button>
@@ -203,9 +232,12 @@ pub async fn main() -> Result<(), JsValue> {
 
     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) )
-             . with_logic( editor_logic(rx_logic, tx_view, rx_dom) );
+    let (tx_toggle, rx_toggle) = broadcast::bounded(1);
+    let (tx_patches, rx_patches) = mpmc::bounded(1);
+
+    let view = editor_view(tx_logic.clone(), rx_toggle, rx_patches, tx_dom);
+    let logic = editor_logic(rx_logic, tx_logic, tx_toggle, tx_patches, rx_dom);
+    let comp = Component::from(view).with_logic(logic);
 
     let page = Component::from(builder! {{comp}});
     page.build()?.run()