Store original path if found

Author: devclef

config.toml

@@ -11,6 +11,7 @@ database_password = "shoebox"
 root_path = "/mnt/storage/tove/immich/auto-transcoded/"
 name = "videos"
 description = "Bmpcc transcoded videos"
+originals_path = "/mnt/storage/bmpcc/raw/"
 
 
 [immich]

migrations/2025-01-02-094055_media/up.sql

@@ -1,17 +1,18 @@
 -- Your SQL goes here
 CREATE TABLE media
 (
-    id          SERIAL PRIMARY KEY,
-    root_path   TEXT        NOT NULL,
-    route       TEXT        NOT NULL,
-    file_name   TEXT        NOT NULL,
-    file_path   TEXT        NOT NULL unique,
-    media_type  TEXT        NOT NULL CHECK (media_type IN ('photo', 'video')),
-    usable      BOOLEAN              DEFAULT TRUE,
-    highlight   BOOLEAN              DEFAULT FALSE,
-    reviewed    BOOLEAN              DEFAULT FALSE,
-    description TEXT,
-    duration_ms INTEGER              DEFAULT 0,
-    created_at  TIMESTAMPtz NOT NULL DEFAULT NOW(),
-    uploaded_at timestamptz          DEFAULT NOW()
+    id            SERIAL PRIMARY KEY,
+    root_path     TEXT        NOT NULL,
+    route         TEXT        NOT NULL,
+    file_name     TEXT        NOT NULL,
+    file_path     TEXT        NOT NULL unique,
+    original_path TEXT                 DEFAULT NULL,
+    media_type    TEXT        NOT NULL CHECK (media_type IN ('photo', 'video')),
+    usable        BOOLEAN              DEFAULT TRUE,
+    highlight     BOOLEAN              DEFAULT FALSE,
+    reviewed      BOOLEAN              DEFAULT FALSE,
+    description   TEXT,
+    duration_ms   INTEGER              DEFAULT 0,
+    created_at    TIMESTAMPtz NOT NULL DEFAULT NOW(),
+    uploaded_at   timestamptz          DEFAULT NOW()
 );

src/app.rs

@@ -83,10 +83,11 @@ pub fn App() -> impl IntoView {
 
 #[server]
 pub async fn get_files() -> Result<(), ServerFnError> {
-    use crate::filesystem::fs_watcher;
     use crate::filesystem::fs_watcher::scan_all;
+    use crate::filesystem::fs_watcher::scan_original_paths;
     log!("Getting files");
     let files = scan_all().await;
+    let _ = scan_original_paths().await;
     log!("Files: {:?}", files);
     Ok(())
 }

src/database/pg_calls.rs

@@ -1,6 +1,6 @@
 use crate::database::pg_conn::pg_connection;
 use crate::lib_models::MediaWeb;
-use crate::models::{Media, MediaTag, NewMedia, Person, Tag};
+use crate::models::{Media, MediaOriginalPathUpdate, MediaTag, NewMedia, Person, Tag};
 use crate::schema::*;
 use diesel::associations::HasTable;
 use diesel::dsl::insert_into;
@@ -245,3 +245,36 @@ pub fn get_file_paths_by_ids(media_ids: Vec<i32>) -> Result<Vec<String>, diesel:
 
     Ok(results)
 }
+
+pub fn update_media_original_path(
+    file_name_: &str,
+    root_path_: &str,
+    original_path_: String,
+) -> Result<(), diesel::result::Error> {
+    use crate::schema::media::dsl::*;
+    let conn = &mut pg_connection();
+
+    // Get the base name without extension
+    let base_name = file_name_
+        .rsplit_once('.')
+        .map(|(base, _)| base)
+        .unwrap_or(file_name_);
+
+    let update = MediaOriginalPathUpdate {
+        original_path: Some(original_path_),
+    };
+
+    // Use a more precise pattern that ensures we match the exact base name
+    diesel::update(media)
+        .filter(
+            file_name
+                .like(format!("{}.%", base_name))
+                .and(root_path.eq(root_path_))
+                // Exclude any files that start with ._
+                .and(file_name.not_like("._%.%")),
+        )
+        .set(&update)
+        .execute(conn)?;
+
+    Ok(())
+}

