nyazoom improves!

Cargo.lock

@@ -1241,6 +1241,20 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "leptos_meta"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ab2fcfe2ae8f14a58798007dd90126c60f529f265e5fa0bf816e047b60b753c"
+dependencies = [
+ "cfg-if",
+ "indexmap 2.0.0",
+ "leptos",
+ "tracing",
+ "wasm-bindgen",
+ "web-sys",
+]
+
 [[package]]
 name = "leptos_reactive"
 version = "0.4.6"
@@ -1524,6 +1538,7 @@ name = "nyazoom"
 version = "0.1.0"
 dependencies = [
  "async-bincode",
+ "async-trait",
  "async_zip",
  "axum",
  "bincode",
@@ -1531,6 +1546,7 @@ dependencies = [
  "futures",
  "headers",
  "leptos",
+ "leptos_meta",
  "leptos_router",
  "rand",
  "reqwest",

Cargo.toml

@@ -8,6 +8,7 @@ edition = "2021"
 
 [dependencies]
 async-bincode = { version = "0.7.0", features = ["tokio"] }
+async-trait = "0.1.72"
 async_zip = { version = "0.0.13", features = ["deflate", "tokio", "tokio-fs", "async-compression"] }
 axum = { version = "0.6.12", features = ["multipart", "http2", "headers", "macros", "original-uri"] }
 bincode = "1.3.3"
@@ -15,6 +16,7 @@ chrono = { version = "0.4.24", features = ["serde"] }
 futures = "0.3.28"
 headers = "0.3.8"
 leptos = { version = "0.4.6", features = ["ssr", "nightly", "tracing", "default-tls"] }
+leptos_meta = { version = "0.4.6", features = ["ssr"] }
 leptos_router = { version = "0.4.6", features = ["ssr"] }
 rand = { version = "0.8.5", features = ["small_rng"] }
 reqwest = { version = "0.11.18", features = ["json", "native-tls", "blocking"] }

dist/css/link.css

@@ -16,6 +16,7 @@ body {
   padding: 1.5em;
   border-radius: 1em;
   border: 1px solid #25283d;
+  list-style: none;
 }
 
 .return-button {

dist/css/main.css

@@ -25,6 +25,7 @@ body {
   justify-content: center;
 }
 
+
 .cat-img {
   width: 250px;
   height: 250px;

src/main.rs

@@ -6,12 +6,13 @@ use axum::{
     http::{Request, Response, StatusCode},
     middleware::{self, Next},
     response::{Html, IntoResponse, Redirect},
-    routing::{get, post},
+    routing::{delete, get, post},
     Json, Router, TypedHeader,
 };
 
 use futures::TryStreamExt;
 
+use headers::HeaderMap;
 use leptos::IntoView;
 use nyazoom_headers::ForwardedFor;
 
@@ -36,7 +37,8 @@ mod views;
 
 use state::{AppState, UploadRecord};
 
-use crate::views::{DownloadLinkPage, LinkView, Welcome};
+use crate::state::AsyncRemoveRecord;
+use crate::views::{DownloadLinkPage, HtmxPage, LinkView, Welcome};
 
 pub mod error {
     use std::io::{Error, ErrorKind};
@@ -74,10 +76,8 @@ async fn main() -> io::Result<()> {
 
                 for (key, record) in records.clone().into_iter() {
                     if !record.can_be_downloaded() {
-                        tracing::info!("{:?} should be culled", record);
-                        let _ = tokio::fs::remove_file(&record.file).await;
-                        records.remove(key.as_str());
-                        cache::write_to_cache(&records).await.unwrap();
+                        tracing::info!("culling: {:?}", record);
+                        records.remove_record(&key).await.unwrap();
                     }
                 }
             }
@@ -92,6 +92,8 @@ async fn main() -> io::Result<()> {
         .route("/records/links", get(records_links))
         .route("/download/:id", get(download))
         .route("/link/:id", get(link))
+        .route("/link/:id", delete(link_delete))
+        .route("/link/:id/remaining", get(remaining))
         .layer(DefaultBodyLimit::disable())
         .layer(RequestBodyLimitLayer::new(
             10 * 1024 * 1024 * 1024, // 10GiB
@@ -112,6 +114,24 @@ async fn main() -> io::Result<()> {
     Ok(())
 }
 
+async fn remaining(
+    State(state): State<AppState>,
+    axum::extract::Path(id): axum::extract::Path<String>,
+) -> impl IntoResponse {
+    let records = state.records.lock().await;
+    if let Some(record) = records.get(&id) {
+        let downloads_remaining = record.downloads_remaining();
+        let plural = if downloads_remaining > 1 { "s" } else { "" };
+        let out = format!(
+            "You have {} download{} remaining!",
+            downloads_remaining, plural
+        );
+        Html(out)
+    } else {
+        Html("?".to_string())
+    }
+}
+
 async fn welcome() -> impl IntoResponse {
     let cat_fact = views::get_cat_fact().await;
     Html(leptos::ssr::render_to_string(move |cx| {
@@ -123,25 +143,39 @@ async fn records(State(state): State<AppState>) -> impl IntoResponse {
     Json(state.records.lock().await.clone())
 }
 
+// This function is to remain ugly until that time in which I properly hide
+// this behind some kind of authentication
 async fn records_links(State(state): State<AppState>) -> impl IntoResponse {
     let records = state.records.lock().await.clone();
     Html(leptos::ssr::render_to_string(move |cx| {
         leptos::view! { cx,
+            <HtmxPage>
+                <div class="form-wrapper">
+                    <div class="column-container">
                         <ul>
-                {records
-                    .iter()
-                    .map(|(key, _)|
-                        leptos::view! { cx, <li><a href="/link/{key}">{key}</a></li> })
+                            {records.keys().map(|key| leptos::view! { cx,
+                                        <li class="link-wrapper">
+                                            <a href="/link/{key}">{key}</a>
+                                            <button style="margin-left: 1em;"
+                                                hx-target="closest .link-wrapper"
+                                                hx-swap="outerHTML"
+                                                hx-delete="/link/{key}">X</button>
+                                        </li>
+                                    })
                                 .collect::<Vec<_>>()}
                         </ul>
+                    </div>
+                </div>
+            </HtmxPage>
         }
     }))
 }
 
 async fn link(
     axum::extract::Path(id): axum::extract::Path<String>,
-    State(state): State<AppState>,
+    State(mut state): State<AppState>,
 ) -> Result<Html<String>, Redirect> {
+    {
         let mut records = state.records.lock().await;
 
         if let Some(record) = records.get_mut(&id) {
@@ -152,16 +186,28 @@ async fn link(
                         leptos::view! { cx, <DownloadLinkPage id=id record=record /> }
                     }
                 })));
-        } else {
-            let _ = tokio::fs::remove_file(&record.file).await;
-            records.remove(&id);
-            cache::write_to_cache(&records).await.unwrap();
+            }
         }
     }
 
+    // TODO: This....
+    state.remove_record(&id).await.unwrap();
+
     Err(Redirect::to(&format!("/404.html")))
 }
 
+async fn link_delete(
+    axum::extract::Path(id): axum::extract::Path<String>,
+    State(mut state): State<AppState>,
+) -> Result<Html<String>, (StatusCode, String)> {
+    state
+        .remove_record(&id)
+        .await
+        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+
+    Ok(Html("".to_string()))
+}
+
 async fn log_source<B>(
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
     forwarded_for: Option<TypedHeader<ForwardedFor>>,
@@ -245,9 +291,20 @@ async fn upload_to_zip(
 
 async fn download(
     axum::extract::Path(id): axum::extract::Path<String>,
-    State(state): State<AppState>,
+    headers: HeaderMap,
+    State(mut state): State<AppState>,
 ) -> Result<axum::response::Response, (StatusCode, String)> {
+    {
         let mut records = state.records.lock().await;
+        tracing::info!("{headers:?}");
+        if headers.get("hx-request").is_some() {
+            return Ok(axum::http::Response::builder()
+                .header("HX-Redirect", format!("/download/{id}"))
+                .status(204)
+                .body("".to_owned())
+                .unwrap()
+                .into_response());
+        }
 
         if let Some(record) = records.get_mut(&id) {
             if record.can_be_downloaded() {
@@ -255,17 +312,17 @@ async fn download(
 
                 let file = tokio::fs::File::open(&record.file).await.unwrap();
 
-            return Ok(axum::http::Response::builder()
+                return Ok(axum::response::Response::builder()
                     .header("Content-Type", "application/zip")
                     .body(StreamBody::new(ReaderStream::new(file)))
                     .unwrap()
                     .into_response());
-        } else {
-            let _ = tokio::fs::remove_file(&record.file).await;
-            records.remove(&id);
-            cache::write_to_cache(&records).await.unwrap();
+            }
         }
     }
 
+    // TODO: This....
+    state.remove_record(&id).await.unwrap();
+
     Ok(Redirect::to("/404.html").into_response())
 }

src/state.rs

@@ -4,10 +4,13 @@ use std::{
     sync::Arc,
 };
 
+use async_trait::async_trait;
 use chrono::{DateTime, Duration, Utc};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;
 
+use crate::cache;
+
 #[allow(dead_code)]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct UploadRecord {
@@ -30,6 +33,10 @@ impl UploadRecord {
 
         dur_since_upload < Duration::days(3) && self.downloads < self.max_downloads
     }
+
+    pub fn downloads_remaining(&self) -> u8 {
+        self.max_downloads - self.downloads
+    }
 }
 
 impl Default for UploadRecord {
@@ -55,3 +62,36 @@ impl AppState {
         }
     }
 }
+
+#[async_trait]
+pub trait AsyncRemoveRecord {
+    async fn remove_record(&mut self, id: &String) -> Result<(), std::io::Error>;
+}
+
+#[async_trait]
+impl AsyncRemoveRecord for AppState {
+    async fn remove_record(&mut self, id: &String) -> Result<(), std::io::Error> {
+        let mut records = self.records.lock().await;
+
+        if let Some(record) = records.get_mut(id) {
+            tokio::fs::remove_file(&record.file).await?;
+            records.remove(id);
+            cache::write_to_cache(&records).await?;
+        }
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl AsyncRemoveRecord for HashMap<String, UploadRecord> {
+    async fn remove_record(&mut self, id: &String) -> Result<(), std::io::Error> {
+        if let Some(record) = self.get_mut(id) {
+            tokio::fs::remove_file(&record.file).await?;
+            self.remove(id);
+            cache::write_to_cache(&self).await?;
+        }
+
+        Ok(())
+    }
+}

src/views.rs

@@ -1,5 +1,5 @@
 use futures::TryFutureExt;
-use leptos::{component, view, Children, IntoAttribute, IntoView, Scope};
+use leptos::{component, view, Children, IntoView, Scope};
 use serde::Deserialize;
 
 use crate::state::UploadRecord;
@@ -91,11 +91,11 @@ pub fn LinkView(cx: Scope, id: String, record: UploadRecord) -> impl IntoView {
         cx,
         <div class="column-container">
             <div class="link-wrapper">
-                <a id="link" href=format!("/download/{id}")>Download Now!</a>
+                <a id="link" hx-get="/download/{id}" href="/download/{id}">Download Now!</a>
             </div>
 
-            <div class="link-wrapper">
-                You have {record.max_downloads - record.downloads} download{plural} remaining!
+            <div class="link-wrapper" hx-get="/link/{id}/remaining" hx-trigger="click from:#link delay:0.2s, every 10s" >
+                You have {record.downloads_remaining()} download{plural} remaining!
             </div>
             <button class="return-button" onclick="clipboard()">Copy to Clipboard</button>