aboutsummaryrefslogtreecommitdiff
path: root/import/src/mod.rs
diff options
context:
space:
mode:
Diffstat (limited to 'import/src/mod.rs')
-rw-r--r--import/src/mod.rs319
1 files changed, 319 insertions, 0 deletions
diff --git a/import/src/mod.rs b/import/src/mod.rs
new file mode 100644
index 0000000..0c43cde
--- /dev/null
+++ b/import/src/mod.rs
@@ -0,0 +1,319 @@
+/*
+ This file is part of jellything (https://codeberg.org/metamuffin/jellything)
+ which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
+ Copyright (C) 2023 metamuffin <metamuffin.org>
+*/
+pub mod infojson;
+pub mod tmdb;
+
+use crate::{make_ident, ok_or_warn, Action};
+use anyhow::Context;
+use infojson::YVideo;
+use jellycommon::{
+ AssetLocation, LocalTrack, MediaInfo, Node, NodeKind, NodePrivate, NodePublic, Rating,
+ TrackSource,
+};
+use jellymatroska::read::EbmlReader;
+use jellyremuxer::import::import_metadata;
+use log::{debug, info, warn};
+use std::{
+ collections::BTreeMap,
+ fs::{remove_file, File},
+ io::{stdin, BufReader, Write},
+};
+use tmdb::{tmdb_details, tmdb_image};
+
+pub(crate) fn import(action: Action, dry: bool) -> anyhow::Result<()> {
+ match action {
+ Action::New {
+ path,
+ tmdb_id,
+ tmdb_search,
+ input,
+ series,
+ ident_prefix,
+ ignore_attachments,
+ copy,
+ video,
+ ignore_metadata,
+ r#move,
+ title,
+ skip_existing,
+ } => {
+ if std::env::current_dir().unwrap().file_name().unwrap() != "library" {
+ warn!("new command can only be used in the library directory; what you are doing right now probably wont work.")
+ }
+
+ if skip_existing {
+ if let Some(input) = &input {
+ let guessed_path = path.join(input.file_stem().unwrap_or(input.as_os_str()));
+ if guessed_path.exists() {
+ info!("guessed output ({guessed_path:?}) exists, skipping import");
+ return Ok(());
+ } else {
+ debug!("guessed output ({guessed_path:?}) missing");
+ }
+ }
+ }
+
+ let tmdb_kind = if series { "tv" } else { "movie" };
+ let tmdb_id = if let Some(id) = tmdb_id {
+ Some(id.parse().unwrap())
+ } else if let Some(title) = tmdb_search {
+ let tmdb_key = std::env::var("TMDB_API_KEY").context("tmdb api key required")?;
+ let results = tmdb::tmdb_search(tmdb_kind, &title, &tmdb_key)?;
+ info!("results:");
+ for (i, r) in results.results.iter().enumerate() {
+ info!(
+ "\t[{i}] {}: {} ({})",
+ r.id,
+ r.title.as_ref().or(r.name.as_ref()).unwrap(),
+ r.overview.chars().take(100).collect::<String>()
+ );
+ }
+ let res_index = if results.results.len() > 1 {
+ stdin()
+ .lines()
+ .next()
+ .unwrap()
+ .unwrap()
+ .parse::<usize>()
+ .unwrap()
+ } else {
+ 0
+ };
+ Some(results.results[res_index].id)
+ } else {
+ None
+ };
+
+ let tmdb_details = tmdb_id
+ .map(|id| {
+ let tmdb_key =
+ std::env::var("TMDB_API_KEY").context("tmdb api key required")?;
+ let td = tmdb_details(tmdb_kind, id, &tmdb_key)
+ .context("fetching details")
+ .unwrap();
+ Ok::<_, anyhow::Error>(td)
+ })
+ .transpose()?;
+
+ let mut kind = NodeKind::Series;
+ let mut file_meta = None;
+ let mut infojson = None;
+
+ if let Some(input_path) = &input {
+ file_meta = Some({
+ let input = BufReader::new(File::open(&input_path).unwrap());
+ let mut input = EbmlReader::new(input);
+ import_metadata(&mut input)?
+ });
+ if ignore_attachments {
+ let file_meta = file_meta.as_mut().unwrap();
+ file_meta.cover = None;
+ file_meta.infojson = None;
+ }
+ if ignore_metadata {
+ let file_meta = file_meta.as_mut().unwrap();
+ file_meta.description = None;
+ file_meta.tagline = None;
+ file_meta.title = None;
+ }
+
+ if let Some(ij) = &file_meta.as_ref().unwrap().infojson {
+ infojson =
+ Some(serde_json::from_str::<YVideo>(ij).context("parsing info.json")?);
+ }
+
+ kind = if video {
+ NodeKind::Video
+ } else {
+ NodeKind::Movie
+ };
+ }
+
+ let title = title
+ .or(tmdb_details
+ .as_ref()
+ .map(|d| d.title.clone().or(d.name.clone()))
+ .flatten())
+ .or(file_meta.as_ref().map(|m| m.title.clone()).flatten())
+ .expect("no title detected");
+
+ let ident = format!(
+ "{}{}",
+ ident_prefix.unwrap_or(String::new()),
+ make_ident(
+ &infojson
+ .as_ref()
+ .map(|i| i.id.clone())
+ .unwrap_or(title.clone())
+ ),
+ );
+ let path = path.join(&ident);
+ let source_path = input.as_ref().map(|_| path.join(format!("source.mkv")));
+
+ let (mut poster, mut backdrop) = (None, None);
+ if !dry {
+ std::fs::create_dir_all(&path)?;
+
+ poster = file_meta
+ .as_ref()
+ .map(|m| {
+ m.cover
+ .as_ref()
+ .map(|(mime, data)| {
+ let pu = path.join(format!(
+ "cover.{}",
+ match mime.as_str() {
+ "image/webp" => "webp",
+ "image/jpeg" => "jpeg",
+ "image/png" => "png",
+ _ => {
+ warn!("unknown mime, just using webp");
+ "webp"
+ }
+ }
+ ));
+ if !pu.exists() {
+ let mut f = File::create(&pu)?;
+ f.write_all(&data)?;
+ }
+ Ok::<_, anyhow::Error>(pu)
+ })
+ .transpose()
+ })
+ .transpose()?
+ .flatten()
+ .or(tmdb_details
+ .as_ref()
+ .map(|d| {
+ d.poster_path
+ .as_ref()
+ .map(|p| {
+ let pu = path.join("poster.jpeg");
+ let mut f = File::create(&pu)?;
+ tmdb_image(&p, &mut f)?;
+ Ok::<_, anyhow::Error>(pu)
+ })
+ .transpose()
+ })
+ .transpose()?
+ .flatten());
+
+ backdrop = tmdb_details
+ .as_ref()
+ .map(|d| {
+ d.backdrop_path
+ .as_ref()
+ .map(|p| {
+ let pu = path.join("backdrop.jpeg");
+ let mut f = File::create(&pu)?;
+ tmdb_image(&p, &mut f)?;
+ Ok::<_, anyhow::Error>(pu)
+ })
+ .transpose()
+ })
+ .transpose()?
+ .flatten();
+ }
+
+ let mut ratings = BTreeMap::new();
+
+ ratings.extend(
+ infojson
+ .as_ref()
+ .map(|i| (Rating::YoutubeViews, i.view_count as f64)),
+ );
+ ratings.extend(
+ infojson
+ .as_ref()
+ .map(|i| i.like_count.map(|l| (Rating::YoutubeLikes, l as f64)))
+ .flatten(),
+ );
+ ratings.extend(
+ tmdb_details
+ .as_ref()
+ .map(|d| (Rating::Tmdb, d.vote_average)),
+ );
+
+ let node = Node {
+ private: NodePrivate {
+ id: Some(ident.clone()),
+ backdrop: backdrop.clone().map(AssetLocation::Library),
+ poster: poster.clone().map(AssetLocation::Library),
+ source: file_meta.as_ref().map(|m| MediaSource::Local {
+ tracks: m
+ .track_sources
+ .clone()
+ .into_iter()
+ .map(|t| LocalTrack {
+ path: source_path.clone().unwrap(),
+ ..t
+ })
+ .collect(),
+ }),
+ },
+ public: NodePublic {
+ federated: None,
+ ratings,
+ description: file_meta
+ .as_ref()
+ .map(|m| m.description.clone())
+ .flatten()
+ .or(tmdb_details.as_ref().map(|d| d.overview.to_owned())),
+ tagline: file_meta.as_ref().map(|m| m.tagline.clone()).flatten().or(
+ tmdb_details
+ .as_ref()
+ .map(|d| d.tagline.to_owned())
+ .flatten(),
+ ),
+ title: Some(title),
+ index: None,
+ kind: Some(kind),
+ children: Vec::new(),
+ media: file_meta.as_ref().map(|m| MediaInfo {
+ chapters: m.chapters.clone(),
+ duration: m.duration,
+ tracks: m.tracks.clone(),
+ }),
+ release_date: tmdb_details
+ .as_ref()
+ .map(|d| tmdb::parse_release_date(&d.release_date.clone()?).ok())
+ .flatten()
+ .or(infojson
+ .as_ref()
+ .and_then(|j| ok_or_warn(infojson::parse_upload_date(&j.upload_date)))),
+ ..Default::default()
+ },
+ };
+
+ if dry {
+ println!("{}", serde_json::to_string_pretty(&node)?);
+ } else {
+ if let Some(source_path) = source_path {
+ let input = input.clone().unwrap();
+ if r#move {
+ std::fs::rename(&input, &source_path)?;
+ } else if copy {
+ std::fs::copy(&input, &source_path)?;
+ } else {
+ if source_path.is_symlink() {
+ remove_file(&source_path)?;
+ }
+ std::os::unix::fs::symlink(&input, &source_path)?;
+ }
+ }
+ let f = File::create(path.join(if series {
+ "directory.json"
+ } else {
+ "item.jelly"
+ }))?;
+ serde_json::to_writer_pretty(f, &node)?;
+ }
+
+ Ok(())
+ }
+ _ => unreachable!(),
+ }
+}
generated by cgit v1.2.3-70-g09d2 (git 2.51.0) at 2025-10-08 23:02:05 +0000