feat(playmatch): support all metadata providers in commands and list

Author: DevYukine

src/abstraction/mod.rs

@@ -1,5 +1,5 @@
 pub mod activity_data;
 pub mod command;
 pub mod components_v2;
-pub mod igdb;
 pub mod playmatch;
+pub mod providers;

src/abstraction/playmatch.rs

@@ -1,11 +1,11 @@
 use crate::abstraction::command::{CommandContext, paginate};
 use crate::abstraction::components_v2::{self, Status};
+use crate::abstraction::providers::{ALL_PROVIDERS, short_label};
 use crate::util::create_discord_markdown_table;
 use log::warn;
 use playmatch_client::Error;
 use playmatch_client::types::{
-	CompanyMetadataResponse, ExternalMetadata, MetadataMatchType, MetadataProvider,
-	PlatformMetadataResponse,
+	CompanyMetadataResponse, ExternalMetadata, MetadataMatchType, PlatformMetadataResponse,
 };
 use reqwest::StatusCode;
 use uuid::Uuid;
@@ -99,43 +99,29 @@ where
 	const SUCCESS_EMOJI: &str = "✅";
 	const FAILURE_EMOJI: &str = "❌";
 
-	let default_headers: Vec<String> = vec![
-		"Name".to_string(),
-		"IGDB Match".to_string(),
-		"IGDB ID".to_string(),
-	];
+	let mut default_headers: Vec<String> = Vec::with_capacity(1 + ALL_PROVIDERS.len());
+	default_headers.push("Name".to_string());
+	for &provider in ALL_PROVIDERS {
+		default_headers.push(short_label(provider).to_string());
+	}
 
 	let mapped_markdown_rows = input
 		.into_iter()
 		.map(|c| {
 			let external_metadata = c.get_external_metadata();
-			let igdb_mapping = external_metadata
-				.iter()
-				.find(|ex| ex.provider_name == MetadataProvider::Igdb);
-
-			let is_igdb_matched = if let Some(igdb_mapping) = igdb_mapping {
-				match igdb_mapping.match_type {
-					MetadataMatchType::Automatic | MetadataMatchType::Manual => true,
-					MetadataMatchType::Failed | MetadataMatchType::None => false,
-				}
-			} else {
-				false
-			};
-
-			let igdb_id = igdb_mapping
-				.and_then(|ex| ex.provider_id.clone())
-				.unwrap_or("".to_string());
-
-			vec![
-				c.get_name(),
-				if is_igdb_matched {
-					SUCCESS_EMOJI
-				} else {
-					FAILURE_EMOJI
-				}
-				.to_string(),
-				igdb_id,
-			]
+			let mut row = Vec::with_capacity(1 + ALL_PROVIDERS.len());
+			row.push(c.get_name());
+			for &provider in ALL_PROVIDERS {
+				let matched = external_metadata.iter().any(|ex| {
+					ex.provider_name == provider
+						&& matches!(
+							ex.match_type,
+							MetadataMatchType::Automatic | MetadataMatchType::Manual
+						)
+				});
+				row.push(if matched { SUCCESS_EMOJI } else { FAILURE_EMOJI }.to_string());
+			}
+			row
 		})
 		.collect::<Vec<Vec<String>>>();
 

src/abstraction/igdb.rs src/abstraction/providers/igdb.rssrc/abstraction/igdb.rs renamed to src/abstraction/providers/igdb.rs

@@ -1,31 +1,9 @@
 use chrono::{DateTime, Utc};
 use log::{debug, warn};
 use playmatch_client::Client;
+use playmatch_client::types::MetadataProvider;
 
