304 lines
9.6 KiB
Rust
304 lines
9.6 KiB
Rust
//! Domain entities
|
|
//!
|
|
//! This module contains pure domain types with no I/O dependencies.
|
|
//! These represent the core business concepts of the application.
|
|
|
|
pub use crate::value_objects::{Email, UserId};
|
|
use chrono::{DateTime, NaiveTime, Timelike, Utc};
|
|
use serde::{Deserialize, Serialize};
|
|
use uuid::Uuid;
|
|
|
|
use crate::value_objects::{
|
|
BlockId, ChannelId, ContentType, FillStrategy, MediaFilter, MediaItemId, RecyclePolicy, SlotId,
|
|
};
|
|
|
|
/// A user in the system.
|
|
///
|
|
/// Designed to be OIDC-ready: the `subject` field stores the OIDC subject claim
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct User {
|
|
pub id: UserId,
|
|
pub subject: String,
|
|
pub email: Email,
|
|
pub password_hash: Option<String>,
|
|
pub created_at: DateTime<Utc>,
|
|
}
|
|
|
|
impl User {
|
|
pub fn new(subject: impl Into<String>, email: Email) -> Self {
|
|
Self {
|
|
id: Uuid::new_v4(),
|
|
subject: subject.into(),
|
|
email,
|
|
password_hash: None,
|
|
created_at: Utc::now(),
|
|
}
|
|
}
|
|
|
|
pub fn with_id(
|
|
id: Uuid,
|
|
subject: impl Into<String>,
|
|
email: Email,
|
|
password_hash: Option<String>,
|
|
created_at: DateTime<Utc>,
|
|
) -> Self {
|
|
Self {
|
|
id,
|
|
subject: subject.into(),
|
|
email,
|
|
password_hash,
|
|
created_at,
|
|
}
|
|
}
|
|
|
|
pub fn new_local(email: Email, password_hash: impl Into<String>) -> Self {
|
|
Self {
|
|
id: Uuid::new_v4(),
|
|
subject: format!("local|{}", Uuid::new_v4()),
|
|
email,
|
|
password_hash: Some(password_hash.into()),
|
|
created_at: Utc::now(),
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Channel
|
|
// ============================================================================
|
|
|
|
/// A broadcast channel owned by a user.
|
|
///
|
|
/// Holds the user-designed `ScheduleConfig` (the template) and `RecyclePolicy`.
|
|
/// The engine consumes these to produce a concrete `GeneratedSchedule`.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Channel {
|
|
pub id: ChannelId,
|
|
pub owner_id: UserId,
|
|
pub name: String,
|
|
pub description: Option<String>,
|
|
/// IANA timezone string, e.g. `"America/New_York"`. All `start_time` fields
|
|
/// inside `ScheduleConfig` are interpreted in this timezone.
|
|
pub timezone: String,
|
|
pub schedule_config: ScheduleConfig,
|
|
pub recycle_policy: RecyclePolicy,
|
|
pub created_at: DateTime<Utc>,
|
|
pub updated_at: DateTime<Utc>,
|
|
}
|
|
|
|
impl Channel {
|
|
pub fn new(
|
|
owner_id: UserId,
|
|
name: impl Into<String>,
|
|
timezone: impl Into<String>,
|
|
) -> Self {
|
|
let now = Utc::now();
|
|
Self {
|
|
id: Uuid::new_v4(),
|
|
owner_id,
|
|
name: name.into(),
|
|
description: None,
|
|
timezone: timezone.into(),
|
|
schedule_config: ScheduleConfig::default(),
|
|
recycle_policy: RecyclePolicy::default(),
|
|
created_at: now,
|
|
updated_at: now,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The user-designed programming template.
|
|
///
|
|
/// This is the shareable/exportable part of a channel. It contains an ordered
|
|
/// list of `ProgrammingBlock`s but makes no assumptions about the media source.
|
|
/// A channel does not need to cover all 24 hours — gaps are valid and render
|
|
/// as a no-signal state on the client.
|
|
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
|
|
pub struct ScheduleConfig {
|
|
pub blocks: Vec<ProgrammingBlock>,
|
|
}
|
|
|
|
impl ScheduleConfig {
|
|
/// Return the block whose time window contains `time`, if any.
|
|
///
|
|
/// Handles blocks that span midnight (e.g. start 23:00, duration 180 min).
|
|
pub fn find_block_at(&self, time: NaiveTime) -> Option<&ProgrammingBlock> {
|
|
let secs = time.num_seconds_from_midnight();
|
|
self.blocks.iter().find(|block| {
|
|
let start = block.start_time.num_seconds_from_midnight();
|
|
let end = start + block.duration_mins * 60;
|
|
if end <= 86_400 {
|
|
secs >= start && secs < end
|
|
} else {
|
|
// Block crosses midnight: active from `start` to `end % 86400` next day
|
|
secs >= start || secs < (end % 86_400)
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Return the start time of the next block that begins strictly after `time`,
|
|
/// within the same calendar day.
|
|
pub fn next_block_start_after(&self, time: NaiveTime) -> Option<NaiveTime> {
|
|
let secs = time.num_seconds_from_midnight();
|
|
self.blocks
|
|
.iter()
|
|
.map(|b| b.start_time.num_seconds_from_midnight())
|
|
.filter(|&s| s > secs)
|
|
.min()
|
|
.and_then(|s| NaiveTime::from_num_seconds_from_midnight_opt(s, 0))
|
|
}
|
|
|
|
/// The earliest block start time across all blocks (used for next-day rollover).
|
|
pub fn earliest_block_start(&self) -> Option<NaiveTime> {
|
|
self.blocks.iter().map(|b| b.start_time).min()
|
|
}
|
|
}
|
|
|
|
/// A single programming rule within a `ScheduleConfig`.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct ProgrammingBlock {
|
|
pub id: BlockId,
|
|
pub name: String,
|
|
/// Local time of day (in the channel's timezone) when this block starts.
|
|
pub start_time: NaiveTime,
|
|
/// Target duration in minutes. The engine fills this window as closely as
|
|
/// possible; remaining time at the end becomes dead air (no-signal).
|
|
pub duration_mins: u32,
|
|
pub content: BlockContent,
|
|
}
|
|
|
|
impl ProgrammingBlock {
|
|
pub fn new_algorithmic(
|
|
name: impl Into<String>,
|
|
start_time: NaiveTime,
|
|
duration_mins: u32,
|
|
filter: MediaFilter,
|
|
strategy: FillStrategy,
|
|
) -> Self {
|
|
Self {
|
|
id: Uuid::new_v4(),
|
|
name: name.into(),
|
|
start_time,
|
|
duration_mins,
|
|
content: BlockContent::Algorithmic { filter, strategy },
|
|
}
|
|
}
|
|
|
|
pub fn new_manual(
|
|
name: impl Into<String>,
|
|
start_time: NaiveTime,
|
|
duration_mins: u32,
|
|
items: Vec<MediaItemId>,
|
|
) -> Self {
|
|
Self {
|
|
id: Uuid::new_v4(),
|
|
name: name.into(),
|
|
start_time,
|
|
duration_mins,
|
|
content: BlockContent::Manual { items },
|
|
}
|
|
}
|
|
}
|
|
|
|
/// How the content of a `ProgrammingBlock` is determined.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(tag = "type", rename_all = "snake_case")]
|
|
pub enum BlockContent {
|
|
/// The user hand-picked specific items in a specific order.
|
|
Manual { items: Vec<MediaItemId> },
|
|
/// The engine selects items from the provider using the given filter and strategy.
|
|
Algorithmic {
|
|
filter: MediaFilter,
|
|
strategy: FillStrategy,
|
|
},
|
|
}
|
|
|
|
// ============================================================================
|
|
// Media / Schedule resolution types
|
|
// ============================================================================
|
|
|
|
/// A snapshot of a media item's metadata at schedule-generation time.
|
|
///
|
|
/// Stream URLs are intentionally absent — they are fetched on-demand from the
|
|
/// provider at tune-in time so they stay fresh and provider-agnostic.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct MediaItem {
|
|
pub id: MediaItemId,
|
|
pub title: String,
|
|
pub content_type: ContentType,
|
|
pub duration_secs: u32,
|
|
pub description: Option<String>,
|
|
pub genres: Vec<String>,
|
|
pub year: Option<u16>,
|
|
pub tags: Vec<String>,
|
|
/// For episodes: the parent TV show name.
|
|
pub series_name: Option<String>,
|
|
/// For episodes: season number (1-based).
|
|
pub season_number: Option<u32>,
|
|
/// For episodes: episode number within the season (1-based).
|
|
pub episode_number: Option<u32>,
|
|
}
|
|
|
|
/// A fully resolved 48-hour broadcast program for one channel.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct GeneratedSchedule {
|
|
pub id: Uuid,
|
|
pub channel_id: ChannelId,
|
|
pub valid_from: DateTime<Utc>,
|
|
pub valid_until: DateTime<Utc>,
|
|
/// Monotonically increasing counter per channel, used by `RecyclePolicy`.
|
|
pub generation: u32,
|
|
/// Resolved slots, sorted ascending by `start_at`.
|
|
pub slots: Vec<ScheduledSlot>,
|
|
}
|
|
|
|
impl GeneratedSchedule {
|
|
pub fn is_active_at(&self, time: DateTime<Utc>) -> bool {
|
|
time >= self.valid_from && time < self.valid_until
|
|
}
|
|
}
|
|
|
|
/// A single resolved broadcast moment within a `GeneratedSchedule`.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct ScheduledSlot {
|
|
pub id: SlotId,
|
|
pub start_at: DateTime<Utc>,
|
|
pub end_at: DateTime<Utc>,
|
|
/// Metadata snapshot captured at schedule-generation time.
|
|
pub item: MediaItem,
|
|
/// Which `ProgrammingBlock` rule produced this slot.
|
|
pub source_block_id: BlockId,
|
|
}
|
|
|
|
/// What is currently broadcasting on a channel — derived from `GeneratedSchedule`
|
|
/// and the wall clock. Never stored. `None` means no block is scheduled right now
|
|
/// (dead air / no-signal).
|
|
#[derive(Debug, Clone)]
|
|
pub struct CurrentBroadcast {
|
|
pub slot: ScheduledSlot,
|
|
/// Seconds elapsed since the start of the current item.
|
|
pub offset_secs: u32,
|
|
}
|
|
|
|
/// Records that an item was aired on a channel. Persisted to drive `RecyclePolicy`.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct PlaybackRecord {
|
|
pub id: Uuid,
|
|
pub channel_id: ChannelId,
|
|
pub item_id: MediaItemId,
|
|
pub played_at: DateTime<Utc>,
|
|
/// The generation of the schedule that scheduled this play.
|
|
pub generation: u32,
|
|
}
|
|
|
|
impl PlaybackRecord {
|
|
pub fn new(channel_id: ChannelId, item_id: MediaItemId, generation: u32) -> Self {
|
|
Self {
|
|
id: Uuid::new_v4(),
|
|
channel_id,
|
|
item_id,
|
|
played_at: Utc::now(),
|
|
generation,
|
|
}
|
|
}
|
|
}
|