work

src/app.rs

@@ -1,5 +1,5 @@
 use axum::{
-    extract::{Path, State},
+    extract::{DefaultBodyLimit, Path, State},
     http::{header, HeaderValue, StatusCode},
     response::{Html, IntoResponse, Response},
     routing::{get, post},
@@ -9,17 +9,23 @@ use tower_http::{services::ServeDir, trace::TraceLayer};
 
 use crate::{api, db, state::SharedState, websocket};
 
-pub fn router(state: SharedState, static_dir: &str) -> Router {
+pub fn router(state: SharedState, static_dir: &str, upload_max_size_bytes: usize) -> Router {
     Router::new()
         .route("/", get(home))
         .route("/p/{slug}", get(pad))
+        .route("/s/{token}", get(public_page))
         .route("/w/{workspace_slug}", get(workspace))
         .route("/w/{workspace_slug}/n/{note_slug}", get(note))
         .route("/health", get(health))
+        .route("/f/{token}/{filename}", get(api::download_file))
+        .route("/files/{directory}/{filename}", get(api::download_legacy_file))
+        .route("/api/public/{token}", get(api::public_page))
         .route("/api/pads", post(api::create_pad))
         .route("/api/pads/{slug}", get(api::pad_info))
         .route("/api/pads/{slug}/history", post(api::pad_history))
+        .route("/api/pads/{slug}/publish", post(api::publish_pad_page))
         .route("/api/pads/{slug}/restore", post(api::pad_restore))
+        .route("/api/pads/{slug}/files", post(api::upload_pad_file))
         .route("/api/workspaces", post(api::create_workspace))
         .route("/api/workspaces/{workspace_slug}", get(api::workspace_info))
         .route("/api/workspaces/{workspace_slug}/open", post(api::open_workspace))
@@ -28,6 +34,10 @@ pub fn router(state: SharedState, static_dir: &str) -> Router {
             "/api/workspaces/{workspace_slug}/notes/{note_slug}",
             get(api::note_info),
         )
+        .route(
+            "/api/workspaces/{workspace_slug}/notes/{note_slug}/publish",
+            post(api::publish_note_page),
+        )
         .route(
             "/api/workspaces/{workspace_slug}/notes/{note_slug}/history",
             post(api::history),
@@ -36,6 +46,10 @@ pub fn router(state: SharedState, static_dir: &str) -> Router {
             "/api/workspaces/{workspace_slug}/notes/{note_slug}/restore",
             post(api::restore),
         )
+        .route(
+            "/api/workspaces/{workspace_slug}/notes/{note_slug}/files",
+            post(api::upload_note_file),
+        )
         .route("/ws/p/{slug}", get(websocket::upgrade_pad))
         .route(
             "/ws/{workspace_slug}/{note_slug}",
@@ -43,6 +57,7 @@ pub fn router(state: SharedState, static_dir: &str) -> Router {
         )
         .nest_service("/assets", ServeDir::new(static_dir))
         .fallback(not_found)
+        .layer(DefaultBodyLimit::max(upload_max_size_bytes.saturating_add(1024 * 1024)))
         .layer(TraceLayer::new_for_http())
         .with_state(state)
 }
@@ -64,10 +79,10 @@ async fn pad(
         Ok(None) => error_response(
             StatusCode::NOT_FOUND,
             "404",
-            "Nie znaleziono notatki",
-            "Ta notatka nie istnieje albo została usunięta.",
+            "Note not found",
+            "This note does not exist or has been deleted.",
             "/",
-            "Strona główna",
+            "Home page",
             &state.asset_version,
         ),
         Err(error) => {
@@ -77,6 +92,28 @@ async fn pad(
     }
 }
 
+async fn public_page(
+    State(state): State<SharedState>,
+    Path(token): Path<String>,
+) -> Response {
+    match db::find_published_page(&state.db, &token).await {
+        Ok(Some(_)) => versioned_html(include_str!("../static/public.html"), &state.asset_version),
+        Ok(None) => error_response(
+            StatusCode::NOT_FOUND,
+            "404",
+            "Published page not found",
+            "The link is invalid or the published page has been removed.",
+            "/",
+            "Home page",
+            &state.asset_version,
+        ),
+        Err(error) => {
+            tracing::error!(%error, %token, "failed to load published page");
+            internal_error(&state.asset_version)
+        }
+    }
+}
+
 async fn workspace(
     State(state): State<SharedState>,
     Path(workspace_slug): Path<String>,
@@ -89,10 +126,10 @@ async fn workspace(
         Ok(None) => error_response(
             StatusCode::NOT_FOUND,
             "404",
-            "Nie znaleziono workspace",
-            "Ten workspace nie istnieje albo został usunięty.",
+            "Workspace not found",
+            "This workspace does not exist or has been deleted.",
             "/",
-            "Strona główna",
+            "Home page",
             &state.asset_version,
         ),
         Err(error) => {
@@ -112,10 +149,10 @@ async fn note(
             return error_response(
                 StatusCode::NOT_FOUND,
                 "404",
-                "Nie znaleziono workspace",
-                "Workspace tej notatki nie istnieje albo został usunięty.",
+                "Workspace not found",
+                "The workspace for this note does not exist or has been deleted.",
                 "/",
-                "Strona główna",
+                "Home page",
                 &state.asset_version,
             );
         }
@@ -130,10 +167,10 @@ async fn note(
         Ok(None) => error_response(
             StatusCode::NOT_FOUND,
             "404",
-            "Nie znaleziono notatki",
-            "Ta notatka nie istnieje albo została usunięta.",
+            "Note not found",
+            "This note does not exist or has been deleted.",
             &format!("/w/{workspace_slug}"),
-            "Wróć do workspace",
+            "Back do workspace",
             &state.asset_version,
         ),
         Err(error) => {
@@ -147,10 +184,10 @@ async fn not_found(State(state): State<SharedState>) -> Response {
     error_response(
         StatusCode::NOT_FOUND,
         "404",
-        "Nie znaleziono strony",
-        "Sprawdź adres albo wróć na stronę główną.",
+        "Page not found",
+        "Check the address or return to the home page.",
         "/",
-        "Strona główna",
+        "Home page",
         &state.asset_version,
     )
 }
@@ -159,10 +196,10 @@ fn internal_error(asset_version: &str) -> Response {
     error_response(
         StatusCode::INTERNAL_SERVER_ERROR,
         "500",
-        "Błąd serwera",
-        "Nie udało się wczytać strony. Spróbuj ponownie za chwilę.",
+        "Server error",
+        "The page could not be loaded. Please try again shortly.",
         "/",
-        "Strona główna",
+        "Home page",
         asset_version,
     )
 }
@@ -199,7 +236,7 @@ fn versioned_html(template: &str, asset_version: &str) -> Response {
 fn no_store(response: &mut Response) {
     response.headers_mut().insert(
         header::CACHE_CONTROL,
-        HeaderValue::from_static("no-cache, no-store, must-revalidate"),
+        HeaderValue::from_static("private, no-store"),
     );
 }