94 lines
2.9 KiB
Rust
94 lines
2.9 KiB
Rust
use std::{collections::HashSet, process::{Command, Stdio}};
|
|
|
|
use schemars::JsonSchema;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::artifacts::{Artifact, SourceID, Track};
|
|
|
|
|
|
#[derive(Debug, Default, Serialize, Deserialize, Clone, JsonSchema)]
|
|
pub struct BeatsQueryArgs {
|
|
artist: Option<String>,
|
|
album: Option<String>,
|
|
genre: Option<String>,
|
|
title: Option<String>,
|
|
year: Option<u32>
|
|
}
|
|
|
|
#[derive(Debug, Default, Deserialize)]
|
|
struct BeetsTrack {
|
|
album: String,
|
|
artist: String,
|
|
genres: Option<Vec<String>>,
|
|
label: Option<String>,
|
|
title: String,
|
|
year: u32,
|
|
mb_trackid: Option<String>
|
|
}
|
|
|
|
impl Into<Artifact> for BeetsTrack {
|
|
fn into(self) -> Artifact {
|
|
let sources = if let Some(mbid) = self.mb_trackid {
|
|
HashSet::from([SourceID::Beets, SourceID::Musicbrainz(mbid)])
|
|
} else {
|
|
HashSet::from([SourceID::Beets])
|
|
};
|
|
Artifact::Track(Track {
|
|
title: self.title,
|
|
label: self.label,
|
|
year: Some(self.year),
|
|
genres: self.genres.unwrap_or_default(),
|
|
album: Some(self.album),
|
|
artist: Some(self.artist),
|
|
bpm: None,
|
|
sources
|
|
})
|
|
}
|
|
}
|
|
|
|
impl BeatsQueryArgs {
|
|
pub fn execute(self) -> Result<Vec<Artifact>, ()> {
|
|
let mut beets_cmd = Command::new("beet");
|
|
beets_cmd.args(["export", "-f", "json", "-i", "title,label,year,genres,album,artist,mb_trackid"]);
|
|
let mut valid = false;
|
|
if let Some(artist) = self.artist {
|
|
beets_cmd.arg(format!("artist:{}", artist));
|
|
valid = true;
|
|
}
|
|
if let Some(genre) = self.genre {
|
|
beets_cmd.arg(format!("genre:{}", genre));
|
|
valid = true;
|
|
}
|
|
if let Some(album) = self.album {
|
|
beets_cmd.arg(format!("album:{}", album));
|
|
valid = true;
|
|
}
|
|
if let Some(title) = self.title {
|
|
beets_cmd.arg(format!("title:{}", title));
|
|
valid = true;
|
|
}
|
|
if let Some(year) = self.year {
|
|
beets_cmd.arg(format!("year:{}", year));
|
|
valid = true;
|
|
}
|
|
|
|
if !valid {
|
|
log::warn!("Tried to execute an empty beets query");
|
|
return Err(())
|
|
}
|
|
|
|
log::debug!("Executing beets: {:?}", beets_cmd);
|
|
if let Ok(output) = beets_cmd.stdout(Stdio::piped()).stderr(Stdio::null()).spawn().unwrap().wait_with_output() {
|
|
match serde_json::from_str::<Vec<BeetsTrack>>(str::from_utf8(&output.stdout).unwrap()) {
|
|
Ok(track) => Ok(track.into_iter().map(|t| { t.into()}).collect()),
|
|
Err(err) => {
|
|
log::error!("Failed to decode beets json: {:?}", err);
|
|
Err(())
|
|
}
|
|
}
|
|
} else {
|
|
log::error!("Unable to execute query!");
|
|
Err(())
|
|
}
|
|
}
|
|
} |