Fix parsing errors for some non-scrobble Plex webhooks

Author: Hamuko

src/main.rs

@@ -82,22 +82,28 @@ async fn scrobble(
     // Check that the webhook is something anifunnel can handle.
     match webhook.is_actionable(state.multi_season) {
         plex::WebhookState::Actionable => log::debug!("Webhook is actionable"),
+        plex::WebhookState::NoMetadata => {
+            error!("Webhook was a scrobble event but has no metadata. This should not happen.");
+            return "ERROR";
+        }
         plex::WebhookState::NonScrobbleEvent => {
             info!("Webhook is not a scrobble event");
             return "NO OP";
         }
         plex::WebhookState::IncorrectType => {
+            let metadata = webhook.metadata.unwrap();
             info!(
                 "Scrobble event for {} is for a non-episode media ({})",
-                &webhook.metadata.title, &webhook.metadata.media_type
+                &metadata.title, &metadata.media_type
             );
             return "NO OP";
         }
         plex::WebhookState::IncorrectSeason => {
+            let metadata = webhook.metadata.unwrap();
             info!(
                 "Scrobble event for {} is for a non-first season ({}). \
                 Enable multi-season matching if this is unexpected.",
-                &webhook.metadata.title, &webhook.metadata.season_number
+                &metadata.title, &metadata.season_number
             );
             return "NO OP";
         }
@@ -121,15 +127,17 @@ async fn scrobble(
     };
 
     if let Ok(media_list_entries) = anilist_client.get_watching_list().await {
-        let mut anime_override = db::get_override_by_title(&mut db, &webhook.metadata.title).await;
+        let metadata = webhook.metadata.unwrap();
+
+        let mut anime_override = db::get_override_by_title(&mut db, &metadata.title).await;
         let matched_media_list = match &anime_override {
             Some(o) => media_list_entries.find_id(&o.id),
-            None => media_list_entries.find_match(&webhook.metadata.title),
+            None => media_list_entries.find_match(&metadata.title),
         };
         let matched_media_list = match matched_media_list {
             Some(media_list) => media_list,
             None => {
-                debug!("Could not find a match for '{}'", &webhook.metadata.title);
+                debug!("Could not find a match for '{}'", &metadata.title);
                 return "NO OP";
             }
         };
@@ -142,7 +150,8 @@ async fn scrobble(
             Some(o) => o.get_episode_offset(),
             None => 0,
         };
-        if webhook.metadata.episode_number + episode_offset == matched_media_list.progress + 1 {
+
+        if metadata.episode_number + episode_offset == matched_media_list.progress + 1 {
             match anilist_client.update_progress(matched_media_list).await {
                 Ok(true) => info!("Updated '{}' progress", matched_media_list.media.title),
                 Ok(false) => error!(

src/plex.rs

@@ -1,4 +1,5 @@
-use serde::Deserialize;
+use serde::{Deserialize, Deserializer};
+use serde_json::Value;
 
 #[derive(Debug, Deserialize)]
 pub struct Webhook {
@@ -7,13 +8,27 @@ pub struct Webhook {
     #[serde(rename = "Account")]
     pub account: WebhookAccount,
 
-    #[serde(rename = "Metadata")]
-    pub metadata: WebhookMetadata,
+    #[serde(
+        default,
+        rename = "Metadata",
+        deserialize_with = "webhook_metadata_wrapper"
+    )]
+    pub metadata: Option<WebhookMetadata>,
+}
+
+/// Convert incomplete metadata into None for non-scrobble events.
+fn webhook_metadata_wrapper<'de, D>(deserializer: D) -> Result<Option<WebhookMetadata>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let v: Value = Deserialize::deserialize(deserializer)?;
+    Ok(Option::deserialize(v).unwrap_or_default())
 }
 
 #[derive(Debug, PartialEq)]
 pub enum WebhookState {
     Actionable,
+    NoMetadata,
     NonScrobbleEvent,
     IncorrectSeason,
     IncorrectType,
@@ -24,12 +39,19 @@ impl Webhook {
         if self.event != "media.scrobble" {
             return WebhookState::NonScrobbleEvent;
         }
-        if self.metadata.media_type != "episode" {
+        let Some(metadata) = &self.metadata else {
+            // Metadata may not be present (or complete, which results in Webhook.metadata
+            // being None) in non-scrobble webhooks, but should always be present in
+            // scrobble events, meaning that this should never happen after checking the
+            // event, but we have it just in case.
+            return WebhookState::NoMetadata;
+        };
+        if metadata.media_type != "episode" {
             return WebhookState::IncorrectType;
         }
         let allowed_season = match multi_season {
-            true => self.metadata.season_number >= 1,
-            false => self.metadata.season_number == 1,
+            true => metadata.season_number >= 1,
+            false => metadata.season_number == 1,
         };
         if !allowed_season {
             return WebhookState::IncorrectSeason;
@@ -44,7 +66,7 @@ pub struct WebhookAccount {
     pub name: String,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, PartialEq)]
 pub struct WebhookMetadata {
     #[serde(rename = "type")]
     pub media_type: String,
@@ -63,19 +85,129 @@ pub struct WebhookMetadata {
 mod tests {
     use super::*;
 
+    #[test]
+    // admin.database.backup events have no Metadata object.
+    fn deserialize_admin_database_backup() {
+        let json = r#"
+            {
+                "event": "admin.database.backup",
+                "user": true,
+                "owner": true,
+                "Account": {
+                    "title": "Username"
+                },
+                "Server": {
+                    "title": "Example"
+                }
+            }
+        "#;
+        let webhook = serde_json::from_str::<Webhook>(json.into()).unwrap();
+        assert_eq!(webhook.event, "admin.database.backup");
+        assert_eq!(webhook.account.name, "Username");
+        assert_eq!(webhook.metadata, None);
+    }
+
+    #[test]
+    // library.new events have missing fields in the Metadata object.
+    fn deserialize_library_new() {
+        let json = r#"
+            {
+                "event": "library.new",
+                "user": true,
+                "owner": true,
+                "Account": {
+                    "title": "Username"
+                },
+                "Server": {
+                    "title": "Example"
+                },
+                "Metadata": {
+                    "index": 1,
+                    "title": "Chanto Suenai Kyuuketsuki-chan",
+                    "type": "show"
+                }
+            }
+        "#;
+        let webhook = serde_json::from_str::<Webhook>(json).unwrap();
+        assert_eq!(webhook.event, "library.new");
+        assert_eq!(webhook.account.name, "Username");
+        assert_eq!(webhook.metadata, None);
+    }
+
+    #[test]
+    fn deserialize_scrobble() {
+        let json = r#"
+            {
+                "event": "media.scrobble",
+                "user": true,
+                "owner": true,
+                "Account": {
+                    "title": "Username"
+                },
+                "Server": {
+                    "title": "Example"
+                },
+                "Metadata": {
+                    "grandparentTitle": "Chanto Suenai Kyuuketsuki-chan",
+                    "index": 2,
+                    "parentIndex": 1,
+                    "type": "episode"
+                }
+            }
+        "#;
+        let webhook = serde_json::from_str::<Webhook>(json).unwrap();
+        assert_eq!(webhook.event, "media.scrobble");
+        assert_eq!(webhook.account.name, "Username");
+        assert_eq!(
+            webhook.metadata,
+            Some(WebhookMetadata {
+                media_type: "episode".into(),
+                title: "Chanto Suenai Kyuuketsuki-chan".into(),
+                season_number: 1,
+                episode_number: 2,
+            })
+        );
+    }
+
+    #[test]
+    // Hypothetical media.scrobble event with missing fields in the Metadata object.
+    fn deserialize_scrobble_corrupted() {
+        let json = r#"
+            {
+                "event": "media.scrobble",
+                "user": true,
+                "owner": true,
+                "Account": {
+                    "title": "Username"
+                },
+                "Server": {
+                    "title": "Example"
+                },
+                "Metadata": {
+                    "grandparentTitle": "Chanto Suenai Kyuuketsuki-chan",
+                    "type": "episode"
+                }
+            }
+        "#;
+        let webhook = serde_json::from_str::<Webhook>(json).unwrap();
+        assert_eq!(webhook.event, "media.scrobble");
+        assert_eq!(webhook.account.name, "Username");
+        assert_eq!(webhook.metadata, None);
+    }
+
     #[test]
     fn webhook_actionable() {
         let webhook = Webhook {
             event: String::from("media.scrobble"),
             account: WebhookAccount {
                 name: String::from("yukikaze"),
             },
-            metadata: WebhookMetadata {
+            metadata: Some(WebhookMetadata {
                 media_type: String::from("episode"),
                 title: String::from("Onii-chan wa Oshimai!"),
                 season_number: 1,
                 episode_number: 4,
-            },
+            }),
         };
         assert_eq!(webhook.is_actionable(false), WebhookState::Actionable);
     }
@@ -88,12 +220,12 @@ mod tests {
             account: WebhookAccount {
                 name: String::from("yukikaze"),
             },
-            metadata: WebhookMetadata {
+            metadata: Some(WebhookMetadata {
                 media_type: String::from("episode"),
                 title: String::from("Onii-chan wa Oshimai!"),
                 season_number: 1,
                 episode_number: 1,
-            },
+            }),
         };
         assert_eq!(webhook.is_actionable(false), WebhookState::Actionable);
     }
@@ -106,16 +238,29 @@ mod tests {
             account: WebhookAccount {
                 name: String::from("yukikaze"),
             },
-            metadata: WebhookMetadata {
+            metadata: Some(WebhookMetadata {
                 media_type: String::from("track"),
                 title: String::from("Onii-chan wa Oshimai!"),
                 season_number: 1,
                 episode_number: 4,
-            },
+            }),
         };
         assert_eq!(webhook.is_actionable(false), WebhookState::IncorrectType);
     }
 
+    #[test]
+    // Scrobbles with unreadable Metadata objects are not actionable. Mostly hypothetical.
+    fn webhook_actionable_missing_metadata() {
+        let webhook = Webhook {
+            event: String::from("media.scrobble"),
+            account: WebhookAccount {
+                name: String::from("yukikaze"),
+            },
+            metadata: None,
+        };
+        assert_eq!(webhook.is_actionable(false), WebhookState::NoMetadata);
+    }
+
     #[test]
     // Only scrobble events trigger anifunnel.
     fn webhook_actionable_playback() {
@@ -124,12 +269,12 @@ mod tests {
             account: WebhookAccount {
                 name: String::from("yukikaze"),
             },
-            metadata: WebhookMetadata {
+            metadata: Some(WebhookMetadata {
                 media_type: String::from("episode"),
                 title: String::from("Onii-chan wa Oshimai!"),
                 season_number: 1,
                 episode_number: 4,
-            },
+            }),
         };
         assert_eq!(webhook.is_actionable(false), WebhookState::NonScrobbleEvent);
     }
@@ -142,12 +287,12 @@ mod tests {
             account: WebhookAccount {
                 name: String::from("yukikaze"),
             },
-            metadata: WebhookMetadata {
+            metadata: Some(WebhookMetadata {
                 media_type: String::from("episode"),
                 title: String::from("Kidou Senshi Gundam: Suisei no Majo"),
                 season_number: 2,
                 episode_number: 4,
-            },
+            }),
         };
         assert_eq!(webhook.is_actionable(false), WebhookState::IncorrectSeason);
     }
@@ -160,12 +305,12 @@ mod tests {
             account: WebhookAccount {
                 name: String::from("yukikaze"),
             },
-            metadata: WebhookMetadata {
+            metadata: Some(WebhookMetadata {
                 media_type: String::from("episode"),
                 title: String::from("Kidou Senshi Gundam: Suisei no Majo"),
                 season_number: 2,
                 episode_number: 4,
-            },
+            }),
         };
         assert_eq!(webhook.is_actionable(true), WebhookState::Actionable);
     }
@@ -178,12 +323,12 @@ mod tests {
             account: WebhookAccount {
                 name: String::from("yukikaze"),
             },
-            metadata: WebhookMetadata {
+            metadata: Some(WebhookMetadata {
                 media_type: String::from("episode"),
                 title: String::from("Bakemonogatari"),
                 season_number: 0,
                 episode_number: 3,
-            },
+            }),
         };
         assert_eq!(webhook.is_actionable(false), WebhookState::IncorrectSeason);
     }
@@ -196,12 +341,12 @@ mod tests {
             account: WebhookAccount {
                 name: String::from("yukikaze"),
             },
-            metadata: WebhookMetadata {
+            metadata: Some(WebhookMetadata {
                 media_type: String::from("episode"),
                 title: String::from("Bakemonogatari"),
                 season_number: 0,
                 episode_number: 3,
-            },
+            }),
         };
         assert_eq!(webhook.is_actionable(true), WebhookState::IncorrectSeason);
     }