Add save button for all captions

NetroScript · NetroScript · commit daf3fdb00cc0 · 2023-07-28T17:53:54.000+02:00
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
@@ -3,11 +3,11 @@
 
 mod server;
 
-use std::thread;
 use once_cell::sync::Lazy;
 use specta::collect_types;
 use std::env;
 use std::sync::{Arc, RwLock};
+use std::thread;
 use tauri_specta::ts;
 
 // Store where our files are served from
@@ -24,7 +24,16 @@ static PORT: Lazy<Arc<RwLock<Option<u16>>>> = Lazy::new(|| Arc::new(RwLock::new(
 
 fn main() {
     #[cfg(debug_assertions)]
-    ts::export(collect_types![select_folder, get_served_dir, get_available_files], "../src/lib/bindings.ts").unwrap();
+    ts::export(
+        collect_types![
+            select_folder,
+            get_served_dir,
+            get_available_files,
+            save_captions
+        ],
+        "../src/lib/bindings.ts",
+    )
+    .unwrap();
 
     // Run the server as long as tauri runs
 
@@ -38,7 +47,12 @@ fn main() {
             });
             Ok(())
         })
-        .invoke_handler(tauri::generate_handler![select_folder, get_served_dir, get_available_files])
+        .invoke_handler(tauri::generate_handler![
+            select_folder,
+            get_served_dir,
+            get_available_files,
+            save_captions
+        ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
@@ -64,7 +78,6 @@ async fn select_folder() -> Result<String, String> {
 
     // Save the path to the global variable
     if let Ok(path) = &path {
-
         let mut served_dir_write = SERVED_DIR.write().unwrap();
         *served_dir_write = path.clone();
 
@@ -84,7 +97,6 @@ async fn select_folder() -> Result<String, String> {
     path
 }
 
-
 // Expose a command to return the currently served directory, and the port number
 #[tauri::command]
 #[specta::specta]
@@ -119,7 +131,6 @@ async fn get_available_files() -> Result<Vec<String>, String> {
                     if path.is_dir() {
                         dir_queue.push(path);
                     } else if let Some(path_str) = path.to_str() {
-
                         // Only store the part of the path that is relative to the served directory
                         let path_str = path_str.replace(&served_dir, "");
                         // Also remove the leading slash (can also be a backslash on Windows)
@@ -139,3 +150,48 @@ async fn get_available_files() -> Result<Vec<String>, String> {
 
     Ok(files)
 }
+
+// Expose a command to save captions, it takes an array of a path to the caption file, and the new caption content
+// We first check if it is a valid path which is inside the served directory, and then write the new content to the file replacing the old content
+#[tauri::command]
+#[specta::specta]
+async fn save_captions(captions: Vec<(String, String)>) -> Result<(), String> {
+    use std::fs;
+    use std::io::Write;
+    use std::path::PathBuf;
+
+    let served_dir = SERVED_DIR.read().unwrap().clone();
+
+    for caption in captions {
+        let path = PathBuf::from(&served_dir).join(&caption.0);
+
+        // Check if the path is inside the served directory, if not return an error
+        if !path.starts_with(&served_dir) {
+            return Err("Invalid path".to_string());
+        }
+
+        // Create the file if it doesn't exist yet
+        if !path.exists() {
+            match path.parent() {
+                Some(parent) => {
+                    fs::create_dir_all(parent).unwrap();
+                }
+                None => {
+                    return Err("Invalid path".to_string());
+                }
+            }
+        }
+
+        // Write the new caption content to the file
+        match fs::File::create(&path) {
+            Ok(mut file) => {
+                file.write_all(caption.1.as_bytes()).unwrap();
+            }
+            Err(_) => {
+                return Err("Error writing to file".to_string());
+            }
+        }
+    }
+
+    Ok(())
+}
diff --git a/src-tauri/src/server/mod.rs b/src-tauri/src/server/mod.rs
@@ -1,13 +1,12 @@
-
 use std::sync::Mutex;
 
-use tauri::AppHandle;
-use actix_files::NamedFile;
-use actix_web::{web, App, HttpServer, Result, middleware};
-use std::path::PathBuf;
-use actix_cors::Cors;
 use super::PORT;
 use super::SERVED_DIR;
+use actix_cors::Cors;
+use actix_files::NamedFile;
+use actix_web::{middleware, web, App, HttpServer, Result};
+use std::path::PathBuf;
+use tauri::AppHandle;
 
 struct TauriAppState {
     app: Mutex<AppHandle>,
@@ -21,7 +20,6 @@ pub async fn init(app: AppHandle) -> std::io::Result<()> {
 
     // Create server, bind it to any available port
     let server = HttpServer::new(move || {
-
         let cors = Cors::default().allow_any_origin().send_wildcard();
 
         // Additionally just return 200 if checkAlive as route is called
@@ -52,7 +50,6 @@ pub async fn init(app: AppHandle) -> std::io::Result<()> {
     server.run().await
 }
 
-
 async fn serve_file(path: web::Path<(String,)>) -> Result<NamedFile> {
     let directory = SERVED_DIR.read().unwrap();
     let file_path = PathBuf::from(&*directory).join(&path.0);
@@ -64,4 +61,3 @@ async fn serve_file(path: web::Path<(String,)>) -> Result<NamedFile> {
 
     Ok(NamedFile::open(file_path)?)
 }
-
diff --git a/src/app.d.ts b/src/app.d.ts
@@ -7,3 +7,5 @@ declare namespace App {
 	// interface Error {}
 	// interface Platform {}
 }
+
+import 'unplugin-icons/types/svelte';
diff --git a/src/lib/bindings.ts b/src/lib/bindings.ts
@@ -22,4 +22,8 @@ export function getAvailableFiles() {
     return invoke()<string[]>("get_available_files")
 }
 
+export function saveCaptions(captions: ([string, string])[]) {
+    return invoke()<null>("save_captions", { captions })
+}
+
 
diff --git a/src/lib/stores.ts b/src/lib/stores.ts
@@ -4,58 +4,96 @@ export const working_folder = writable('');
 export const file_server_port = writable(0);
 export const available_files = writable<string[]>([]);
 
-const VALID_IMAGE_FORMATS = ['.jpg', '.png', '.gif', '.bmp', '.webp', '.jpeg', '.avif']
+const VALID_IMAGE_FORMATS = ['.jpg', '.png', '.gif', '.bmp', '.webp', '.jpeg', '.avif'];
 
 // Have a derived store, which combines all available files into an image file, and a corresponding caption file (the first non image file with the same name)
-export const available_images = writable<{image: string, caption: string, caption_file: string, viewed: boolean}[]>([]);
+export const available_images = writable<
+	{ image: string; caption: string; caption_file: string; viewed: boolean }[]
+>([]);
 export const is_loading_image_data = writable(false);
 
 const update_available_files = async () => {
-    const image_map = new Map<string, {image: string, caption: string, caption_file: string, viewed: boolean}>();
-
-
-    const unprocessed_files = [];
-    
-    for (const file of get(available_files)) {
-        // Get the file without the extension
-        const [file_name, file_extension] = file.split('.');
-        if (VALID_IMAGE_FORMATS.includes(`.${file_extension.toLocaleLowerCase()}`)) {
-            image_map.set(file_name, {
-                image: file,
-                caption: '',
-                caption_file: '',
-                viewed: false,
-            });
-        } else {
-            unprocessed_files.push(file);
-        }
-    };
-
-    for (const file of unprocessed_files) {
-        const [file_name, file_extension] = file.split('.');
-        const image = image_map.get(file_name);
-        if (image && image.caption === '') {
-            image.caption_file = file;
-
-            // Fetch the text caption from our file server
-            image.caption = await fetch(`http://localhost:${get(file_server_port)}/${file}`).then((response) => {
-                return response.text();
-            }).catch((error) => {
-                console.error(error);
-            }) || '';
-
-        }
-    }
-
-    return Array.from(image_map.values());
-}
+	const image_map = new Map<
+		string,
+		{ image: string; caption: string; caption_file: string; viewed: boolean }
+	>();
 
+	const unprocessed_files = [];
+
+	for (const file of get(available_files)) {
+		// Get the file without the extension
+		const [file_name, file_extension] = file.split('.');
+		if (file_extension && VALID_IMAGE_FORMATS.includes(`.${file_extension.toLowerCase()}`)) {
+			image_map.set(file_name, {
+				image: file,
+				caption: '',
+				caption_file: '',
+				viewed: false
+			});
+		} else {
+			unprocessed_files.push(file);
+		}
+	}
+
+	const caption_counts: Map<string, number> = new Map();
+
+	for (const file of unprocessed_files) {
+		const [file_name, file_extension] = file.split('.');
+
+		// If a file extension exists
+		if (file_extension !== undefined) {
+			// Count how often we see the different caption extensions
+			if (caption_counts.has(file_extension.toLowerCase())) {
+				caption_counts.set(
+					file_extension.toLocaleLowerCase(),
+					caption_counts.get(file_extension.toLowerCase())! + 1
+				);
+			} else {
+				caption_counts.set(file_extension.toLowerCase(), 1);
+			}
+		}
+
+		const image = image_map.get(file_name);
+		if (image && image.caption === '') {
+			image.caption_file = file;
+
+			// Fetch the text caption from our file server, disable caching
+			image.caption =
+				(await fetch(`http://localhost:${get(file_server_port)}/${file}`, { cache: 'no-store' })
+					.then((response) => {
+						return response.text();
+					})
+					.catch((error) => {
+						console.error(error);
+					})) || '';
+		}
+	}
+
+	let final_caption_extension = 'txt';
+
+	if (caption_counts.size > 0) {
+		// Find the most common caption extension
+		const most_common_caption_extensions = [...caption_counts.entries()].reduce((a, e) =>
+			e[1] > a[1] ? e : a
+		);
+		if (most_common_caption_extensions.length > 0) {
+			[final_caption_extension] = most_common_caption_extensions;
+		}
+	}
+
+	// Iterate all images, and set the caption file if it is not already set (using the same name as the image, but with the most common caption extension)
+	for (const image of image_map.values()) {
+		if (image.caption_file === '') {
+			image.caption_file = `${image.image.split('.')[0]}.${final_caption_extension}`;
+		}
+	}
+
+	return Array.from(image_map.values());
+};
 
 // But we need to manually, asynchronously update the available images by subscribing to the available files store
 available_files.subscribe(async (files) => {
-    is_loading_image_data.set(true);
-    available_images.set(await update_available_files());
-    is_loading_image_data.set(false);
+	is_loading_image_data.set(true);
+	available_images.set(await update_available_files());
+	is_loading_image_data.set(false);
 });
-
-
diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte

Original file line number	Diff line number	Diff line change
`@@ -7,3 +7,5 @@ declare namespace App {`
`7`	`7`	`// interface Error {}`
`8`	`8`	`// interface Platform {}`
`9`	`9`	`}`
	`10`	`+`
	`11`	`+import 'unplugin-icons/types/svelte';`
Original file line number	Diff line number	Diff line change
`@@ -22,4 +22,8 @@ export function getAvailableFiles() {`
`22`	`22`	`return invoke()<string[]>("get_available_files")`
`23`	`23`	`}`
`24`	`24`
	`25`	`+export function saveCaptions(captions: ([string, string])[]) {`
	`26`	`+ return invoke()<null>("save_captions", { captions })`
	`27`	`+}`
	`28`	`+`
`25`	`29`