src/filesystem/fs_watcher.rs

@@ -1,8 +1,9 @@
-use crate::database::pg_calls::insert_new_media;
+use crate::database::pg_calls::{insert_new_media, update_media_original_path};
 use crate::filesystem::exif_parse::parse_exif;
 use crate::lib_models::{FileType, Metadata};
 use crate::models::NewMedia;
 use crate::settings::settings;
+use anyhow::Result;
 use chrono::DateTime;
 use leptos::logging::log;
 use std::fs;
@@ -139,3 +140,42 @@ pub async fn scan_files(dir: &str, route: &str, root_path: &str) -> Vec<FileType
 
     files
 }
+
+pub async fn scan_original_paths() {
+    let settings = settings();
+    for path in &settings.paths {
+        if let Some(orig_path) = &path.originals_path {
+            let _ = update_original_paths(orig_path.as_str(), path.root_path.as_str()).await;
+
+            // Scan subdirectories
+            let dirs = find_dirs(orig_path.as_str());
+            for dir in dirs {
+                let _ = update_original_paths(dir.as_str(), path.root_path.as_str()).await;
+            }
+        }
+    }
+}
+
+pub async fn update_original_paths(dir: &str, root_path: &str) -> Result<()> {
+    log!("scanning original paths in: {}", dir);
+
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.filter_map(Result::ok) {
+            if entry.file_type().unwrap().is_dir() {
+                continue;
+            }
+
+            let path = entry.path();
+            if let Some(file_name) = path.file_name().map(|n| n.to_string_lossy().to_string()) {
+                // Update the database record that matches this filename and root_path
+                update_media_original_path(
+                    &file_name,
+                    root_path,
+                    path.to_string_lossy().to_string(),
+                )?;
+            }
+        }
+    }
+
+    Ok(())
+}

src/models.rs

@@ -7,7 +7,7 @@ use chrono::{DateTime, Utc};
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
 
-#[derive(Queryable, Selectable, Debug, Serialize, Deserialize, Identifiable)]
+#[derive(Queryable, Identifiable, Debug, Selectable)]
 #[diesel(table_name = media)]
 #[diesel(check_for_backend(diesel::pg::Pg))]
 pub struct Media {
@@ -16,6 +16,7 @@ pub struct Media {
     pub route: String,
     pub file_name: String,
     pub file_path: String,
+    pub original_path: Option<String>,
     pub media_type: String,
     pub usable: Option<bool>,
     pub highlight: Option<bool>,
@@ -53,6 +54,13 @@ pub struct MediaUpdate {
     pub description: String,
 }
 
+// Add a specific struct for updating original_path
+#[derive(AsChangeset, Debug, Selectable)]
+#[diesel(table_name = media)]
+pub struct MediaOriginalPathUpdate {
+    pub original_path: Option<String>,
+}
+
 #[derive(Queryable, Selectable, Debug, Insertable, Associations, Identifiable)]
 #[diesel(belongs_to(Media, foreign_key = media_id))]
 #[diesel(belongs_to(Tag, foreign_key = tag_id))]

src/schema.rs

@@ -7,6 +7,7 @@ diesel::table! {
         route -> Text,
         file_name -> Text,
         file_path -> Text,
+        original_path -> Nullable<Text>,
         media_type -> Text,
         usable -> Nullable<Bool>,
         highlight -> Nullable<Bool>,
@@ -51,4 +52,10 @@ diesel::joinable!(media_people -> people (person_id));
 diesel::joinable!(media_tags -> media (media_id));
 diesel::joinable!(media_tags -> tags (tag_id));
 
-diesel::allow_tables_to_appear_in_same_query!(media, media_people, media_tags, people, tags,);
+diesel::allow_tables_to_appear_in_same_query!(
+    media,
+    media_people,
+    media_tags,
+    people,
+    tags,
+);

src/settings.rs

@@ -44,6 +44,7 @@ pub struct PathConfig {
     pub root_path: String,
     pub name: String,
     pub description: String,
+    pub originals_path: Option<String>,
 }
 
 impl PathConfig {