Client code cleanup and refactoring

+use std::fmt::Display;
+
+use artshop_common::types::MarkdownJson;
+
+use super::super::error::*;
+use super::super::client::Client;
+
+#[derive(Debug, Clone)]
+pub struct Markdown {
+    client: Client,
+    pub json: MarkdownJson,
+}
+
+impl Markdown {
+    pub(crate) async fn new(name :&str) -> Result<Markdown> {
+        let client = Client::new()?;
+        let api_uri = format!("/api/v0/markdowns/{}", name);
+        let (response, data) = client.get(&api_uri).await?;
+
+        match response.status() {
+            200 => Ok(Self { client
+                           , json: serde_json::from_str(data.as_str())? }),
+            status => Err(Self::status_error(status)),
+        }
+    }
+
+    pub(crate) async fn read( &mut self
+                            , patch :Option<i32>
+                            ) -> Result<&Markdown>
+    {
+        let api_uri = match patch {
+            Some(i) => format!( "/api/v0/markdowns/{}?patch={}"
+                              , self.json.name, i ),
+            None    => format!("/api/v0/markdowns/{}", self.json.name),
+        };
+        let (response, data) = self.client.get(&api_uri).await?;
+
+        match response.status() {
+            200 => {
+                self.json = serde_json::from_str(data.as_str())?;
+                Ok(self)
+            },
+            status => Err(Self::status_error(status)),
+        }
+    }
+
+    pub(crate) async fn save(&self) -> Result<&Markdown> {
+        let url = format!("/api/v0/markdowns/{}", self.json.name);
+        let data = serde_json::to_string(&self.json)?;
+
+        let response = self.client.put(url.as_str(), data.as_str()).await?;
+
+        match response.status() {
+            200 => Ok(self),
+            status => Err(Self::status_error(status)),
+        }
+    }
+
+    pub(crate) fn _to_html_string(&self) -> String {
+        use pulldown_cmark::{Parser, Options, html};
+
+        let mut html_out = String::new();
+        let parser = Parser::new_ext(&self.json.content, Options::all());
+
+        html::push_html(&mut html_out, parser);
+        html_out
+    }
+
+
+    fn status_error<I: Display>(status :I) -> Error {
+        let err_str = format!("Invalid response status: {}", status);
+        Error::from(err_str.as_str())
+    }
+}

+pub(crate) mod markdown;

+use js_sys::JsString;
+use mogwai::prelude::*;
+use wasm_bindgen::prelude::*;
+use web_sys::{Window, window, Response, Request, RequestInit, RequestMode};
+use super::error::*;
+
+use std::result::Result as StdResult;
+
+#[derive(Debug, Clone)]
+pub(crate) struct Client {
+    window :Window,
+}
+
+type ReqGetter = fn(&str, &RequestInit) -> StdResult<Request, JsValue>;
+
+const REQUEST :ReqGetter = Request::new_with_str_and_init;
+
+impl Client {
+    pub fn new() -> Result<Self> {
+        const WINDOW_ERROR :&str = "Unable to get window instance";
+
+        Ok(Self { window: window()
+                        . ok_or(Error::from(WINDOW_ERROR))? })
+    }
+
+    pub async fn get(&self, url :&str) -> Result<(Response, String)> {
+        let mut init = RequestInit::new();
+        let request = REQUEST( &url
+                             , init . method("GET")
+                                    . mode(RequestMode::Cors) )?;
+
+        request . headers()
+                . set("Accept", "application/json")?;
+
+        let response = JsFuture::from( self.window
+                                     . fetch_with_request(&request) )
+                     . await?
+                     . dyn_into::<Response>()?;
+
+        let data = JsFuture::from(response.text()?)
+                 . await?
+                 . dyn_into::<JsString>()?;
+
+        Ok((response, String::from(data)))
+    }
+
+    pub async fn put(&self, url :&str, data :&str) -> Result<Response> {
+        let mut init = RequestInit::new();
+        let request = REQUEST( &url
+                             , init . method("PUT")
+                                    . mode(RequestMode::Cors)
+                                    . body(Some(&data.into())) )?;
+
+        request . headers()
+                . set("Content-Type", "application/json")?;
+
+        let response = JsFuture::from( self.window
+                                     . fetch_with_request(&request))
+                     . await?
+                     . dyn_into::<Response>()?;
+
+        Ok(response)
+    }
+}

