feat(yarr): restructure into workspace with separate API and CLI crates

yarr-api/src/lib.rs

@@ -0,0 +1,570 @@
+//! Sonarr API client library
+//!
+//! This crate provides a Rust client for the Sonarr API, allowing you to interact
+//! with Sonarr instances programmatically.
+
+pub mod error;
+
+pub use error::{ApiError, Result};
+
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Clone)]
+pub struct SonarrClient {
+    client: Client,
+    base_url: String,
+    api_key: String,
+}
+
+impl SonarrClient {
+    pub fn new(base_url: String, api_key: String) -> Self {
+        Self {
+            client: Client::new(),
+            base_url: base_url.trim_end_matches('/').to_string(),
+            api_key,
+        }
+    }
+
+    async fn get<T: for<'de> Deserialize<'de>>(&self, endpoint: &str) -> Result<T, ApiError> {
+        let url = format!("{}/api/v3{}", self.base_url, endpoint);
+        let response = self
+            .client
+            .get(&url)
+            .header("X-Api-Key", &self.api_key)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(ApiError::Generic {
+                message: format!("HTTP {}: {}", status, error_text),
+            });
+        }
+
+        let text = response.text().await?;
+        let result: T = serde_json::from_str(&text)?;
+        Ok(result)
+    }
+
+    #[allow(dead_code)]
+    async fn get_debug<T: for<'de> Deserialize<'de>>(&self, endpoint: &str) -> Result<T, ApiError> {
+        let url = format!("{}/api/v3{}", self.base_url, endpoint);
+        let response = self
+            .client
+            .get(&url)
+            .header("X-Api-Key", &self.api_key)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(ApiError::Generic {
+                message: format!("Debug HTTP {}: {}", status, error_text),
+            });
+        }
+
+        let text = response.text().await?;
+        let _ = std::fs::write(endpoint.replace("/", "_"), &text);
+        let result: T = serde_json::from_str(&text)?;
+        Ok(result)
+    }
+
+    #[allow(dead_code)]
+    async fn post<T: Serialize, R: for<'de> Deserialize<'de>>(
+        &self,
+        endpoint: &str,
+        body: &T,
+    ) -> Result<R, ApiError> {
+        let url = format!("{}/api/v3{}", self.base_url, endpoint);
+        let response = self
+            .client
+            .post(&url)
+            .header("X-Api-Key", &self.api_key)
+            .json(body)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(ApiError::Generic {
+                message: format!("POST HTTP {}: {}", status, error_text),
+            });
+        }
+
+        let text = response.text().await?;
+        let result: R = serde_json::from_str(&text)?;
+        Ok(result)
+    }
+
+    pub async fn get_system_status(&self) -> Result<SystemStatus, ApiError> {
+        self.get("/system/status").await
+    }
+
+    pub async fn get_series(&self) -> Result<Vec<Series>, ApiError> {
+        self.get("/series").await
+    }
+
+    #[allow(dead_code)]
+    pub async fn get_series_by_id(&self, id: u32) -> Result<Series, ApiError> {
+        self.get(&format!("/series/{}", id)).await
+    }
+
+    #[allow(dead_code)]
+    pub async fn get_episodes(
+        &self,
+        series_id: Option<u32>,
+        season_number: Option<u32>,
+    ) -> Result<Vec<Episode>, ApiError> {
+        let mut query = Vec::new();
+        if let Some(id) = series_id {
+            query.push(format!("seriesId={}", id));
+        }
+        if let Some(season) = season_number {
+            query.push(format!("seasonNumber={}", season));
+        }
+
+        let query_string = if query.is_empty() {
+            String::new()
+        } else {
+            format!("?{}", query.join("&"))
+        };
+
+        self.get(&format!("/episode{}", query_string)).await
+    }
+
+    pub async fn get_calendar(
+        &self,
+        start: Option<&str>,
+        end: Option<&str>,
+    ) -> Result<Vec<Episode>, ApiError> {
+        let mut query = Vec::new();
+        if let Some(start_date) = start {
+            query.push(format!("start={}", start_date));
+        }
+        if let Some(end_date) = end {
+            query.push(format!("end={}", end_date));
+        }
+
+        let query_string = if query.is_empty() {
+            String::new()
+        } else {
+            format!("?{}", query.join("&"))
+        };
+
+        self.get(&format!("/calendar{}", query_string)).await
+    }
+
+    pub async fn get_queue(&self) -> Result<QueuePagingResource, ApiError> {
+        self.get("/queue").await
+    }
+
+    pub async fn get_history(&self) -> Result<HistoryPagingResource, ApiError> {
+        self.get("/history").await
+    }
+
+    #[allow(dead_code)]
+    pub async fn get_missing_episodes(&self) -> Result<EpisodePagingResource, ApiError> {
+        self.get("/wanted/missing").await
+    }
+
+    pub async fn get_health(&self) -> Result<Vec<HealthResource>, ApiError> {
+        self.get("/health").await
+    }
+
+    pub async fn search_series(&self, term: &str) -> Result<Vec<Series>, ApiError> {
+        self.get(&format!(
+            "/series/lookup?term={}",
+            urlencoding::encode(term)
+        ))
+        .await
+    }
+
+    #[allow(dead_code)]
+    pub async fn add_series(&self, series: &Series) -> Result<Series, ApiError> {
+        self.post("/series", series).await
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SystemStatus {
+    pub app_name: Option<String>,
+    pub instance_name: Option<String>,
+    pub version: Option<String>,
+    pub build_time: chrono::DateTime<chrono::Utc>,
+    pub is_debug: bool,
+    pub is_production: bool,
+    pub is_admin: bool,
+    pub is_user_interactive: bool,
+    pub startup_path: Option<String>,
+    pub app_data: Option<String>,
+    pub os_name: Option<String>,
+    pub os_version: Option<String>,
+    pub is_net_core: bool,
+    pub is_linux: bool,
+    pub is_osx: bool,
+    pub is_windows: bool,
+    pub is_docker: bool,
+    pub mode: String,
+    pub branch: Option<String>,
+    pub authentication: String,
+    pub sqlite_version: Option<String>,
+    pub migration_version: i32,
+    pub url_base: Option<String>,
+    pub runtime_version: Option<String>,
+    pub runtime_name: Option<String>,
+    pub start_time: chrono::DateTime<chrono::Utc>,
+    pub package_version: Option<String>,
+    pub package_author: Option<String>,
+    pub package_update_mechanism: String,
+    pub package_update_mechanism_message: Option<String>,
+    pub database_version: Option<String>,
+    pub database_type: String,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Series {
+    pub id: Option<u32>,
+    pub title: Option<String>,
+    pub alternate_titles: Option<Vec<AlternateTitle>>,
+    pub sort_title: Option<String>,
+    pub status: String,
+    pub ended: Option<bool>,
+    pub profile_name: Option<String>,
+    pub overview: Option<String>,
+    pub next_airing: Option<chrono::DateTime<chrono::Utc>>,
+    pub previous_airing: Option<chrono::DateTime<chrono::Utc>>,
+    pub network: Option<String>,
+    pub air_time: Option<String>,
+    pub images: Option<Vec<MediaCover>>,
+    pub original_language: Option<Language>,
+    pub remote_poster: Option<String>,
+    pub seasons: Option<Vec<Season>>,
+    pub year: u32,
+    pub path: Option<String>,
+    pub quality_profile_id: u32,
+    pub season_folder: bool,
+    pub monitored: bool,
+    pub monitor_new_items: String,
+    pub use_scene_numbering: bool,
+    pub runtime: u32,
+    pub tvdb_id: u32,
+    pub tv_rage_id: u32,
+    pub tv_maze_id: u32,
+    pub tmdb_id: u32,
+    pub first_aired: Option<chrono::DateTime<chrono::Utc>>,
+    pub last_aired: Option<chrono::DateTime<chrono::Utc>>,
+    pub series_type: String,
+    pub clean_title: Option<String>,
+    pub imdb_id: Option<String>,
+    pub title_slug: Option<String>,
+    pub root_folder_path: Option<String>,
+    pub folder: Option<String>,
+    pub certification: Option<String>,
+    pub genres: Option<Vec<String>>,
+    pub tags: Option<Vec<u32>>,
+    pub added: chrono::DateTime<chrono::Utc>,
+    pub add_options: Option<AddSeriesOptions>,
+    pub ratings: Option<Ratings>,
+    pub statistics: Option<SeriesStatistics>,
+    pub episodes_changed: Option<bool>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AlternateTitle {
+    pub title: Option<String>,
+    pub season_number: Option<i32>,
+    pub scene_season_number: Option<i32>,
+    pub scene_origin: Option<String>,
+    pub comment: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MediaCover {
+    pub cover_type: String,
+    pub url: Option<String>,
+    pub remote_url: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Language {
+    pub id: u32,
+    pub name: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Season {
+    pub season_number: i32,
+    pub monitored: bool,
+    pub statistics: Option<SeasonStatistics>,
+    pub images: Option<Vec<MediaCover>>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AddSeriesOptions {
+    pub ignore_episodes_with_files: bool,
+    pub ignore_episodes_without_files: bool,
+    pub monitor: String,
+    pub search_for_missing_episodes: bool,
+    pub search_for_cutoff_unmet_episodes: bool,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Ratings {
+    pub votes: i32,
+    pub value: f64,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SeriesStatistics {
+    pub season_count: i32,
+    pub episode_file_count: i32,
+    pub episode_count: i32,
+    pub total_episode_count: i32,
+    pub size_on_disk: i64,
+    pub release_groups: Option<Vec<String>>,
+    pub percent_of_episodes: f64,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SeasonStatistics {
+    pub next_airing: Option<chrono::DateTime<chrono::Utc>>,
+    pub previous_airing: Option<chrono::DateTime<chrono::Utc>>,
+    pub episode_file_count: i32,
+    pub episode_count: i32,
+    pub total_episode_count: i32,
+    pub size_on_disk: i64,
+    pub release_groups: Option<Vec<String>>,
+    pub percent_of_episodes: f64,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Episode {
+    pub id: u32,
+    pub series_id: u32,
+    pub tvdb_id: u32,
+    pub episode_file_id: u32,
+    pub season_number: i32,
+    pub episode_number: i32,
+    pub title: Option<String>,
+    pub air_date: Option<String>,
+    pub air_date_utc: Option<chrono::DateTime<chrono::Utc>>,
+    pub last_search_time: Option<chrono::DateTime<chrono::Utc>>,
+    pub runtime: i32,
+    pub finale_type: Option<String>,
+    pub overview: Option<String>,
+    pub episode_file: Option<EpisodeFile>,
+    pub has_file: bool,
+    pub monitored: bool,
+    pub absolute_episode_number: Option<i32>,
+    pub scene_absolute_episode_number: Option<i32>,
+    pub scene_episode_number: Option<i32>,
+    pub scene_season_number: Option<i32>,
+    pub unverified_scene_numbering: bool,
+    pub end_time: Option<chrono::DateTime<chrono::Utc>>,
+    pub grab_date: Option<chrono::DateTime<chrono::Utc>>,
+    pub series: Option<Series>,
+    pub images: Option<Vec<MediaCover>>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EpisodeFile {
+    pub id: u32,
+    pub series_id: u32,
+    pub season_number: i32,
+    pub relative_path: Option<String>,
+    pub path: Option<String>,
+    pub size: i64,
+    pub date_added: chrono::DateTime<chrono::Utc>,
+    pub scene_name: Option<String>,
+    pub release_group: Option<String>,
+    pub languages: Option<Vec<Language>>,
+    pub quality: Option<Quality>,
+    pub custom_formats: Option<Vec<CustomFormat>>,
+    pub custom_format_score: i32,
+    pub indexer_flags: Option<i32>,
+    pub release_type: Option<String>,
+    pub media_info: Option<MediaInfo>,
+    pub quality_cutoff_not_met: bool,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Quality {
+    pub quality: QualityDefinition,
+    pub revision: Revision,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityDefinition {
+    pub id: u32,
+    pub name: Option<String>,
+    pub source: String,
+    pub resolution: i32,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Revision {
+    pub version: i32,
+    pub real: i32,
+    pub is_repack: bool,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CustomFormat {
+    pub id: u32,
+    pub name: Option<String>,
+    pub include_custom_format_when_renaming: Option<bool>,
+    pub specifications: Option<Vec<HashMap<String, serde_json::Value>>>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MediaInfo {
+    pub id: u32,
+    pub audio_bitrate: i64,
+    pub audio_channels: f64,
+    pub audio_codec: Option<String>,
+    pub audio_languages: Option<String>,
+    pub audio_stream_count: i32,
+    pub video_bit_depth: i32,
+    pub video_bitrate: i64,
+    pub video_codec: Option<String>,
+    pub video_fps: f64,
+    pub video_dynamic_range: Option<String>,
+    pub video_dynamic_range_type: Option<String>,
+    pub resolution: Option<String>,
+    pub run_time: Option<String>,
+    pub scan_type: Option<String>,
+    pub subtitles: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueuePagingResource {
+    pub page: i32,
+    pub page_size: i32,
+    pub sort_key: Option<String>,
+    pub sort_direction: String,
+    pub total_records: i32,
+    pub records: Vec<QueueItem>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueueItem {
+    pub id: u32,
+    pub series_id: Option<u32>,
+    pub episode_id: Option<u32>,
+    pub season_number: Option<i32>,
+    pub series: Option<Series>,
+    pub episode: Option<Episode>,
+    pub languages: Option<Vec<Language>>,
+    pub quality: Option<Quality>,
+    pub custom_formats: Option<Vec<CustomFormat>>,
+    pub custom_format_score: i32,
+    pub size: f64,
+    pub title: Option<String>,
+    pub estimated_completion_time: Option<chrono::DateTime<chrono::Utc>>,
+    pub added: Option<chrono::DateTime<chrono::Utc>>,
+    pub status: String,
+    pub tracked_download_status: Option<String>,
+    pub tracked_download_state: Option<String>,
+    pub status_messages: Option<Vec<StatusMessage>>,
+    pub error_message: Option<String>,
+    pub download_id: Option<String>,
+    pub protocol: String,
+    pub download_client: Option<String>,
+    pub download_client_has_post_import_category: bool,
+    pub indexer: Option<String>,
+    pub output_path: Option<String>,
+    pub episode_has_file: bool,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StatusMessage {
+    pub title: Option<String>,
+    pub messages: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HistoryPagingResource {
+    pub page: i32,
+    pub page_size: i32,
+    pub sort_key: Option<String>,
+    pub sort_direction: String,
+    pub total_records: i32,
+    pub records: Vec<HistoryItem>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HistoryItem {
+    pub id: u32,
+    pub episode_id: u32,
+    pub series_id: u32,
+    pub source_title: Option<String>,
+    pub languages: Option<Vec<Language>>,
+    pub quality: Option<Quality>,
+    pub custom_formats: Option<Vec<CustomFormat>>,
+    pub custom_format_score: i32,
+    pub quality_cutoff_not_met: bool,
+    pub date: chrono::DateTime<chrono::Utc>,
+    pub download_id: Option<String>,
+    pub event_type: Option<String>,
+    pub data: Option<HashMap<String, Option<String>>>,
+    pub episode: Option<Episode>,
+    pub series: Option<Series>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EpisodePagingResource {
+    pub page: i32,
+    pub page_size: i32,
+    pub sort_key: Option<String>,
+    pub sort_direction: String,
+    pub total_records: i32,
+    pub records: Vec<Episode>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HealthResource {
+    pub id: Option<i32>,
+    pub source: Option<String>,
+    #[serde(rename = "type")]
+    pub health_type: String,
+    pub message: Option<String>,
+    pub wiki_url: Option<String>,
+}