incomplete image selector

@@ -8,27 +8,23 @@ pub enum Either<L, R> {
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MarkdownJson {
-    pub name: String,
-    pub content: String,
-    pub number_of_versions: i32,
-    pub date_created: String,
-    pub date_updated: String,
+    pub name               :String,
+    pub content            :String,
+    pub number_of_versions :i32,
+    pub date_created       :String,
+    pub date_updated       :String,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MarkdownDiffJson {
-    pub id: i32,
-    pub date_created: String,
+    pub id           :i32,
+    pub date_created :String,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ImageJson {
-    pub upload_uuid  :Option<Vec<u8>>,
-    pub uuid         :Option<Vec<u8>>,
-    pub size         :i32,
-    pub dim_x        :Option<i32>,
-    pub dim_y        :Option<i32>,
-    pub mime_type    :String,
+    pub id           :i32,
+    pub uuid         :Vec<u8>,
     pub date_created :String,
     pub date_updated :String
 }

@@ -57,6 +57,9 @@ async fn main() -> std::io::Result<()> {
                             . service( web::resource("/upload")
                                      . route(web::post().to(upload))
                                      )
+                            . service( web::resource("/images")
+                                     . route(web::get().to(get_images))
+                                     )
                             . service( web::resource("/images/{id}")
                                      . route(web::get().to(get_image))
                                      )

@@ -240,6 +240,13 @@ pub(crate) fn finalize( pool :Arc<Pool>
     }
 }
 
+pub(crate) fn get_images(pool: Arc<Pool>) -> Result<Vec<Image>>
+{
+    use crate::schema::images::dsl::*;
+    let db_connection = pool.get()?;
+    Ok(images.load::<Image>(&db_connection)?)
+}
+
 pub(crate) fn get_image( pool  :Arc<Pool>
                        , ident :i32 ) -> Result<Image>
 {

@@ -2,7 +2,7 @@ use std::fmt::Display;
 
 use crate::{models::image, AppData, error::Error};
 
-use actix_web::{Error as ActixError, web, http::StatusCode};
+use actix_web::{Error as ActixError, web, HttpResponse, http::StatusCode};
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 
@@ -35,6 +35,17 @@ impl Display for Size {
     }
 }
 
+pub async fn get_images(app_data: web::Data<AppData>)
+    -> Result<HttpResponse, ActixError>
+{
+    let pool = app_data.database_pool.clone();
+
+    Ok(web::block(move || image::get_images(pool))
+       . await
+       . map(|images| HttpResponse::Ok().json(images))
+       . map_err(|_| HttpResponse::InternalServerError())?)
+}
+
 pub async fn get_image( app_data: web::Data<AppData>
                       , ident: web::Path<i32>
                       , size: web::Query<SizeQuery>

@@ -111,17 +111,17 @@ async fn save_resized( original :&DynamicImage
         Err(e) if e.kind() == ErrorKind::NotFound =>
             spawn_blocking(move || -> Result<(), Error> {
                 let mut scaled = original.resize(width, height, Lanczos3);
-                overlay(&mut scaled, CONFIG.copyright_image(), 0_u32, 0_u32);
 
                 if let Size::Thumbnail = size {
-                    scaled.save_with_format(&path, Jpeg)?;
                 } else {
-                    let stegonography = CONFIG.copyright_steganography().as_bytes();
-                    let encoder = Encoder::new(stegonography, scaled);
-                    let scaled = encoder.encode_alpha();
-                    scaled.save_with_format(&path, Jpeg)?;
+                    overlay(&mut scaled, CONFIG.copyright_image(), 0_u32, 0_u32);
                 }
 
+                let stegonography = CONFIG.copyright_steganography().as_bytes();
+                let encoder = Encoder::new(stegonography, scaled);
+                let scaled = encoder.encode_alpha();
+                scaled.save_with_format(&path, Jpeg)?;
+
                 let exiv = Metadata::new_from_path(&path)?;
                 exiv.set_tag_string("Exif.Image.Copyright", CONFIG.copyright_exiv())?;
                 exiv.save_to_file(&path)?;

-.upload {
+.application > div {
 	float: left;
-	width: 400px;
+	width: 30%;
+}
+
+.selector {
+	padding: 1em;
+	border-radius: .5em;
+	border: 1px solid #ddd;
+	background: #f7f7f7;
+}
+
+.selector img {
+	max-width: 75px;
+	max-height: 75px;
+	width: auto;
+	height: auto;
+	vertical-align: middle;
+}
+
+.selector > ul {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 5px;
+	justify-content: space-between;
+	align-items: center;
+	max-height: 15em;
+	width: calc(100% - 15px);
+	overflow-y: auto;
+	overflow-x: auto;
+	background: #ffffff;
+	border-radius: .35em;
+	border: 2px solid #bbb;
+	cursor: default;
+	padding-left: 5px;
+	padding-right: 5px;
+	margin-top: 0;
+	margin-bottom: 0;
+}
+
+.selector > ul > li {
+	display: unset;
+	border: 1px solid black;
+	width: fit-content;
+	height: fit-content;
+	margin-bottom: .15em;
+}
+
+.selector > ul > li:last-child {
+	margin-bottom: 0;
+}
+
+.upload {
 	padding: 1em;
 	border-radius: .5em;
 	border: 1px solid #ddd;
@@ -55,7 +105,6 @@
 }
 
 .markdown {
-	float: left;
 	padding: 1em;
 	border-radius: .5em;
 	border: 1px solid #ddd;
@@ -76,7 +125,6 @@
 
 .markdown > div:first-child {
 	position: fixed;
-	width: inherit;
 	z-index: 10;
 }
 

+use std::fmt::Display;
+
+use artshop_common::types::ImageJson;
+
+use super::super::error::*;
+use super::super::client::Client;
+
+#[derive(Debug, Clone)]
+pub struct Image {
+    pub json: ImageJson,
+}
+
+pub(crate) async fn images() -> Result<Vec<Image>> {
+    let client = Client::new()?;
+    let (response, data) = client.get("/api/v0/images").await?;
+
+    match response.status() {
+        200 => Ok ( serde_json::from_str(data.as_str())
+                  . map(|images :Vec<ImageJson>| {
+                      images.into_iter().map(|json| Image { json }).collect()
+                  })? ),
+        status => Err(status_error(status)),
+    }
+}
+
+fn status_error<I: Display>(status :I) -> Error {
+    let err_str = format!("Invalid response status: {}", status);
+    Error::from(err_str.as_str())
+}
+
+// impl Image {
+// }

+pub(crate) mod image;
 pub(crate) mod markdown;
 pub(crate) mod upload;

+use mogwai::prelude::*;
+
+use crate::api::image::{Image, images};
+
+use super::{PatchSender, view::image_preview_view};
+
+pub(super) async fn image_preview_logic() {
+}
+
+pub(super) async fn selector_logic( mut rx_dom  :broadcast::Receiver<Dom>
+                                  , tx_previews :PatchSender) {
+    let mut previews :ListPatchModel<Image> = ListPatchModel::new();
+
+    mogwai::spawn(previews.stream().for_each(move |patch| {
+        let patch :ListPatch<ViewBuilder<Dom>> = patch.map(|i| {
+            let view = image_preview_view(
+                String::from(format!( "/api/v0/images/{}?size=thumbnail"
+                                    , i.json.id )));
+            let logic = image_preview_logic();
+
+            Component::from(view).with_logic(logic).into()
+        });
+        let tx_previews = tx_previews.clone();
+
+        async move {
+            tx_previews.send(patch).await.unwrap();
+        }
+    }));
+
+    if let Some(_) = rx_dom.next().await {
+        for image in images().await.unwrap().into_iter() {
+            previews.list_patch_push(image);
+        }
+    }
+}

+pub(crate) mod logic;
+mod view;
+
+use mogwai::prelude::*;
+
+use self::{view::selector_view, logic::selector_logic};
+
+type PatchSender = mpmc::Sender<ListPatch<ViewBuilder<Dom>>>;
+type PatchReceiver = mpmc::Receiver<ListPatch<ViewBuilder<Dom>>>;
+
+pub(crate) async fn new() -> Component<Dom> {
+    let (tx_previews, rx_previews) = mpmc::bounded(1);
+    let (tx_dom, rx_dom) = broadcast::bounded(1);
+
+    let view = selector_view(tx_dom, rx_previews);
+    let logic = selector_logic(rx_dom, tx_previews);
+
+    Component::from(view).with_logic(logic)
+}

+use mogwai::prelude::*;
+
+use crate::component::imageselector::PatchReceiver;
+
+pub(super) fn image_preview_view(image_url :String) -> ViewBuilder<Dom> {
+    builder! {
+        <li><img src=image_url/></li>
+    }
+}
+
+pub(super) fn selector_view( tx_dom :broadcast::Sender<Dom>
+                           , rx_previews :PatchReceiver) -> ViewBuilder<Dom> {
+    let post_build = move |dom: &mut Dom| {
+        tx_dom.try_broadcast(dom.clone()).unwrap();
+    };
+
+    builder! {
+        <div class="selector">
+            <ul patch:children=rx_previews
+                post:build=post_build>
+            </ul>
+        </div>
+    }
+}

@@ -58,7 +58,6 @@ pub(super) fn markdown_view( tx_logic: broadcast::Sender<MarkdownLogic>
 
     builder! {
         <div class="markdown"
-             style:width="33%"
              post:build=move |_: &mut Dom| {
                  tx_logic.try_broadcast(MarkdownLogic::Choose(None)).unwrap();
              }

+pub(crate) mod imageselector;
 pub(crate) mod markdown;
 pub(crate) mod upload;

@@ -29,11 +29,13 @@ pub async fn main() -> Result<(), JsValue> {
 
     let md = markdown::new().await;
     let comp = upload::new().await;
+    let selector = imageselector::new().await;
 
     let page = Component::from(builder! {
-        <div>
+        <div class="application">
             {comp}
             {md}
+            {selector}
         </div>
     });
     page.build()?.run()