-pub struct IgdbGameInfo {
-	pub name: String,
-	pub page_url: String,
-	pub summary: Option<String>,
-	pub first_release_date: Option<DateTime<Utc>>,
-	pub cover_url: Option<String>,
-	pub screenshot_urls: Vec<String>,
-}
-
-pub struct IgdbCompanyInfo {
-	pub name: String,
-	pub page_url: Option<String>,
-	pub logo_url: Option<String>,
-	pub description: Option<String>,
-}
-
-pub struct IgdbPlatformInfo {
-	pub name: String,
-	pub page_url: String,
-	pub logo_url: Option<String>,
-	pub summary: Option<String>,
-}
-
-const SUMMARY_MAX: usize = 280;
+use super::{ProviderCompanyInfo, ProviderGameInfo, ProviderPlatformInfo, truncate_summary};
 
 fn normalize_image_url(raw: &str, size: &str) -> String {
 	let https = if let Some(rest) = raw.strip_prefix("//") {
@@ -38,20 +16,11 @@ fn normalize_image_url(raw: &str, size: &str) -> String {
 	https.replacen("t_thumb", size, 1)
 }
 
-fn truncate_summary(s: &str) -> String {
-	if s.chars().count() <= SUMMARY_MAX {
-		s.to_string()
-	} else {
-		let truncated: String = s.chars().take(SUMMARY_MAX - 1).collect();
-		format!("{truncated}…")
-	}
-}
-
 fn timestamp_to_datetime(ts: i64) -> Option<DateTime<Utc>> {
 	DateTime::<Utc>::from_timestamp(ts, 0)
 }
 
-pub async fn fetch_game(client: &Client, provider_id: &str) -> Option<IgdbGameInfo> {
+pub async fn fetch_game(client: &Client, provider_id: &str) -> Option<ProviderGameInfo> {
 	let id: i32 = match provider_id.parse() {
 		Ok(id) => id,
 		Err(e) => {
@@ -110,17 +79,18 @@ pub async fn fetch_game(client: &Client, provider_id: &str) -> Option<IgdbGameIn
 		}
 	}
 
-	Some(IgdbGameInfo {
+	Some(ProviderGameInfo {
+		provider: MetadataProvider::Igdb,
 		name: game.name,
-		page_url: game.url,
+		page_url: Some(game.url),
 		summary: game.summary.map(|s| truncate_summary(&s)),
 		first_release_date: game.first_release_date.and_then(timestamp_to_datetime),
 		cover_url,
 		screenshot_urls,
 	})
 }
 
-pub async fn fetch_company(client: &Client, provider_id: &str) -> Option<IgdbCompanyInfo> {
+pub async fn fetch_company(client: &Client, provider_id: &str) -> Option<ProviderCompanyInfo> {
 	let id: i32 = match provider_id.parse() {
 		Ok(id) => id,
 		Err(e) => {
@@ -157,15 +127,16 @@ pub async fn fetch_company(client: &Client, provider_id: &str) -> Option<IgdbCom
 		None => None,
 	};
 
-	Some(IgdbCompanyInfo {
+	Some(ProviderCompanyInfo {
+		provider: MetadataProvider::Igdb,
 		name: company.name,
 		page_url: company.url,
 		logo_url,
 		description: company.description.map(|s| truncate_summary(&s)),
 	})
 }
 
-pub async fn fetch_platform(client: &Client, provider_id: &str) -> Option<IgdbPlatformInfo> {
+pub async fn fetch_platform(client: &Client, provider_id: &str) -> Option<ProviderPlatformInfo> {
 	let id: i32 = match provider_id.parse() {
 		Ok(id) => id,
 		Err(e) => {
@@ -202,9 +173,10 @@ pub async fn fetch_platform(client: &Client, provider_id: &str) -> Option<IgdbPl
 		None => None,
 	};
 
-	Some(IgdbPlatformInfo {
+	Some(ProviderPlatformInfo {
+		provider: MetadataProvider::Igdb,
 		name: platform.name,
-		page_url: platform.url,
+		page_url: Some(platform.url),
 		logo_url,
 		summary: platform.summary.map(|s| truncate_summary(&s)),
 	})

src/abstraction/providers/launchbox.rs

@@ -0,0 +1,64 @@
+use log::warn;
+use playmatch_client::Client;
+use playmatch_client::types::{LbGameImage, MetadataProvider};
+
+use super::{ProviderGameInfo, truncate_summary};
+
+fn is_cover(img: &LbGameImage) -> bool {
+	let t = img.image_type.to_ascii_lowercase();
+	t.contains("box - front") || t.contains("clear logo")
+}
+
+fn is_screenshot(img: &LbGameImage) -> bool {
+	img.image_type.to_ascii_lowercase().contains("screenshot")
+}
+
+pub async fn fetch_game(client: &Client, provider_id: &str) -> Option<ProviderGameInfo> {
+	let id: i64 = match provider_id.parse() {
+		Ok(id) => id,
+		Err(e) => {
+			warn!("LaunchBox game provider_id '{provider_id}' is not a valid i64: {e}");
+			return None;
+		}
+	};
+
+	let game = match client.get_lb_game_by_id().id(id).send().await {
+		Ok(resp) => resp.into_inner(),
+		Err(e) => {
+			warn!("LaunchBox game lookup failed for id {id}: {e}");
+			return None;
+		}
+	};
+
+	let (cover_url, screenshot_urls) = match client.get_lb_game_images().game_id(id).send().await {
+		Ok(resp) => {
+			let images = resp.into_inner();
+			let cover = images
+				.iter()
+				.find(|i| is_cover(i))
+				.or_else(|| images.first())
+				.map(|i| i.file_name.clone());
+			let screenshots: Vec<String> = images
+				.iter()
+				.filter(|i| is_screenshot(i))
+				.take(3)
+				.map(|i| i.file_name.clone())
+				.collect();
+			(cover, screenshots)
+		}
+		Err(e) => {
+			warn!("LaunchBox image lookup failed for id {id}: {e}");
+			(None, Vec::new())
+		}
+	};
+
+	Some(ProviderGameInfo {
+		provider: MetadataProvider::LaunchBox,
+		name: game.name,
+		page_url: game.wikipedia_url,
+		summary: game.overview.map(|s| truncate_summary(&s)),
+		first_release_date: None,
+		cover_url,
+		screenshot_urls,
+	})
+}

src/abstraction/providers/mobygames.rs

@@ -0,0 +1,40 @@
+use log::warn;
+use playmatch_client::Client;
+use playmatch_client::types::MetadataProvider;
+
+use super::{ProviderGameInfo, truncate_summary};
+
+pub async fn fetch_game(client: &Client, provider_id: &str) -> Option<ProviderGameInfo> {
+	let id: i64 = match provider_id.parse() {
+		Ok(id) => id,
+		Err(e) => {
+			warn!("MobyGames game provider_id '{provider_id}' is not a valid i64: {e}");
+			return None;
+		}
+	};
+
+	let game = match client.get_mg_game_by_id().id(id).send().await {
+		Ok(resp) => resp.into_inner(),
+		Err(e) => {
+			warn!("MobyGames game lookup failed for id {id}: {e}");
+			return None;
+		}
+	};
+
+	let cover_url = game.sample_cover.as_ref().map(|c| c.image.clone());
+	let screenshot_urls = game
+		.sample_screenshots
+		.as_ref()
+		.map(|ss| ss.iter().take(3).map(|s| s.image.clone()).collect())
+		.unwrap_or_default();
+
+	Some(ProviderGameInfo {
+		provider: MetadataProvider::MobyGames,
+		name: game.title,
+		page_url: game.moby_url,
+		summary: game.description.map(|s| truncate_summary(&s)),
+		first_release_date: None,
+		cover_url,
+		screenshot_urls,
+	})
+}