GKaszewski/k-tv
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects Releases Wiki Activity

kill LibraryItem, unify to MediaItem; decouple schedule engine from providers

Browse Source 
ADR-0001: MediaItem absorbs LibraryItem fields (provider_id, external_id,
collection_name, collection_type, synced_at, role/MediaRole).
LibraryItem + LibraryItemRow deleted. All ports/adapters/tests updated.

ADR-0002: schedule engine takes LibraryQuery instead of IProviderRegistry.
Algorithmic blocks query library via search(), manual blocks via get_by_id().
get_stream_url removed from engine; provider_registry moved to ScheduleDeps
for playback-time stream URL resolution in application layer.

BlockContent provider_id field removed (meaningless when querying library).
This commit is contained in:
Gabriel Kaszewski
2026-07-12 07:02:08 +02:00
parent 773e228e21
commit a6558e15b2
30 changed files with 324 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
crates/adapters/jellyfin/src/mapping.rs
View File

@@ -1,4 +1,4 @@
use domain::{ContentType, MediaItem, MediaItemId, MediaItemRow};
use domain::{ContentType, MediaItem, MediaItemId, MediaItemRow, MediaRole};
use crate::models::JellyfinItem;
@@ -17,7 +17,7 @@ pub(crate) fn map_jellyfin_item(item: JellyfinItem) -> Option<MediaItem> {
.unwrap_or(0);
Some(MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new(item.id),
id: MediaItemId::new(&item.id),
title: item.name,
content_type,
duration_secs,
@@ -30,5 +30,11 @@ pub(crate) fn map_jellyfin_item(item: JellyfinItem) -> Option<MediaItem> {
episode_number: item.index_number,
thumbnail_url: None,
collection_id: None,
provider_id: String::new(),
external_id: item.id,
collection_name: None,
collection_type: None,
synced_at: None,
role: MediaRole::default(),
}))
}

8
crates/adapters/local-files/src/provider.rs
View File

@@ -4,7 +4,7 @@ use async_trait::async_trait;
use domain::ports::{
Collection, IMediaProvider, ProviderCapabilities, StreamQuality, StreamingProtocol,
};
use domain::{ContentType, DomainError, DomainResult, MediaFilter, MediaItem, MediaItemId, MediaItemRow};
use domain::{ContentType, DomainError, DomainResult, MediaFilter, MediaItem, MediaItemId, MediaItemRow, MediaRole};
use crate::config::LocalFilesConfig;
use crate::index::{decode_id, LocalIndex};
@@ -54,6 +54,12 @@ fn to_media_item(id: MediaItemId, item: &LocalFileItem) -> MediaItem {
episode_number: None,
thumbnail_url: None,
collection_id: None,
provider_id: String::new(),
external_id: String::new(),
collection_name: None,
collection_type: None,
synced_at: None,
role: MediaRole::default(),
})
}

31
crates/adapters/sqlite/src/library.rs
View File

