remove container name to fix reload issue

Author: chaos-dotcom

Cargo.lock

@@ -15,3 +15,4 @@ chrono = { version = "0.4", default-features = false, features = ["std", "clock"
 anyhow = "1.0"
 thiserror = "1.0"
 hrt-shared = { path = "../shared" }
+lopdf = "0.39"

crates/server/Cargo.toml

@@ -4,14 +4,17 @@ use axum::http::{HeaderMap, HeaderValue, StatusCode};
 use axum::response::{IntoResponse, Response};
 use axum::Json;
 use chrono::Utc;
+use lopdf::Document;
 use serde_json::{json, Value};
 
 use hrt_shared::convert::convert_hormone;
 use hrt_shared::types::Hormone;
 
 use crate::storage::{
-    content_type_from_ext, delete_photo, read_json, read_photo, read_yaml, save_photo,
-    write_json_atomic, write_yaml, DATA_FILE_PATH, SETTINGS_FILE_PATH,
+    content_type_from_ext, delete_bloodtest_pdf as delete_bloodtest_pdf_file, delete_photo,
+    read_bloodtest_pdf as read_bloodtest_pdf_file, read_json, read_photo, read_yaml,
+    save_bloodtest_pdf, save_photo, write_json_atomic, write_yaml, DATA_FILE_PATH,
+    SETTINGS_FILE_PATH,
 };
 
 pub async fn get_data() -> Response {
@@ -214,6 +217,111 @@ pub async fn delete_dosage_photo(Path((entry_id, filename)): Path<(String, Strin
     }
 }
 
+pub async fn upload_bloodtest_pdf(mut multipart: Multipart) -> Response {
+    let settings = match read_yaml::<Value>(SETTINGS_FILE_PATH).await {
+        Ok(Some(value)) if value.is_object() => value,
+        _ => json!({}),
+    };
+    let pdf_password = pdf_password_from_settings(&settings);
+
+    let mut files: Vec<(String, Vec<u8>)> = Vec::new();
+    while let Ok(Some(field)) = multipart.next_field().await {
+        let name = field.name().unwrap_or("");
+        if name != "file" && name != "files" && name != "pdf" && name != "pdfs" {
+            continue;
+        }
+        let filename = field.file_name().map(|s| s.to_string());
+        let content_type = field.content_type().map(|s| s.to_string());
+        let bytes = match field.bytes().await {
+            Ok(bytes) => bytes,
+            Err(_) => continue,
+        };
+        if bytes.is_empty() {
+            continue;
+        }
+        let ext = ext_from_name_or_type(filename.as_deref(), content_type.as_deref());
+        if ext != "pdf" {
+            continue;
+        }
+        let stored_name = format!("{}_{}.{}", Utc::now().timestamp_millis(), files.len(), ext);
+        files.push((stored_name, bytes.to_vec()));
+    }
+
+    if files.is_empty() {
+        return json_error("no files", StatusCode::BAD_REQUEST);
+    }
+
+    let mut payload = Vec::new();
+    for (filename, bytes) in files {
+        if save_bloodtest_pdf(&filename, &bytes).await.is_err() {
+            continue;
+        }
+        let extraction = extract_pdf_text(&bytes, pdf_password.as_deref());
+        let (text, extract_error) = match extraction {
+            Ok(text) => {
+                let trimmed = text.trim();
+                if trimmed.is_empty() {
+                    (None, Some("no extractable text found".to_string()))
+                } else {
+                    let capped: String = text.chars().take(120_000).collect();
+                    (Some(capped), None)
+                }
+            }
+            Err(err) => (None, Some(err)),
+        };
+        payload.push(json!({
+            "filename": filename,
+            "text": text,
+            "extractError": extract_error,
+        }));
+    }
+
+    Json(json!({ "files": payload })).into_response()
+}
+
+pub async fn get_bloodtest_pdf(Path(filename): Path<String>) -> Response {
+    if !is_safe_storage_name(&filename) {
+        return Response::builder()
+            .status(StatusCode::NOT_FOUND)
+            .body("Not found".into())
+            .unwrap();
+    }
+
+    let data = match read_bloodtest_pdf_file(&filename).await {
+        Ok(Some(bytes)) => bytes,
+        Ok(None) => {
+            return Response::builder()
+                .status(StatusCode::NOT_FOUND)
+                .body("Not found".into())
+                .unwrap()
+        }
+        Err(_) => {
+            return Response::builder()
+                .status(StatusCode::INTERNAL_SERVER_ERROR)
+                .body("Error".into())
+                .unwrap()
+        }
+    };
+
+    let ext = filename.split('.').last().unwrap_or("");
+    let mut headers = HeaderMap::new();
+    if let Ok(value) = HeaderValue::from_str(content_type_from_ext(ext)) {
+        headers.insert("Content-Type", value);
+    }
+    (StatusCode::OK, headers, data).into_response()
+}
+
+pub async fn delete_bloodtest_pdf(Path(filename): Path<String>) -> Response {
+    if !is_safe_storage_name(&filename) {
+        return json_error("invalid filename", StatusCode::BAD_REQUEST);
+    }
+
+    match delete_bloodtest_pdf_file(&filename).await {
+        Ok(_) => Json(json!({ "success": true })).into_response(),
+        Err(_) => json_error("delete failed", StatusCode::INTERNAL_SERVER_ERROR),
+    }
+}
+
 fn ext_from_name_or_type(name: Option<&str>, content_type: Option<&str>) -> String {
     if let Some(name) = name {
         if let Some(ext) = name.split('.').last() {
@@ -224,6 +332,7 @@ fn ext_from_name_or_type(name: Option<&str>, content_type: Option<&str>) -> Stri
     }
 
     match content_type.unwrap_or("") {
+        "application/pdf" => "pdf".to_string(),
         "image/jpeg" => "jpg".to_string(),
         "image/png" => "png".to_string(),
         "image/webp" => "webp".to_string(),
@@ -232,6 +341,48 @@ fn ext_from_name_or_type(name: Option<&str>, content_type: Option<&str>) -> Stri
     }
 }
 
+fn pdf_password_from_settings(settings: &Value) -> Option<String> {
+    settings
+        .get("pdfPassword")
+        .and_then(|value| value.as_str())
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+fn extract_pdf_text(bytes: &[u8], password: Option<&str>) -> Result<String, String> {
+    let mut document = match password.filter(|value| !value.trim().is_empty()) {
+        Some(password) => Document::load_mem_with_password(bytes, password)
+            .or_else(|_| Document::load_mem(bytes))
+            .map_err(|err| err.to_string())?,
+        None => Document::load_mem(bytes).map_err(|err| err.to_string())?,
+    };
+
+    if document.is_encrypted() && document.encryption_state.is_none() {
+        if let Some(password) = password.filter(|value| !value.trim().is_empty()) {
+            document.decrypt(password).map_err(|err| err.to_string())?;
+        }
+    }
+
+    let pages = document.get_pages();
+    if pages.is_empty() {
+        return Ok(String::new());
+    }
+    let page_numbers: Vec<u32> = pages.keys().cloned().collect();
+    document
+        .extract_text(&page_numbers)
+        .map_err(|err| err.to_string())
+}
+
+fn is_safe_storage_name(value: &str) -> bool {
+    let trimmed = value.trim();
+    if trimmed.is_empty() || trimmed.contains("..") {
+        return false;
+    }
+    trimmed
+        .bytes()
+        .all(|ch| ch.is_ascii_alphanumeric() || ch == b'.' || ch == b'_' || ch == b'-')
+}
+
 fn json_error(message: &str, status: StatusCode) -> Response {
     (status, Json(json!({ "error": message }))).into_response()
 }

crates/server/src/api.rs

@@ -38,6 +38,11 @@ async fn main() {
             "/api/dosage-photo/:entry_id/:filename",
             get(api::get_dosage_photo).delete(api::delete_dosage_photo),
         )
+        .route("/api/bloodtest-pdf", post(api::upload_bloodtest_pdf))
+        .route(
+            "/api/bloodtest-pdf/:filename",
+            get(api::get_bloodtest_pdf).delete(api::delete_bloodtest_pdf),
+        )
         .layer(cors);
 
     let addr = std::env::var("HRT_SERVER_ADDR").unwrap_or_else(|_| "127.0.0.1:4200".to_string());

crates/server/src/main.rs

@@ -7,6 +7,7 @@ use tokio::io::AsyncWriteExt;
 pub const DATA_FILE_PATH: &str = "data/hrt-data.json";
 pub const SETTINGS_FILE_PATH: &str = "data/hrt-settings.yaml";
 pub const PHOTOS_DIR: &str = "data/dosage-photos";
+pub const BLOODTEST_PDFS_DIR: &str = "data/bloodtest-pdfs";
 
 #[derive(thiserror::Error, Debug)]
 pub enum StorageError {
@@ -115,8 +116,35 @@ pub async fn delete_photo(entry_id: &str, filename: &str) -> Result<bool, Storag
     }
 }
 
+pub async fn save_bloodtest_pdf(filename: &str, bytes: &[u8]) -> Result<PathBuf, StorageError> {
+    let dir = Path::new(BLOODTEST_PDFS_DIR);
+    fs::create_dir_all(dir).await?;
+    let path = dir.join(filename);
+    fs::write(&path, bytes).await?;
+    Ok(path)
+}
+
+pub async fn read_bloodtest_pdf(filename: &str) -> Result<Option<Vec<u8>>, StorageError> {
+    let path = Path::new(BLOODTEST_PDFS_DIR).join(filename);
+    match fs::read(path).await {
+        Ok(bytes) => Ok(Some(bytes)),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(err) => Err(err.into()),
+    }
+}
+
+pub async fn delete_bloodtest_pdf(filename: &str) -> Result<bool, StorageError> {
+    let path = Path::new(BLOODTEST_PDFS_DIR).join(filename);
+    match fs::remove_file(path).await {
+        Ok(()) => Ok(true),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(false),
+        Err(err) => Err(err.into()),
+    }
+}
+
 pub fn content_type_from_ext(ext: &str) -> &'static str {
     match ext.to_lowercase().as_str() {
+        "pdf" => "application/pdf",
         "jpg" | "jpeg" => "image/jpeg",
         "png" => "image/png",
         "webp" => "image/webp",

crates/server/src/storage.rs

@@ -305,6 +305,8 @@ pub struct BloodTest {
     pub notes: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub estrogenType: Option<EstrogenType>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pdfFiles: Option<Vec<String>>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -370,6 +372,8 @@ pub struct Settings {
     pub displayInjectableInIU: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub braSizeSystem: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pdfPassword: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]

crates/shared/src/types.rs

@@ -16,6 +16,7 @@ pub fn BackupPage() -> impl IntoView {
     let settings = store.settings;
 
     let ics_secret = create_rw_signal(settings.get().icsSecret.unwrap_or_default());
+    let pdf_password = create_rw_signal(settings.get().pdfPassword.unwrap_or_default());
     let blood_test_interval_months = create_rw_signal(
         settings
             .get()
@@ -48,16 +49,23 @@ pub fn BackupPage() -> impl IntoView {
     let on_save_settings = {
         let store = store.clone();
         let ics_secret = ics_secret;
+        let pdf_password = pdf_password;
         let blood_test_interval_months = blood_test_interval_months;
         move |_: leptos::ev::MouseEvent| {
             let secret = ics_secret.get();
+            let password = pdf_password.get();
             let interval = parse_decimal(&blood_test_interval_months.get());
             store.settings.update(|s| {
                 s.icsSecret = if secret.trim().is_empty() {
                     None
                 } else {
                     Some(secret)
                 };
+                s.pdfPassword = if password.trim().is_empty() {
+                    None
+                } else {
+                    Some(password)
+                };
                 s.bloodTestIntervalMonths = interval;
             });
             store.mark_dirty();
@@ -242,6 +250,13 @@ pub fn BackupPage() -> impl IntoView {
                             on:input=move |ev| ics_secret.set(event_target_value(&ev))
                             prop:value=move || ics_secret.get()
                         />
+                        <label>"PDF password (optional)"</label>
+                        <input
+                            type="password"
+                            placeholder="password for encrypted lab PDFs"
+                            on:input=move |ev| pdf_password.set(event_target_value(&ev))
+                            prop:value=move || pdf_password.get()
+                        />
                         <label>"Estradiol display unit"</label>
                         <select
                             on:change={