+use std::fmt::Display;
+use wasm_bindgen::prelude::*;
+
+type ParentError = Option<Box<dyn std::error::Error>>;
+
+#[derive(Debug)]
+pub(crate) struct Error {
+    source: ParentError,
+    message: String,
+}
+
+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 Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            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<JsValue> for Error {
+    fn from(source: JsValue) -> Self {
+        let source = js_sys::Error::from(source);
+
+        let message = format!("[{}] {}", source.name(), source.message());
+        let source = Error::from(message.as_str());
+
+        Self { source: Some(Box::new(source))
+             , message: String::from("WebSys Error")
+        }
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(source: serde_json::Error) -> Self {
+        Self { source: Some(Box::new(source))
+             , message: String::from("Serde Error")
+        }
+    }
+}

+mod api;
 mod data;
+mod error;
+mod client;
 
-use artshop_common::types::MarkdownJson;
+use api::markdown::Markdown;
 use data::icons::*;
-use js_sys::JsString;
 use log::Level;
 use mogwai::prelude::*;
-use web_sys::{RequestInit, RequestMode, Request, Response};
 use std::panic;
 use wasm_bindgen::prelude::*;
 
@@ -18,69 +19,16 @@ enum AppLogic {
     Discard,
 }
 
-fn md_to_html(source: &str) -> String {
-    use pulldown_cmark::{Parser, Options, html};
-
-    let parser = Parser::new_ext(source, Options::all());
-    let mut html_output = String::new();
-    html::push_html(&mut html_output, parser);
-
-    html_output
-}
-
-async fn md_from_db(patch :Option<i32>) -> MarkdownJson {
-    let window = web_sys::window().unwrap();
-    let mut opts = RequestInit::new();
-    opts.method("GET").mode(RequestMode::Cors);
-
-    let api_uri = match patch {
-        Some(i) => format!("/api/v0/markdowns/md-example?patch={}", i),
-        None    => String::from("/api/v0/markdowns/md-example"),
-    };
-
-    let request = Request::new_with_str_and_init(&api_uri, &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 = String::from( JsFuture::from(response.text().unwrap())
-                           . await.unwrap()
-                           . dyn_into::<JsString>().unwrap()
-                           );
-    let data :MarkdownJson = serde_json::from_str(data.as_str()).unwrap();
-
-    data
-}
-
-async fn md_to_db(md :&MarkdownJson) {
-    let encoded = serde_json::to_string(&md).unwrap();
-
-    let window = web_sys::window().unwrap();
-    let mut opts = RequestInit::new();
-    opts . method("PUT")
-         . mode(RequestMode::Cors)
-         . body(Some(&encoded.into()));
-
-    let url_str = format!("/api/v0/markdowns/{}", md.name);
-    let request = Request::new_with_str_and_init(url_str.as_str(), &opts)
-                . unwrap();
-    request.headers().set("Content-Type", "application/json").unwrap();
-
-    let _response = JsFuture::from(window.fetch_with_request(&request))
-                  . await.unwrap()
-                  . dyn_into::<Response>().unwrap();
-
-    /* do something with the response here.... */
-}
-
 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;
-    let mut md = md_from_db(Some(2)).await;
+    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) =>
@@ -117,14 +65,21 @@ async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
 
     let update = move || {
         match cont_ref {
-            Some((md_cont, view_cont)) =>
-                view_cont.set_inner_html(
-                    md_to_html(md_cont.inner_text().as_str()).as_str() ),
+            Some((_, view_cont)) => {
+                use pulldown_cmark::{Parser, Options, html};
+
+                let mut html_out = String::new();
+                let md = get_md();
+                let parser = Parser::new_ext(&md, Options::all());
+
+                html::push_html(&mut html_out, parser);
+                view_cont.set_inner_html(&html_out)
+            },
             None => (),
         }
     };
 
-    set_md(md.content.as_str());
+    set_md(md.json.content.as_str());
     update();
 
     /* play with katex ==== */
@@ -136,28 +91,28 @@ async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
 
     if let Either::Left(dom_js) = dom.inner_read() {
         dom_js . to_owned()
-            . dyn_into::<Node>().unwrap()
-            . child_nodes().get(1).unwrap()
-            . child_nodes().get(2).unwrap()
-            . dyn_into::<HtmlElement>().unwrap()
-            . set_inner_html(formula1.as_str())
+               . dyn_into::<Node>().unwrap()
+               . child_nodes().get(1).unwrap()
+               . child_nodes().get(2).unwrap()
+               . dyn_into::<HtmlElement>().unwrap()
+               . set_inner_html(formula1.as_str())
     };
 
     if let Either::Left(dom_js) = dom.inner_read() {
         dom_js . to_owned()
-            . dyn_into::<Node>().unwrap()
-            . child_nodes().get(1).unwrap()
-            . child_nodes().get(3).unwrap()
-            . dyn_into::<HtmlElement>().unwrap()
-            . set_inner_html(formula2.as_str())
+               . dyn_into::<Node>().unwrap()
+               . child_nodes().get(1).unwrap()
+               . child_nodes().get(3).unwrap()
+               . dyn_into::<HtmlElement>().unwrap()
+               . set_inner_html(formula2.as_str())
     };
     /* =========== */
 
     while let Some(msg) = rx_logic.next().await {
         match msg {
             AppLogic::Store => {
-                md.content = get_md();
-                md_to_db(&md).await;
+                md.json.content = get_md();
+                md.save().await.unwrap();
             },
             AppLogic::Update => update(),
             AppLogic::Toggle => {
@@ -170,12 +125,12 @@ async fn editor_logic( mut rx_logic: broadcast::Receiver<AppLogic>
                 };
             },
             AppLogic::Discard => {
-                set_md(md.content.as_str());
+                set_md(md.json.content.as_str());
                 update();
             },
-            AppLogic::Select(id) => {
-                md = md_from_db(id).await;
-                set_md(md.content.as_str());
+            AppLogic::Select(_id) => {
+                md.read(None).await.unwrap();
+                set_md(md.json.content.as_str());
                 update();
             },
         }