code refactor

Reviewed-on: #26

crates/adapters/media-server/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "media-server"
+version = "0.1.0"
+edition.workspace = true
+
+[dependencies]
+domain = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }

crates/adapters/media-server/src/jellyfin.rs

@@ -0,0 +1,60 @@
+use domain::{errors::DomainError, models::ParsedPlaybackEvent, ports::MediaServerParser};
+use serde::Deserialize;
+
+pub struct JellyfinParser;
+
+impl MediaServerParser for JellyfinParser {
+    fn parse_playback_event(
+        &self,
+        body: &[u8],
+    ) -> Result<Option<ParsedPlaybackEvent>, DomainError> {
+        let payload: JellyfinPayload = serde_json::from_slice(body)
+            .map_err(|e| DomainError::ValidationError(format!("invalid Jellyfin payload: {e}")))?;
+
+        if payload.notification_type != "PlaybackStop" {
+            return Ok(None);
+        }
+
+        let item_type = payload.item_type.as_deref().unwrap_or("");
+        if item_type != "Movie" {
+            return Ok(None);
+        }
+
+        if !payload.played_to_completion.unwrap_or(false) {
+            return Ok(None);
+        }
+
+        let title = match payload.name {
+            Some(t) if !t.is_empty() => t,
+            _ => return Ok(None),
+        };
+
+        let tmdb_id = payload.provider_tmdb.map(|id| format!("tmdb:{id}"));
+        let imdb_id = payload.provider_imdb;
+
+        Ok(Some(ParsedPlaybackEvent {
+            title,
+            year: payload.year,
+            tmdb_id,
+            imdb_id,
+        }))
+    }
+}
+
+#[derive(Deserialize)]
+struct JellyfinPayload {
+    #[serde(rename = "NotificationType")]
+    notification_type: String,
+    #[serde(rename = "ItemType")]
+    item_type: Option<String>,
+    #[serde(rename = "Name")]
+    name: Option<String>,
+    #[serde(rename = "Year")]
+    year: Option<u16>,
+    #[serde(rename = "PlayedToCompletion")]
+    played_to_completion: Option<bool>,
+    #[serde(rename = "Provider_tmdb")]
+    provider_tmdb: Option<String>,
+    #[serde(rename = "Provider_imdb")]
+    provider_imdb: Option<String>,
+}

crates/adapters/media-server/src/lib.rs

@@ -0,0 +1,5 @@
+mod jellyfin;
+mod plex;
+
+pub use jellyfin::JellyfinParser;
+pub use plex::PlexParser;

crates/adapters/media-server/src/plex.rs

@@ -0,0 +1,70 @@
+use domain::{errors::DomainError, models::ParsedPlaybackEvent, ports::MediaServerParser};
+use serde::Deserialize;
+
+pub struct PlexParser;
+
+impl MediaServerParser for PlexParser {
+    fn parse_playback_event(
+        &self,
+        body: &[u8],
+    ) -> Result<Option<ParsedPlaybackEvent>, DomainError> {
+        let payload: PlexPayload = serde_json::from_slice(body)
+            .map_err(|e| DomainError::ValidationError(format!("invalid Plex payload: {e}")))?;
+
+        if payload.event != "media.scrobble" {
+            return Ok(None);
+        }
+
+        let metadata = match payload.metadata {
+            Some(m) => m,
+            None => return Ok(None),
+        };
+
+        if metadata.media_type != "movie" {
+            return Ok(None);
+        }
+
+        if metadata.title.is_empty() {
+            return Ok(None);
+        }
+
+        let mut tmdb_id = None;
+        let mut imdb_id = None;
+        for guid in &metadata.guids {
+            if let Some(id) = guid.id.strip_prefix("tmdb://") {
+                tmdb_id = Some(format!("tmdb:{id}"));
+            } else if let Some(id) = guid.id.strip_prefix("imdb://") {
+                imdb_id = Some(id.to_string());
+            }
+        }
+
+        Ok(Some(ParsedPlaybackEvent {
+            title: metadata.title,
+            year: metadata.year.map(|y| y as u16),
+            tmdb_id,
+            imdb_id,
+        }))
+    }
+}
+
+#[derive(Deserialize)]
+struct PlexPayload {
+    event: String,
+    #[serde(rename = "Metadata")]
+    metadata: Option<PlexMetadata>,
+}
+
+#[derive(Deserialize)]
+struct PlexMetadata {
+    #[serde(rename = "type")]
+    media_type: String,
+    title: String,
+    year: Option<i32>,
+    #[serde(rename = "Guid", default)]
+    guids: Vec<PlexGuid>,
+}
+
+#[derive(Deserialize)]
+struct PlexGuid {
+    id: String,
+}

