Add nextory folder support

Author: StirlingMouse

mlm_db/src/lib.rs

@@ -300,4 +300,5 @@ pub mod ids {
     pub const GOODREADS: &str = "goodreads";
     pub const ISBN: &str = "isbn";
     pub const MAM: &str = "mam";
+    pub const NEXTORY: &str = "nextory";
 }

server/src/linker/folder.rs

@@ -57,11 +57,11 @@ async fn link_folder(
 
     let mut audio_files = vec![];
     let mut ebook_files = vec![];
-    let mut metadata_file = None;
+    let mut metadata_files = vec![];
     // let mut cover_file = None;
     while let Some(entry) = entries.next_entry().await? {
         match entry.path().extension() {
-            Some(ext) if ext == "json" => metadata_file = Some(entry),
+            Some(ext) if ext == "json" => metadata_files.push(entry),
             // Some(ext) if ext == "jpg" || ext == "png" => cover_file = Some(entry),
             Some(ext)
                 if config
@@ -83,22 +83,41 @@ async fn link_folder(
         }
     }
 
-    let Some(metadata_file) = metadata_file else {
+    if metadata_files.is_empty() {
         warn!("Missing metadata file");
         return Ok(());
-    };
+    }
 
-    let json = read_to_string(metadata_file.path()).await?;
-    if let Ok(libation_meta) = serde_json::from_str::<Libation>(&json) {
-        trace!("Linking libation folder");
-        let asin = libation_meta.asin.clone();
-        let title = libation_meta.title.clone();
-        let result =
-            link_libation_folder(config, library, db, libation_meta, audio_files, ebook_files)
-                .await;
-        update_errored_torrent(db, ErroredTorrentId::Linker(asin), title, result).await;
+    metadata_files.sort_by_key(|entry| entry.file_name());
+    for metadata_file in metadata_files {
+        let json = read_to_string(metadata_file.path()).await?;
+        if let Ok(libation_meta) = serde_json::from_str::<Libation>(&json) {
+            trace!("Linking libation folder");
+            let asin = libation_meta.asin.clone();
+            let title = libation_meta.title.clone();
+            let result =
+                link_libation_folder(config, library, db, libation_meta, audio_files, ebook_files)
+                    .await;
+            update_errored_torrent(db, ErroredTorrentId::Linker(asin), title, result).await;
+            return Ok(());
+        }
+        if let Some(nextory_meta) = parse_nextory_meta(&json) {
+            trace!("Linking nextory folder");
+            let id = nextory_torrent_id(nextory_meta.id);
+            let title = nextory_meta.title.clone();
+            let result =
+                link_nextory_folder(config, library, db, nextory_meta, audio_files, ebook_files)
+                    .await;
+            update_errored_torrent(db, ErroredTorrentId::Linker(id), title, result).await;
+            return Ok(());
+        }
     }
 
+    warn!(
+        folder = folder.path().to_string_lossy().to_string(),
+        "Unsupported metadata format"
+    );
+
     Ok(())
 }
 
@@ -110,11 +129,10 @@ async fn link_libation_folder(
     audio_files: Vec<DirEntry>,
     ebook_files: Vec<DirEntry>,
 ) -> Result<()> {
-    let r = db.r_transaction()?;
-    let existing_torrent: Option<Torrent> = r.get().primary(libation_meta.asin.clone())?;
-    if existing_torrent.is_some() {
-        return Ok(());
-    }
+    let torrent =
+        build_libation_torrent(library, libation_meta, &audio_files, &ebook_files).await?;
+    link_prepared_folder_torrent(config, library, db, torrent, audio_files, ebook_files).await
+}
 
 async fn link_nextory_folder(
     config: &Config,
@@ -123,19 +141,9 @@ async fn link_nextory_folder(
     nextory_meta: NextoryRaw,
     audio_files: Vec<DirEntry>,
     ebook_files: Vec<DirEntry>,
-    events: &crate::stats::Events,
 ) -> Result<()> {
     let torrent = build_nextory_torrent(library, nextory_meta, &audio_files, &ebook_files).await?;
-    link_prepared_folder_torrent(
-        config,
-        library,
-        db,
-        torrent,
-        audio_files,
-        ebook_files,
-        events,
-    )
-    .await
+    link_prepared_folder_torrent(config, library, db, torrent, audio_files, ebook_files).await
 }
 
 async fn build_libation_torrent(
@@ -197,13 +205,7 @@ async fn build_libation_torrent(
     if libation_meta.format_type.starts_with("abridged") {
         flags.abridged = Some(true);
     }
-    let mut size = 0;
-    for file in &audio_files {
-        size += file_size(&file.metadata().await?);
-    }
-    for file in &ebook_files {
-        size += file_size(&file.metadata().await?);
-    }
+    let (size, filetypes) = folder_file_stats(audio_files, ebook_files).await?;
 
     let meta = TorrentMeta {
         ids,
@@ -215,7 +217,7 @@ async fn build_libation_torrent(
         tags: vec![],
         language: Language::from_str(&libation_meta.language).ok(),
         flags: Some(FlagBits::new(flags.as_bitfield())),
-        filetypes: vec!["m4b".to_string()],
+        filetypes,
         num_files: audio_files.len() as u64,
         size: Size::from_bytes(size),
         title,
@@ -231,10 +233,103 @@ async fn build_libation_torrent(
         source: MetadataSource::File,
         uploaded_at: Timestamp::from(UtcDateTime::UNIX_EPOCH),
     };
-    let meta = clean_meta(meta, "")?;
+    build_torrent(library, libation_meta.asin, clean_meta(meta, "")?)
+}
+
+async fn build_nextory_torrent(
+    library: &Library,
+    nextory_meta: NextoryRaw,
+    audio_files: &[DirEntry],
+    ebook_files: &[DirEntry],
+) -> Result<Torrent> {
+    let mut series = vec![];
+    if let Some(raw_series) = nextory_meta.series
+        && !raw_series.name.is_empty()
+    {
+        let sequence = nextory_meta
+            .volume
+            .map(|v| v.to_string())
+            .unwrap_or_default();
+        if let Ok(parsed) = Series::try_from((raw_series.name, sequence)) {
+            series.push(parsed);
+        }
+    }
+    if series.is_empty()
+        && let Some((name, num)) = parse_series_from_title(&nextory_meta.title)
+    {
+        series.push(Series {
+            name: name.to_string(),
+            entries: SeriesEntries::new(num.into_iter().map(SeriesEntry::Num).collect()),
+        });
+    }
+
+    let mut ids = BTreeMap::new();
+    ids.insert(ids::NEXTORY.to_string(), nextory_meta.id.to_string());
+    if let Some(isbn) = nextory_isbn(&nextory_meta.formats) {
+        ids.insert(ids::ISBN.to_string(), isbn);
+    }
+    let (size, filetypes) = folder_file_stats(audio_files, ebook_files).await?;
 
-    let mut torrent = Torrent {
-        id: libation_meta.asin.clone(),
+    let description = if nextory_meta.description_full.is_empty() {
+        nextory_meta.blurb
+    } else {
+        nextory_meta.description_full
+    };
+    let meta = TorrentMeta {
+        ids,
+        vip_status: None,
+        cat: None,
+        media_type: MediaType::Audiobook,
+        main_cat: None,
+        categories: vec![],
+        tags: vec![],
+        language: parse_nextory_language(&nextory_meta.language),
+        flags: None,
+        filetypes,
+        num_files: audio_files.len() as u64,
+        size: Size::from_bytes(size),
+        title: nextory_meta.title,
+        edition: None,
+        description,
+        authors: nextory_meta.authors.into_iter().map(|a| a.name).collect(),
+        narrators: nextory_meta.narrators.into_iter().map(|n| n.name).collect(),
+        series,
+        source: MetadataSource::File,
+        uploaded_at: Timestamp::from(UtcDateTime::UNIX_EPOCH),
+    };
+    build_torrent(
+        library,
+        nextory_torrent_id(nextory_meta.id),
+        clean_meta(meta, "")?,
+    )
+}
+
+async fn folder_file_stats(
+    audio_files: &[DirEntry],
+    ebook_files: &[DirEntry],
+) -> Result<(u64, Vec<String>)> {
+    let mut size = 0;
+    let mut filetypes = vec![];
+    for file in audio_files {
+        size += file_size(&file.metadata().await?);
+        if let Some(ext) = file.path().extension() {
+            filetypes.push(ext.to_string_lossy().to_lowercase());
+        }
+    }
+    for file in ebook_files {
+        size += file_size(&file.metadata().await?);
+        if let Some(ext) = file.path().extension() {
+            filetypes.push(ext.to_string_lossy().to_lowercase());
+        }
+    }
+    filetypes.sort();
+    filetypes.dedup();
+    Ok((size, filetypes))
+}
+
+fn build_torrent(library: &Library, id: String, meta: TorrentMeta) -> Result<Torrent> {
+    Ok(Torrent {
+        id,
         id_is_hash: false,
         mam_id: meta.mam_id(),
         library_path: None,
@@ -244,12 +339,28 @@ async fn build_libation_torrent(
         selected_audio_format: None,
         selected_ebook_format: None,
         title_search: normalize_title(&meta.title),
-        meta: meta.clone(),
+        meta,
         created_at: Timestamp::now(),
         replaced_with: None,
         library_mismatch: None,
         client_status: None,
-    };
+    })
+}
+
+async fn link_prepared_folder_torrent(
+    config: &Config,
+    library: &Library,
+    db: &Database<'_>,
+    mut torrent: Torrent,
+    audio_files: Vec<DirEntry>,
+    ebook_files: Vec<DirEntry>,
+) -> Result<()> {
+    let torrent_id = torrent.id.clone();
+    let r = db.r_transaction()?;
+    let existing_torrent: Option<Torrent> = r.get().primary(torrent_id.clone())?;
+    if existing_torrent.is_some() {
+        return Ok(());
+    }
 
     let matches = find_matches(db, &torrent)?;
     if !matches.is_empty() {
@@ -263,7 +374,9 @@ async fn build_libation_torrent(
     }
 
     if let Some(filter) = library.edition_filter()
-        && !filter.matches_meta(&meta).is_ok_and(|matches| matches)
+        && !filter
+            .matches_meta(&torrent.meta)
+            .is_ok_and(|matches| matches)
     {
         trace!("Skipping folder due to edition filter");
         return Ok(());
@@ -282,14 +395,20 @@ async fn build_libation_torrent(
     );
 
     let library_path = if library.options().method != LibraryLinkMethod::NoLink {
-        let Some(mut dir) = library_dir(config.exclude_narrator_in_library_dir, library, &meta)
-        else {
+        let Some(mut dir) = library_dir(
+            config.exclude_narrator_in_library_dir,
+            library,
+            &torrent.meta,
+        ) else {
             bail!("Torrent has no author");
         };
-        if config.exclude_narrator_in_library_dir && !meta.narrators.is_empty() && dir.exists() {
-            dir = library_dir(false, library, &meta).unwrap();
+        if config.exclude_narrator_in_library_dir
+            && !torrent.meta.narrators.is_empty()
+            && dir.exists()
+        {
+            dir = library_dir(false, library, &torrent.meta).unwrap();
         }
-        let metadata = abs::create_metadata(&meta);
+        let metadata = abs::create_metadata(&torrent.meta);
 
         create_dir_all(&dir).await?;
         for file in audio_files {
@@ -339,7 +458,7 @@ async fn build_libation_torrent(
         write_event(
             db,
             Event::new(
-                Some(libation_meta.asin),
+                Some(torrent_id),
                 None,
                 EventType::Linked {
                     linker: library.options().name.clone(),
@@ -462,3 +581,47 @@ pub struct LibationSeries {
     pub sequence: String,
     pub title: String,
 }
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NextoryWrapped {
+    pub raw: NextoryRaw,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NextoryRaw {
+    pub id: u64,
+    pub title: String,
+    #[serde(default)]
+    pub blurb: String,
+    #[serde(default)]
+    pub description_full: String,
+    pub language: String,
+    #[serde(default)]
+    pub volume: Option<f64>,
+    #[serde(default)]
+    pub series: Option<NextorySeries>,
+    #[serde(default)]
+    pub formats: Vec<NextoryFormat>,
+    #[serde(default)]
+    pub authors: Vec<NextoryName>,
+    #[serde(default)]
+    pub narrators: Vec<NextoryName>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NextorySeries {
+    pub name: String,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NextoryFormat {
+    #[serde(rename = "type")]
+    pub format_type: String,
+    #[serde(default)]
+    pub isbn: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NextoryName {
+    pub name: String,
+}