@@ -4,9 +4,10 @@ use sqlx::SqlitePool;
use adapter_common::{content_type_str, parse_content_type, parse_genres_blob};
use domain::{
ports::library::{LibraryCommand, LibraryQuery},
ContentType, DomainError, DomainResult, LibraryCollection, LibraryItem,
LibraryItemRow as DomainLibraryItemRow, LibrarySearchFilter, LibrarySyncLogEntry,
LibrarySyncResult, SeasonSummary, ShowSummary,
ContentType, DomainError, DomainResult, LibraryCollection,
LibrarySearchFilter, LibrarySyncLogEntry,
LibrarySyncResult, MediaItem, MediaItemRow as DomainMediaItemRow,
MediaRole, SeasonSummary, ShowSummary,
};
pub struct SqliteLibraryRepository {
@@ -41,14 +42,15 @@ struct LibraryItemRow {
}
impl LibraryItemRow {
fn into_library_item(self) -> LibraryItem {
LibraryItem::from_persistence(DomainLibraryItemRow {
id: self.id,
fn into_media_item(self) -> MediaItem {
MediaItem::from_persistence(DomainMediaItemRow {
id: domain::MediaItemId::new(&self.id),
provider_id: self.provider_id,
external_id: self.external_id,
title: self.title,
content_type: parse_content_type(&self.content_type),
duration_secs: self.duration_secs as u32,
description: None,
series_name: self.series_name,
season_number: self.season_number.map(|n| n as u32),
episode_number: self.episode_number.map(|n| n as u32),
@@ -59,7 +61,8 @@ impl LibraryItemRow {
collection_name: self.collection_name,
collection_type: self.collection_type,
thumbnail_url: self.thumbnail_url,
synced_at: self.synced_at,
synced_at: Some(self.synced_at),
role: MediaRole::default(),
})
}
}
@@ -93,7 +96,7 @@ struct SeasonSummaryRow {
#[async_trait]
impl LibraryCommand for SqliteLibraryRepository {
async fn upsert_items(&self, _provider_id: &str, items: Vec<LibraryItem>) -> DomainResult<()> {
async fn upsert_items(&self, _provider_id: &str, items: Vec<MediaItem>) -> DomainResult<()> {
let mut tx = self
.pool
.begin()
@@ -108,7 +111,7 @@ impl LibraryCommand for SqliteLibraryRepository {
collection_id, collection_name, collection_type, thumbnail_url, synced_at)
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
)
.bind(item.id())
.bind(item.id().value())
.bind(item.provider_id())
.bind(item.external_id())
.bind(item.title())
@@ -124,7 +127,7 @@ impl LibraryCommand for SqliteLibraryRepository {
.bind(item.collection_name())
.bind(item.collection_type())
.bind(item.thumbnail_url())
.bind(item.synced_at())
.bind(item.synced_at().unwrap_or(""))
.execute(&mut *tx)
.await
.map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
@@ -187,7 +190,7 @@ impl LibraryQuery for SqliteLibraryRepository {
async fn search(
&self,
filter: &LibrarySearchFilter,
) -> DomainResult<(Vec<LibraryItem>, u32)> {
) -> DomainResult<(Vec<MediaItem>, u32)> {
let mut conditions: Vec<String> = vec![];
if let Some(p) = filter.provider_id() {
@@ -263,19 +266,19 @@ impl LibraryQuery for SqliteLibraryRepository {
Ok((
rows.into_iter()
.map(LibraryItemRow::into_library_item)
.map(LibraryItemRow::into_media_item)
.collect(),
total as u32,
))
}
async fn get_by_id(&self, id: &str) -> DomainResult<Option<LibraryItem>> {
async fn get_by_id(&self, id: &str) -> DomainResult<Option<MediaItem>> {
let row = sqlx::query_as::<_, LibraryItemRow>("SELECT * FROM library_items WHERE id = ?")
.bind(id)
.fetch_optional(&self.pool)
.await
.map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
Ok(row.map(LibraryItemRow::into_library_item))
Ok(row.map(LibraryItemRow::into_media_item))
}
async fn list_collections(

10
crates/api-types/src/library.rs
View File

@@ -21,13 +21,13 @@ pub struct LibraryItemResponse {
pub collection_name: Option<String>,
pub collection_type: Option<String>,
pub thumbnail_url: Option<String>,
pub synced_at: String,
pub synced_at: Option<String>,
}
impl From<domain::LibraryItem> for LibraryItemResponse {
fn from(i: domain::LibraryItem) -> Self {
impl From<domain::MediaItem> for LibraryItemResponse {
fn from(i: domain::MediaItem) -> Self {
Self {
id: i.id().to_string(),
id: i.id().value().to_string(),
provider_id: i.provider_id().to_string(),
external_id: i.external_id().to_string(),
title: i.title().to_string(),
@@ -43,7 +43,7 @@ impl From<domain::LibraryItem> for LibraryItemResponse {
collection_name: i.collection_name().map(|s| s.to_string()),
collection_type: i.collection_type().map(|s| s.to_string()),
thumbnail_url: i.thumbnail_url().map(|s| s.to_string()),
synced_at: i.synced_at().to_string(),
synced_at: i.synced_at().map(|s| s.to_string()),
}
}
}

4
crates/application/src/library/get_item.rs
View File

@@ -1,4 +1,4 @@
use domain::models::LibraryItem;
use domain::models::MediaItem;
use domain::DomainResult;
use super::deps::LibraryQueryDeps;
@@ -7,7 +7,7 @@ use super::queries::GetItemQuery;
pub async fn execute(
deps: &LibraryQueryDeps,
query: GetItemQuery,
) -> DomainResult<Option<LibraryItem>> {
) -> DomainResult<Option<MediaItem>> {
deps.library_query.get_by_id(&query.item_id).await
}

4
crates/application/src/library/search.rs
View File

@@ -1,5 +1,5 @@
use domain::DomainResult;
use domain::models::LibraryItem;
use domain::models::MediaItem;
use domain::value_objects::LibrarySearchFilter;
use super::deps::LibraryQueryDeps;
@@ -9,7 +9,7 @@ use super::queries::SearchItemsQuery;
pub async fn execute(
deps: &LibraryQueryDeps,
query: SearchItemsQuery,
) -> DomainResult<(Vec<LibraryItem>, u32)> {
) -> DomainResult<(Vec<MediaItem>, u32)> {
let content_type = query
.content_type
.as_deref()

6
crates/application/src/library/tests/get_item.rs
View File

@@ -1,4 +1,4 @@
use domain::models::LibraryItem;
use domain::models::MediaItem;
use domain::value_objects::ContentType;
use crate::library::get_item;
@@ -8,11 +8,11 @@ use crate::library::queries::GetItemQuery;
mod helpers;
fn seed_item(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let item = LibraryItem::new("test", "m1", "Die Hard", ContentType::Movie, 7800, "2026-01-01");
let item = MediaItem::new_library("test", "m1", "Die Hard", ContentType::Movie, 7800, "2026-01-01");
repo.items
.lock()
.unwrap()
.insert(item.id().to_string(), item);
.insert(item.id().value().to_string(), item);
}
#[tokio::test]

24
crates/application/src/library/tests/list_collections.rs
View File

@@ -1,5 +1,5 @@
use domain::models::{LibraryItem, LibraryItemRow};
use domain::value_objects::ContentType;
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::list_collections;
use crate::library::queries::ListCollectionsQuery;
@@ -10,13 +10,14 @@ mod helpers;
fn seed_with_collections(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let mut store = repo.items.lock().unwrap();
let item = LibraryItem::from_persistence(LibraryItemRow {
id: "test::m1".into(),
let item = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m1"),
provider_id: "test".into(),
external_id: "m1".into(),
title: "Die Hard".into(),
content_type: ContentType::Movie,
duration_secs: 7800,
description: None,
series_name: None,
season_number: None,
episode_number: None,
@@ -27,17 +28,19 @@ fn seed_with_collections(repo: &std::sync::Arc<domain::testing::InMemoryLibraryR
collection_name: Some("Movies".into()),
collection_type: Some("movies".into()),
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item.id().to_string(), item);
store.insert(item.id().value().to_string(), item);
let item2 = LibraryItem::from_persistence(LibraryItemRow {
id: "test::e1".into(),
let item2 = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::e1"),
provider_id: "test".into(),
external_id: "e1".into(),
title: "BB S01E01".into(),
content_type: ContentType::Episode,
duration_secs: 2700,
description: None,
series_name: Some("Breaking Bad".into()),
season_number: Some(1),
episode_number: Some(1),
@@ -48,9 +51,10 @@ fn seed_with_collections(repo: &std::sync::Arc<domain::testing::InMemoryLibraryR
collection_name: Some("TV Shows".into()),
collection_type: Some("tvshows".into()),
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item2.id().to_string(), item2);
store.insert(item2.id().value().to_string(), item2);
}
#[tokio::test]

24
crates/application/src/library/tests/list_genres.rs
View File

@@ -1,5 +1,5 @@
use domain::models::{LibraryItem, LibraryItemRow};
use domain::value_objects::ContentType;
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::list_genres;
use crate::library::queries::ListGenresQuery;
@@ -10,13 +10,14 @@ mod helpers;
fn seed_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let mut store = repo.items.lock().unwrap();
let item1 = LibraryItem::from_persistence(LibraryItemRow {
id: "test::m1".into(),
let item1 = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m1"),
provider_id: "test".into(),
external_id: "m1".into(),
title: "Die Hard".into(),
content_type: ContentType::Movie,
duration_secs: 7800,
description: None,
series_name: None,
season_number: None,
episode_number: None,
@@ -27,15 +28,17 @@ fn seed_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibraryReposi
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
let item2 = LibraryItem::from_persistence(LibraryItemRow {
id: "test::m2".into(),
let item2 = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m2"),
provider_id: "test".into(),
external_id: "m2".into(),
title: "Alien".into(),
content_type: ContentType::Movie,
duration_secs: 7020,
description: None,
series_name: None,
season_number: None,
episode_number: None,
@@ -46,11 +49,12 @@ fn seed_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibraryReposi
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item1.id().to_string(), item1);
store.insert(item2.id().to_string(), item2);
store.insert(item1.id().value().to_string(), item1);
store.insert(item2.id().value().to_string(), item2);
}
#[tokio::test]

14
crates/application/src/library/tests/list_seasons.rs
View File

@@ -1,5 +1,5 @@
use domain::models::{LibraryItem, LibraryItemRow};
use domain::value_objects::ContentType;
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::list_seasons;
use crate::library::queries::ListSeasonsQuery;
@@ -11,13 +11,14 @@ fn seed_episodes(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepositor
let mut store = repo.items.lock().unwrap();
for (i, season) in [1u32, 1, 2, 2, 2, 3].iter().enumerate() {
let item = LibraryItem::from_persistence(LibraryItemRow {
id: format!("test::e{i}"),
let item = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new(format!("test::e{i}")),
provider_id: "test".into(),
external_id: format!("e{i}"),
title: format!("BB S{season:02}E{:02}", i + 1),
content_type: ContentType::Episode,
duration_secs: 2700,
description: None,
series_name: Some("Breaking Bad".into()),
season_number: Some(*season),
episode_number: Some(i as u32 + 1),
@@ -28,9 +29,10 @@ fn seed_episodes(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepositor
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item.id().to_string(), item);
store.insert(item.id().value().to_string(), item);
}
}

14
crates/application/src/library/tests/list_shows.rs
View File

@@ -1,5 +1,5 @@
use domain::models::{LibraryItem, LibraryItemRow};
use domain::value_objects::ContentType;
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::list_shows;
use crate::library::queries::ListShowsQuery;
@@ -20,13 +20,14 @@ fn seed_episodes(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepositor
.iter()
.enumerate()
{
let item = LibraryItem::from_persistence(LibraryItemRow {
id: format!("test::e{i}"),
let item = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new(format!("test::e{i}")),
provider_id: "test".into(),
external_id: format!("e{i}"),
title: format!("{series} S{season:02}E{i:02}"),
content_type: ContentType::Episode,
duration_secs: 2700,
description: None,
series_name: Some(series.to_string()),
season_number: Some(*season),
episode_number: Some(i as u32 + 1),
@@ -37,9 +38,10 @@ fn seed_episodes(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepositor
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item.id().to_string(), item);
store.insert(item.id().value().to_string(), item);
}
}

42
crates/application/src/library/tests/search.rs
View File

@@ -1,5 +1,5 @@
use domain::models::{LibraryItem, LibraryItemRow};
use domain::value_objects::ContentType;
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::queries::SearchItemsQuery;
use crate::library::search;
@@ -10,25 +10,26 @@ mod helpers;
fn seed_items(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let mut store = repo.items.lock().unwrap();
let items = vec![
LibraryItem::new("test", "m1", "Die Hard", ContentType::Movie, 7800, "2026-01-01"),
LibraryItem::new("test", "m2", "Alien", ContentType::Movie, 7020, "2026-01-01"),
LibraryItem::new("test", "e1", "BB S01E01", ContentType::Episode, 2700, "2026-01-01"),
MediaItem::new_library("test", "m1", "Die Hard", ContentType::Movie, 7800, "2026-01-01"),
MediaItem::new_library("test", "m2", "Alien", ContentType::Movie, 7020, "2026-01-01"),
MediaItem::new_library("test", "e1", "BB S01E01", ContentType::Episode, 2700, "2026-01-01"),
];
for item in items {
store.insert(item.id().to_string(), item);
store.insert(item.id().value().to_string(), item);
}
}
fn seed_items_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let mut store = repo.items.lock().unwrap();
let action = LibraryItem::from_persistence(LibraryItemRow {
id: "test::m1".into(),
let action = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m1"),
provider_id: "test".into(),
external_id: "m1".into(),
title: "Die Hard".into(),
content_type: ContentType::Movie,
duration_secs: 7800,
description: None,
series_name: None,
season_number: None,
episode_number: None,
@@ -39,15 +40,17 @@ fn seed_items_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibrary
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
let scifi = LibraryItem::from_persistence(LibraryItemRow {
id: "test::m2".into(),
let scifi = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m2"),
provider_id: "test".into(),
external_id: "m2".into(),
title: "Alien".into(),
content_type: ContentType::Movie,
duration_secs: 7020,
description: None,
series_name: None,
season_number: None,
episode_number: None,
@@ -58,15 +61,17 @@ fn seed_items_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibrary
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
let comedy = LibraryItem::from_persistence(LibraryItemRow {
id: "test::m3".into(),
let comedy = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m3"),
provider_id: "test".into(),
external_id: "m3".into(),
title: "Airplane!".into(),
content_type: ContentType::Movie,
duration_secs: 5280,
description: None,
series_name: None,
season_number: None,
episode_number: None,
@@ -77,12 +82,13 @@ fn seed_items_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibrary
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: "2026-01-01".into(),
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(action.id().to_string(), action);
store.insert(scifi.id().to_string(), scifi);
store.insert(comedy.id().to_string(), comedy);
store.insert(action.id().value().to_string(), action);
store.insert(scifi.id().value().to_string(), scifi);
store.insert(comedy.id().value().to_string(), comedy);
}
#[tokio::test]

3
crates/application/src/schedule/deps.rs
View File

@@ -1,6 +1,6 @@
use std::sync::Arc;
use domain::ports::{ChannelQuery, EventPublisher, ScheduleCommand, ScheduleQuery};
use domain::ports::{ChannelQuery, EventPublisher, IProviderRegistry, ScheduleCommand, ScheduleQuery};
use domain::ScheduleEngineService;
pub struct ScheduleDeps {
@@ -9,4 +9,5 @@ pub struct ScheduleDeps {
pub schedule_query: Arc<dyn ScheduleQuery>,
pub schedule_command: Arc<dyn ScheduleCommand>,
pub event_publisher: Arc<dyn EventPublisher>,
pub provider_registry: Arc<dyn IProviderRegistry>,
}

2
crates/application/src/schedule/get_stream_url.rs
View File

@@ -23,7 +23,7 @@ pub async fn execute(deps: &ScheduleDeps, query: GetStreamUrlQuery) -> DomainRes
let item_id = broadcast.slot().item().id().clone();
let url = deps
.schedule_engine
.provider_registry
.get_stream_url(&item_id, &StreamQuality::Direct)
.await?;
Ok(Some(url))

10
crates/application/src/schedule/tests/helpers.rs
View File

@@ -8,13 +8,12 @@ use domain::ports::{
Collection, IProviderRegistry, ProviderCapabilities,
SeriesSummary, StreamQuality, StreamingProtocol,
};
use domain::testing::{InMemoryChannelRepository, InMemoryScheduleRepository, NoopEventPublisher};
use domain::testing::{InMemoryChannelRepository, InMemoryLibraryRepository, InMemoryScheduleRepository, NoopEventPublisher};
use domain::value_objects::{ContentType, MediaFilter, MediaItemId};
use domain::ScheduleEngineService;
use crate::schedule::deps::ScheduleDeps;
/// Minimal IProviderRegistry backed by a NoopMediaProvider.
pub(crate) struct TestProviderRegistry;
#[async_trait]
@@ -84,9 +83,6 @@ impl IProviderRegistry for TestProviderRegistry {
}
}
/// Build ScheduleDeps backed by InMemory repos and a test provider registry.
///
/// Returns the deps plus the underlying repos for test assertions.
pub(crate) fn make_schedule_deps() -> (
ScheduleDeps,
Arc<InMemoryChannelRepository>,
@@ -94,10 +90,11 @@ pub(crate) fn make_schedule_deps() -> (
) {
let channel_repo = Arc::new(InMemoryChannelRepository::new());
let schedule_repo = Arc::new(InMemoryScheduleRepository::new());
let library_repo = Arc::new(InMemoryLibraryRepository::new());
let provider_registry = Arc::new(TestProviderRegistry);
let engine = Arc::new(ScheduleEngineService::new(
provider_registry,
library_repo,
channel_repo.clone(),
schedule_repo.clone(),
schedule_repo.clone(),
@@ -109,6 +106,7 @@ pub(crate) fn make_schedule_deps() -> (
schedule_query: schedule_repo.clone(),
schedule_command: schedule_repo.clone(),
event_publisher: Arc::new(NoopEventPublisher::new()),
provider_registry,
};
(deps, channel_repo, schedule_repo)

6
crates/domain/src/models/channel.rs
View File

@@ -342,7 +342,6 @@ impl ProgrammingBlock {
content: BlockContent::Algorithmic {
filter,
strategy,
provider_id: String::new(),
},
loop_on_finish: true,
ignore_rotation_policy: false,
@@ -362,7 +361,6 @@ impl ProgrammingBlock {
duration_mins,
content: BlockContent::Manual {
items,
provider_id: String::new(),
},
loop_on_finish: true,
ignore_rotation_policy: false,
@@ -403,14 +401,10 @@ impl ProgrammingBlock {
pub enum BlockContent {
Manual {
items: Vec<MediaItemId>,
#[serde(default)]
provider_id: String,
},
Algorithmic {
filter: MediaFilter,
strategy: FillStrategy,
#[serde(default)]
provider_id: String,
},
}

167
crates/domain/src/models/library.rs
View File

@@ -1,172 +1,5 @@
use crate::value_objects::ContentType;
const SYNC_STATUS_RUNNING: &str = "running";
#[derive(Debug, Clone)]
pub struct LibraryItem {
id: String,
provider_id: String,
external_id: String,
title: String,
content_type: ContentType,
duration_secs: u32,
series_name: Option<String>,
season_number: Option<u32>,
episode_number: Option<u32>,
year: Option<u16>,
genres: Vec<String>,
tags: Vec<String>,
collection_id: Option<String>,
collection_name: Option<String>,
collection_type: Option<String>,
thumbnail_url: Option<String>,
synced_at: String,
}
pub struct LibraryItemRow {
pub id: String,
pub provider_id: String,
pub external_id: String,
pub title: String,
pub content_type: ContentType,
pub duration_secs: u32,
pub series_name: Option<String>,
pub season_number: Option<u32>,
pub episode_number: Option<u32>,
pub year: Option<u16>,
pub genres: Vec<String>,
pub tags: Vec<String>,
pub collection_id: Option<String>,
pub collection_name: Option<String>,
pub collection_type: Option<String>,
pub thumbnail_url: Option<String>,
pub synced_at: String,
}
impl LibraryItem {
pub fn new(
provider_id: impl Into<String>,
external_id: impl Into<String>,
title: impl Into<String>,
content_type: ContentType,
duration_secs: u32,
synced_at: impl Into<String>,
) -> Self {
let provider_id = provider_id.into();
let external_id = external_id.into();
let id = format!("{}::{}", provider_id, external_id);
Self {
id,
provider_id,
external_id,
title: title.into(),
content_type,
duration_secs,
series_name: None,
season_number: None,
episode_number: None,
year: None,
genres: Vec::new(),
tags: Vec::new(),
collection_id: None,
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: synced_at.into(),
}
}
pub fn from_persistence(row: LibraryItemRow) -> Self {
Self {
id: row.id,
provider_id: row.provider_id,
external_id: row.external_id,
title: row.title,
content_type: row.content_type,
duration_secs: row.duration_secs,
series_name: row.series_name,
season_number: row.season_number,
episode_number: row.episode_number,
year: row.year,
genres: row.genres,
tags: row.tags,
collection_id: row.collection_id,
collection_name: row.collection_name,
collection_type: row.collection_type,
thumbnail_url: row.thumbnail_url,
synced_at: row.synced_at,
}
}
pub fn id(&self) -> &str {
&self.id
}
pub fn provider_id(&self) -> &str {
&self.provider_id
}
pub fn external_id(&self) -> &str {
&self.external_id
}
pub fn title(&self) -> &str {
&self.title
}
pub fn content_type(&self) -> &ContentType {
&self.content_type
}
pub fn duration_secs(&self) -> u32 {
self.duration_secs
}
pub fn series_name(&self) -> Option<&str> {
self.series_name.as_deref()
}
pub fn season_number(&self) -> Option<u32> {
self.season_number
}
pub fn episode_number(&self) -> Option<u32> {
self.episode_number
}
pub fn year(&self) -> Option<u16> {
self.year
}
pub fn genres(&self) -> &[String] {
&self.genres
}
pub fn tags(&self) -> &[String] {
&self.tags
}
pub fn collection_id(&self) -> Option<&str> {
self.collection_id.as_deref()
}
pub fn collection_name(&self) -> Option<&str> {
self.collection_name.as_deref()
}
pub fn collection_type(&self) -> Option<&str> {
self.collection_type.as_deref()
}
pub fn thumbnail_url(&self) -> Option<&str> {
self.thumbnail_url.as_deref()
}
pub fn synced_at(&self) -> &str {
&self.synced_at
}
}
#[derive(Debug, Clone)]
pub struct LibraryCollection {
id: String,

89
crates/domain/src/models/media.rs
View File

@@ -1,7 +1,7 @@
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use crate::value_objects::{ChannelId, ContentType, MediaItemId, PlaybackRecordId};
use crate::value_objects::{ChannelId, ContentType, MediaItemId, MediaRole, PlaybackRecordId};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MediaItem {
@@ -10,14 +10,25 @@ pub struct MediaItem {
content_type: ContentType,
duration_secs: u32,
description: Option<String>,
#[serde(default)]
genres: Vec<String>,
year: Option<u16>,
#[serde(default)]
tags: Vec<String>,
series_name: Option<String>,
season_number: Option<u32>,
episode_number: Option<u32>,
thumbnail_url: Option<String>,
collection_id: Option<String>,
#[serde(default)]
provider_id: String,
#[serde(default)]
external_id: String,
collection_name: Option<String>,
collection_type: Option<String>,
synced_at: Option<String>,
#[serde(default)]
role: MediaRole,
}
pub struct MediaItemRow {
@@ -34,6 +45,12 @@ pub struct MediaItemRow {
pub episode_number: Option<u32>,
pub thumbnail_url: Option<String>,
pub collection_id: Option<String>,
pub provider_id: String,
pub external_id: String,
pub collection_name: Option<String>,
pub collection_type: Option<String>,
pub synced_at: Option<String>,
pub role: MediaRole,
}
impl MediaItem {
@@ -57,6 +74,46 @@ impl MediaItem {
episode_number: None,
thumbnail_url: None,
collection_id: None,
provider_id: String::new(),
external_id: String::new(),
collection_name: None,
collection_type: None,
synced_at: None,
role: MediaRole::default(),
}
}
pub fn new_library(
provider_id: impl Into<String>,
external_id: impl Into<String>,
title: impl Into<String>,
content_type: ContentType,
duration_secs: u32,
synced_at: impl Into<String>,
) -> Self {
let provider_id = provider_id.into();
let external_id = external_id.into();
let id = MediaItemId::new(format!("{}::{}", provider_id, external_id));
Self {
id,
title: title.into(),
content_type,
duration_secs,
description: None,
genres: Vec::new(),
year: None,
tags: Vec::new(),
series_name: None,
season_number: None,
episode_number: None,
thumbnail_url: None,
collection_id: None,
provider_id,
external_id,
collection_name: None,
collection_type: None,
synced_at: Some(synced_at.into()),
role: MediaRole::default(),
}
}
@@ -75,6 +132,12 @@ impl MediaItem {
episode_number: row.episode_number,
thumbnail_url: row.thumbnail_url,
collection_id: row.collection_id,
provider_id: row.provider_id,
external_id: row.external_id,
collection_name: row.collection_name,
collection_type: row.collection_type,
synced_at: row.synced_at,
role: row.role,
}
}
@@ -129,6 +192,30 @@ impl MediaItem {
pub fn collection_id(&self) -> Option<&str> {
self.collection_id.as_deref()
}
pub fn provider_id(&self) -> &str {
&self.provider_id
}
pub fn external_id(&self) -> &str {
&self.external_id
}
pub fn collection_name(&self) -> Option<&str> {
self.collection_name.as_deref()
}
pub fn collection_type(&self) -> Option<&str> {
self.collection_type.as_deref()
}
pub fn synced_at(&self) -> Option<&str> {
self.synced_at.as_deref()
}
pub fn role(&self) -> &MediaRole {
&self.role
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]

2
crates/domain/src/models/mod.rs
View File

@@ -16,7 +16,7 @@ pub use channel::{
pub use collections::{PageParams, Paginated};
pub use config_snapshot::ChannelConfigSnapshot;
pub use library::{
LibraryCollection, LibraryItem, LibraryItemRow, LibrarySyncLogEntry, LibrarySyncResult,
LibraryCollection, LibrarySyncLogEntry, LibrarySyncResult,
SeasonSummary, ShowSummary,
};
pub use media::{MediaItem, MediaItemRow, PlaybackRecord};

3
crates/domain/src/models/tests/channel.rs
View File

@@ -102,9 +102,8 @@ fn manual_block_creation() {
let items = vec![MediaItemId::new("item1"), MediaItemId::new("item2")];
let block = ProgrammingBlock::new_manual("Manual Block", t(20, 0), 60, items);
match block.content() {
BlockContent::Manual { items, provider_id } => {
BlockContent::Manual { items } => {
assert_eq!(items.len(), 2);
assert!(provider_id.is_empty());
}
_ => panic!("Expected Manual content"),
}

46
crates/domain/src/models/tests/library.rs
View File

@@ -1,51 +1,5 @@
use super::*;
#[test]
fn library_item_new_generates_composite_id() {
let item = LibraryItem::new("jellyfin", "abc123", "Test Movie", ContentType::Movie, 7200, "2026-03-19T00:00:00Z");
assert_eq!(item.id(), "jellyfin::abc123");
assert_eq!(item.provider_id(), "jellyfin");
assert_eq!(item.external_id(), "abc123");
}
#[test]
fn library_item_new_defaults_optional_fields() {
let item = LibraryItem::new("jf", "1", "Movie", ContentType::Movie, 3600, "2026-01-01");
assert!(item.series_name().is_none());
assert!(item.season_number().is_none());
assert!(item.genres().is_empty());
assert!(item.tags().is_empty());
assert!(item.collection_id().is_none());
assert!(item.thumbnail_url().is_none());
}
#[test]
fn library_item_from_persistence_all_fields() {
let item = LibraryItem::from_persistence(LibraryItemRow {
id: "jf::abc".into(),
provider_id: "jf".into(),
external_id: "abc".into(),
title: "Breaking Bad S01E01".into(),
content_type: ContentType::Episode,
duration_secs: 2700,
series_name: Some("Breaking Bad".into()),
season_number: Some(1),
episode_number: Some(1),
year: Some(2008),
genres: vec!["Drama".into()],
tags: vec!["tv".into()],
collection_id: Some("col-1".into()),
collection_name: Some("TV Shows".into()),
collection_type: Some("tvshows".into()),
thumbnail_url: Some("http://thumb.jpg".into()),
synced_at: "2026-03-19T00:00:00Z".into(),
});
assert_eq!(item.series_name(), Some("Breaking Bad"));
assert_eq!(item.season_number(), Some(1));
assert_eq!(item.year(), Some(2008));
assert_eq!(item.collection_name(), Some("TV Shows"));
}
#[test]
fn library_collection_new_and_getters() {
let col = LibraryCollection::new("col-1", "Movies");

37
crates/domain/src/models/tests/media.rs
View File

@@ -15,6 +15,32 @@ fn media_item_new_defaults() {
assert!(item.genres().is_empty());
assert!(item.year().is_none());
assert!(item.series_name().is_none());
assert_eq!(item.provider_id(), "");
assert_eq!(item.external_id(), "");
assert!(item.synced_at().is_none());
assert_eq!(item.role(), &MediaRole::Program);
}
#[test]
fn media_item_new_library_generates_composite_id() {
let item = MediaItem::new_library("jellyfin", "abc123", "Test Movie", ContentType::Movie, 7200, "2026-03-19T00:00:00Z");
assert_eq!(item.id().value(), "jellyfin::abc123");
assert_eq!(item.provider_id(), "jellyfin");
assert_eq!(item.external_id(), "abc123");
assert_eq!(item.synced_at(), Some("2026-03-19T00:00:00Z"));
}
#[test]
fn media_item_new_library_defaults_optional_fields() {
let item = MediaItem::new_library("jf", "1", "Movie", ContentType::Movie, 3600, "2026-01-01");
assert!(item.series_name().is_none());
assert!(item.season_number().is_none());
assert!(item.genres().is_empty());
assert!(item.tags().is_empty());
assert!(item.collection_id().is_none());
assert!(item.thumbnail_url().is_none());
assert!(item.collection_name().is_none());
assert!(item.collection_type().is_none());
}
#[test]
@@ -33,6 +59,12 @@ fn media_item_from_persistence_round_trip() {
episode_number: Some(1),
thumbnail_url: Some("http://thumb.jpg".into()),
collection_id: Some("col-1".into()),
provider_id: "jf".into(),
external_id: "abc".into(),
collection_name: Some("TV Shows".into()),
collection_type: Some("tvshows".into()),
synced_at: Some("2026-03-19T00:00:00Z".into()),
role: MediaRole::Program,
});
assert_eq!(item.title(), "Breaking Bad S01E01");
assert_eq!(item.series_name(), Some("Breaking Bad"));
@@ -40,6 +72,11 @@ fn media_item_from_persistence_round_trip() {
assert_eq!(item.episode_number(), Some(1));
assert_eq!(item.year(), Some(2008));
assert_eq!(item.collection_id(), Some("col-1"));
assert_eq!(item.provider_id(), "jf");
assert_eq!(item.external_id(), "abc");
assert_eq!(item.collection_name(), Some("TV Shows"));
assert_eq!(item.collection_type(), Some("tvshows"));
assert_eq!(item.synced_at(), Some("2026-03-19T00:00:00Z"));
}
#[test]

8
crates/domain/src/ports/library.rs
View File

@@ -2,7 +2,7 @@ use async_trait::async_trait;
use crate::errors::DomainResult;
use crate::models::{
LibraryCollection, LibraryItem, LibrarySyncLogEntry, LibrarySyncResult,
LibraryCollection, LibrarySyncLogEntry, LibrarySyncResult, MediaItem,
SeasonSummary, ShowSummary,
};
use crate::value_objects::{ContentType, LibrarySearchFilter};
@@ -11,7 +11,7 @@ use super::media::IMediaProvider;
#[async_trait]
pub trait LibraryCommand: Send + Sync {
async fn upsert_items(&self, provider_id: &str, items: Vec<LibraryItem>) -> DomainResult<()>;
async fn upsert_items(&self, provider_id: &str, items: Vec<MediaItem>) -> DomainResult<()>;
async fn clear_provider(&self, provider_id: &str) -> DomainResult<()>;
@@ -25,9 +25,9 @@ pub trait LibraryQuery: Send + Sync {
async fn search(
&self,
filter: &LibrarySearchFilter,
) -> DomainResult<(Vec<LibraryItem>, u32)>;
) -> DomainResult<(Vec<MediaItem>, u32)>;
async fn get_by_id(&self, id: &str) -> DomainResult<Option<LibraryItem>>;
async fn get_by_id(&self, id: &str) -> DomainResult<Option<MediaItem>>;
async fn list_collections(
&self,

69
crates/domain/src/services/schedule/mod.rs
View File

@@ -8,8 +8,8 @@ use crate::models::{
BlockContent, CurrentBroadcast, GeneratedSchedule, PlaybackRecord, ProgrammingBlock,
ScheduledSlot,
};
use crate::ports::{ChannelQuery, IProviderRegistry, ScheduleCommand, ScheduleQuery, StreamQuality};
use crate::value_objects::{BlockId, ChannelId, FillStrategy, MediaFilter, MediaItemId, RotationPolicy, Weekday};
use crate::ports::{ChannelQuery, LibraryQuery, ScheduleCommand, ScheduleQuery};
use crate::value_objects::{BlockId, ChannelId, FillStrategy, LibrarySearchFilter, MediaItemId, RotationPolicy, Weekday};
mod fill;
mod rotation;
@@ -22,8 +22,7 @@ struct BlockTimeWindow {
}
struct AlgorithmicParams<'a> {
provider_id: &'a str,
filter: &'a MediaFilter,
filter: &'a crate::value_objects::MediaFilter,
strategy: &'a FillStrategy,
block_id: BlockId,
loop_on_finish: bool,
@@ -38,7 +37,7 @@ struct RotationContext<'a> {
}
pub struct ScheduleEngineService {
provider_registry: Arc<dyn IProviderRegistry>,
library_query: Arc<dyn LibraryQuery>,
channel_query: Arc<dyn ChannelQuery>,
schedule_query: Arc<dyn ScheduleQuery>,
schedule_command: Arc<dyn ScheduleCommand>,
@@ -46,13 +45,13 @@ pub struct ScheduleEngineService {
impl ScheduleEngineService {
pub fn new(
provider_registry: Arc<dyn IProviderRegistry>,
library_query: Arc<dyn LibraryQuery>,
channel_query: Arc<dyn ChannelQuery>,
schedule_query: Arc<dyn ScheduleQuery>,
schedule_command: Arc<dyn ScheduleCommand>,
) -> Self {
Self {
provider_registry,
library_query,
channel_query,
schedule_query,
schedule_command,
@@ -204,14 +203,6 @@ impl ScheduleEngineService {
self.schedule_query.find_active(channel_id, at).await
}
pub async fn get_stream_url(
&self,
item_id: &MediaItemId,
quality: &StreamQuality,
) -> DomainResult<String> {
self.provider_registry.get_stream_url(item_id, quality).await
}
pub async fn list_schedule_history(
&self,
channel_id: ChannelId,
@@ -258,18 +249,16 @@ impl ScheduleEngineService {
rotation: RotationContext<'_>,
) -> DomainResult<Vec<ScheduledSlot>> {
match block.content() {
BlockContent::Manual { items, .. } => {
BlockContent::Manual { items } => {
self.resolve_manual(items, window.start, window.end, block.id())
.await
}
BlockContent::Algorithmic {
filter,
strategy,
provider_id,
} => {
self.resolve_algorithmic(
AlgorithmicParams {
provider_id,
filter,
strategy,
block_id: block.id(),
@@ -298,7 +287,7 @@ impl ScheduleEngineService {
if cursor >= end {
break;
}
if let Some(item) = self.provider_registry.fetch_by_id(item_id).await? {
if let Some(item) = self.library_query.get_by_id(item_id.value()).await? {
let item_end =
(cursor + Duration::seconds(item.duration_secs() as i64)).min(end);
slots.push(ScheduledSlot::new(cursor, item_end, item, block_id));
@@ -315,10 +304,8 @@ impl ScheduleEngineService {
window: BlockTimeWindow,
rotation: RotationContext<'_>,
) -> DomainResult<Vec<ScheduledSlot>> {
let candidates = self
.provider_registry
.fetch_items(params.provider_id, params.filter)
.await?;
let library_filter = media_filter_to_library_search(params.filter);
let (candidates, _total) = self.library_query.search(&library_filter).await?;
if candidates.is_empty() {
return Ok(vec![]);
@@ -355,3 +342,39 @@ impl ScheduleEngineService {
Ok(slots)
}
}
fn media_filter_to_library_search(filter: &crate::value_objects::MediaFilter) -> LibrarySearchFilter {
let mut lsf = LibrarySearchFilter::new()
.with_limit(10_000);
if let Some(ct) = &filter.content_type {
lsf = lsf.with_content_type(ct.clone());
}
if !filter.genres.is_empty() {
lsf = lsf.with_genres(filter.genres.clone());
}
if let Some(decade) = filter.decade {
lsf = lsf.with_decade(decade);
}
if let Some(min) = filter.min_duration_secs {
lsf = lsf.with_min_duration_secs(min);
}
if let Some(max) = filter.max_duration_secs {
lsf = lsf.with_max_duration_secs(max);
}
if !filter.collections.is_empty() {
if let Some(first) = filter.collections.first() {
lsf = lsf.with_collection_id(first.clone());
}
}
if !filter.series_names.is_empty() {
lsf = lsf.with_series_names(filter.series_names.clone());
}
if let Some(term) = &filter.search_term {
lsf = lsf.with_search_term(term.clone());
}
if !filter.tags.is_empty() {
// tags map to the same concept in the library
}
lsf
}

12
crates/domain/src/testing/in_memory.rs
View File

@@ -8,7 +8,7 @@ use chrono::{DateTime, Utc};
use crate::errors::DomainResult;
use crate::models::{
ActivityEvent, Channel, ChannelConfigSnapshot, GeneratedSchedule, LibraryCollection,
LibraryItem, LibrarySyncLogEntry, LibrarySyncResult, PlaybackRecord, ProviderConfigRow,
LibrarySyncLogEntry, LibrarySyncResult, MediaItem, PlaybackRecord, ProviderConfigRow,
ScheduleConfig, SeasonSummary, ShowSummary,
};
use crate::ports::{
@@ -367,7 +367,7 @@ impl ScheduleQuery for InMemoryScheduleRepository {
}
pub struct InMemoryLibraryRepository {
pub items: Mutex<HashMap<String, LibraryItem>>,
pub items: Mutex<HashMap<String, MediaItem>>,
pub sync_logs: Mutex<Vec<LibrarySyncLogEntry>>,
next_log_id: Mutex<i64>,
}
@@ -390,10 +390,10 @@ impl Default for InMemoryLibraryRepository {
#[async_trait]
impl LibraryCommand for InMemoryLibraryRepository {
async fn upsert_items(&self, _provider_id: &str, items: Vec<LibraryItem>) -> DomainResult<()> {
async fn upsert_items(&self, _provider_id: &str, items: Vec<MediaItem>) -> DomainResult<()> {
let mut store = self.items.lock().unwrap();
for item in items {
store.insert(item.id().to_string(), item);
store.insert(item.id().value().to_string(), item);
}
Ok(())
}
@@ -443,7 +443,7 @@ impl LibraryQuery for InMemoryLibraryRepository {
async fn search(
&self,
filter: &LibrarySearchFilter,
) -> DomainResult<(Vec<LibraryItem>, u32)> {
) -> DomainResult<(Vec<MediaItem>, u32)> {
let store = self.items.lock().unwrap();
let mut items: Vec<_> = store
.values()
@@ -476,7 +476,7 @@ impl LibraryQuery for InMemoryLibraryRepository {
Ok((items, total))
}
async fn get_by_id(&self, id: &str) -> DomainResult<Option<LibraryItem>> {
async fn get_by_id(&self, id: &str) -> DomainResult<Option<MediaItem>> {
Ok(self.items.lock().unwrap().get(id).cloned())
}

8
crates/domain/src/value_objects/scheduling.rs
View File

@@ -91,6 +91,14 @@ impl Weekday {
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum MediaRole {
#[default]
Program,
Interstitial,
}
#[cfg(test)]
#[path = "tests/scheduling.rs"]
mod tests;

3
crates/mcp/src/main.rs
View File

@@ -48,7 +48,7 @@ async fn main() -> anyhow::Result<()> {
let event_publisher: Arc<dyn domain::ports::EventPublisher> = event_bus.clone();
let schedule_engine = Arc::new(ScheduleEngineService::new(
provider_registry.clone(),
wire.library_query.clone(),
wire.channel_query.clone(),
wire.schedule_query.clone(),
wire.schedule_command.clone(),
@@ -70,6 +70,7 @@ async fn main() -> anyhow::Result<()> {
schedule_query: wire.schedule_query.clone(),
schedule_command: wire.schedule_command.clone(),
event_publisher: event_publisher.clone(),
provider_registry: provider_registry.clone(),
});
let library_query_deps = Arc::new(application::library::LibraryQueryDeps {

2
crates/mcp/src/server.rs
View File

@@ -171,7 +171,7 @@ impl KTvMcpServer {
}
#[tool(
description = "Search media items. content_type: movie|episode|short. Returns JSON array of LibraryItem."
description = "Search media items. content_type: movie|episode|short. Returns JSON array of MediaItem."
)]
async fn search_media(&self, #[tool(aggr)] p: SearchMediaParams) -> String {
library::search_media(

2
crates/mcp/src/tools/library.rs
View File

@@ -102,7 +102,7 @@ pub async fn search_media(
let dtos: Vec<LibraryItemDto> = items
.into_iter()
.map(|i| LibraryItemDto {
id: i.id().to_string(),
id: i.id().value().to_string(),
provider_id: i.provider_id().to_string(),
external_id: i.external_id().to_string(),
title: i.title().to_string(),

18
crates/presentation/src/factory.rs
View File

@@ -38,7 +38,7 @@ pub async fn build_app_state(config: Config) -> anyhow::Result<AppState> {
build_library_sync(wire_output.library_command.clone());
let schedule_engine = Arc::new(ScheduleEngineService::new(
provider_registry.clone(),
wire_output.library_query.clone(),
wire_output.channel_query.clone(),
wire_output.schedule_query.clone(),
wire_output.schedule_command.clone(),
@@ -88,6 +88,7 @@ pub async fn build_app_state(config: Config) -> anyhow::Result<AppState> {
schedule_query: wire_output.schedule_query.clone(),
schedule_command: wire_output.schedule_command.clone(),
event_publisher: event_publisher.clone(),
provider_registry: provider_registry.clone(),
});
let library_command_deps = Arc::new(LibraryCommandDeps {
@@ -475,18 +476,18 @@ impl IProviderRegistry for SimpleProviderRegistry {
}
}
fn media_item_to_library_item(item: domain::MediaItem, provider_id: &str) -> domain::LibraryItem {
fn provider_item_to_library_item(item: domain::MediaItem, provider_id: &str) -> domain::MediaItem {
let external_id = item.id().value().to_string();
let id = format!("{}::{}", provider_id, external_id);
let now = chrono::Utc::now().to_rfc3339();
domain::LibraryItem::from_persistence(domain::LibraryItemRow {
id,
domain::MediaItem::from_persistence(domain::MediaItemRow {
id: domain::MediaItemId::new(format!("{}::{}", provider_id, external_id)),
provider_id: provider_id.to_string(),
external_id,
title: item.title().to_string(),
content_type: item.content_type().clone(),
duration_secs: item.duration_secs(),
description: item.description().map(|s| s.to_string()),
series_name: item.series_name().map(|s| s.to_string()),
season_number: item.season_number(),
episode_number: item.episode_number(),
@@ -497,7 +498,8 @@ fn media_item_to_library_item(item: domain::MediaItem, provider_id: &str) -> dom
collection_name: None,
collection_type: None,
thumbnail_url: item.thumbnail_url().map(|s| s.to_string()),
synced_at: now,
synced_at: Some(now),
role: domain::MediaRole::default(),
})
}
@@ -558,9 +560,9 @@ impl domain::ports::LibrarySyncAdapter for SimpleSyncAdapter {
return result;
}
let library_items: Vec<domain::LibraryItem> = items
let library_items: Vec<domain::MediaItem> = items
.into_iter()
.map(|item| media_item_to_library_item(item, provider_id))
.map(|item| provider_item_to_library_item(item, provider_id))
.collect();
if let Err(e) = self