crates/adapters/media-server/tests/jellyfin_parser_test.rs

@@ -0,0 +1,69 @@
+use domain::ports::MediaServerParser;
+use media_server::JellyfinParser;
+
+#[test]
+fn parses_valid_playback_stop() {
+    let body = serde_json::json!({
+        "NotificationType": "PlaybackStop",
+        "ItemType": "Movie",
+        "Name": "Blade Runner",
+        "Year": 1982,
+        "PlayedToCompletion": true,
+        "Provider_tmdb": "78",
+        "Provider_imdb": "tt0083658"
+    });
+    let parser = JellyfinParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    let event = result.expect("should parse");
+    assert_eq!(event.title, "Blade Runner");
+    assert_eq!(event.year, Some(1982));
+    assert_eq!(event.tmdb_id, Some("tmdb:78".into()));
+    assert_eq!(event.imdb_id, Some("tt0083658".into()));
+}
+
+#[test]
+fn ignores_non_movie() {
+    let body = serde_json::json!({
+        "NotificationType": "PlaybackStop",
+        "ItemType": "Episode",
+        "Name": "Some Episode",
+        "PlayedToCompletion": true
+    });
+    let parser = JellyfinParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    assert!(result.is_none());
+}
+
+#[test]
+fn ignores_incomplete_playback() {
+    let body = serde_json::json!({
+        "NotificationType": "PlaybackStop",
+        "ItemType": "Movie",
+        "Name": "Blade Runner",
+        "PlayedToCompletion": false
+    });
+    let parser = JellyfinParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    assert!(result.is_none());
+}
+
+#[test]
+fn ignores_playback_start() {
+    let body = serde_json::json!({
+        "NotificationType": "PlaybackStart",
+        "ItemType": "Movie",
+        "Name": "Blade Runner",
+        "PlayedToCompletion": false
+    });
+    let parser = JellyfinParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    assert!(result.is_none());
+}

crates/adapters/media-server/tests/plex_parser_test.rs

@@ -0,0 +1,96 @@
+use domain::ports::MediaServerParser;
+use media_server::PlexParser;
+
+#[test]
+fn parses_movie_scrobble() {
+    let body = serde_json::json!({
+        "event": "media.scrobble",
+        "Metadata": {
+            "type": "movie",
+            "title": "Blade Runner",
+            "year": 1982,
+            "Guid": [
+                {"id": "tmdb://78"},
+                {"id": "imdb://tt0083658"}
+            ]
+        }
+    });
+    let parser = PlexParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    let event = result.expect("should parse");
+    assert_eq!(event.title, "Blade Runner");
+    assert_eq!(event.year, Some(1982));
+    assert_eq!(event.tmdb_id, Some("tmdb:78".into()));
+    assert_eq!(event.imdb_id, Some("tt0083658".into()));
+}
+
+#[test]
+fn ignores_tv_episode() {
+    let body = serde_json::json!({
+        "event": "media.scrobble",
+        "Metadata": {
+            "type": "episode",
+            "title": "Pilot",
+            "grandparentTitle": "Breaking Bad",
+            "year": 2008,
+            "Guid": []
+        }
+    });
+    let parser = PlexParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    assert!(result.is_none());
+}
+
+#[test]
+fn ignores_play_event() {
+    let body = serde_json::json!({
+        "event": "media.play",
+        "Metadata": {
+            "type": "movie",
+            "title": "Blade Runner",
+            "year": 1982,
+            "Guid": []
+        }
+    });
+    let parser = PlexParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    assert!(result.is_none());
+}
+
+#[test]
+fn handles_no_guids() {
+    let body = serde_json::json!({
+        "event": "media.scrobble",
+        "Metadata": {
+            "type": "movie",
+            "title": "Some Indie Film",
+            "year": 2023
+        }
+    });
+    let parser = PlexParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    let event = result.expect("should parse");
+    assert_eq!(event.title, "Some Indie Film");
+    assert!(event.tmdb_id.is_none());
+    assert!(event.imdb_id.is_none());
+}
+
+#[test]
+fn handles_missing_metadata() {
+    let body = serde_json::json!({
+        "event": "media.scrobble"
+    });
+    let parser = PlexParser;
+    let result = parser
+        .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
+        .unwrap();
+    assert!(result.is_none());
+}