From 2b6dc0304040a5e403b6fd431bf8eec9842347b2 Mon Sep 17 00:00:00 2001 From: tretrauit Date: Wed, 10 Jan 2024 02:09:34 +0700 Subject: [PATCH] feat(katana): implement character parsing from Calf's analysis Also fix bug in kc o:w parsing --- swordfish-common/src/constants.rs | 1 + swordfish-common/src/utils/katana.rs | 77 ++++++++++++++++++++++++++++ swordfish-user/src/main.rs | 26 ++++++++++ swordfish/src/debug.rs | 45 ++++++++++++++++ swordfish/src/main.rs | 28 ++++++++++ 5 files changed, 177 insertions(+) diff --git a/swordfish-common/src/constants.rs b/swordfish-common/src/constants.rs index 8ba1f34..0c52526 100644 --- a/swordfish-common/src/constants.rs +++ b/swordfish-common/src/constants.rs @@ -1,3 +1,4 @@ pub const KATANA_ID: u64 = 646937666251915264; pub const SOFA_ID: u64 = 853629533855809596; pub const QINGQUE_ID: u64 = 772642704257187840; +pub const CALF_ID: u64 = 1006025546045591632; diff --git a/swordfish-common/src/utils/katana.rs b/swordfish-common/src/utils/katana.rs index c9c014a..d93dd24 100644 --- a/swordfish-common/src/utils/katana.rs +++ b/swordfish-common/src/utils/katana.rs @@ -64,6 +64,8 @@ pub fn parse_cards_from_qingque_atopwl(content: &String) -> Vec { pub fn parse_cards_from_katana_kc_ow(content: &String) -> Vec { let mut cards: Vec = Vec::new(); for line in content.split("\n") { + let mut line = line.to_string(); + line.remove_matches("~~"); trace!("Parsing line: {}", line); if !line.ends_with("**") { continue; @@ -246,3 +248,78 @@ pub fn parse_cards_from_katana_klu_lookup(content: &String) -> Option last_update_ts: 0, }) } + +pub fn parse_cards_from_calf_analysis(content: &String) -> Vec { + let mut cards: Vec = Vec::new(); + let mut lines = content.split("\n"); + // Skip first 2 lines + lines.nth(1); + for line in lines { + trace!("Parsing line: {}", line); + let mut line_string = line.to_string(); + // Remove first ` + match line.find('`') { + Some(i) => { + line_string.drain(0..i + 1); + } + None => continue, + } + let mut line_split = line_string.split('`'); + let wishlist = match line_split.nth(0) { + Some(wishlist_str) => { + let mut wl_string = wishlist_str.to_string(); + // Remove ♡ + wl_string.remove(0); + // Remove "," in the number + // I don't know, I've never seen this myself. + wl_string.remove_matches(","); + // Remove whitespace + wl_string = wl_string + .split_whitespace() + .collect::() + .trim() + .to_string(); + trace!("Formatted wishlist number: {}", wl_string); + match wl_string.parse::() { + Ok(wishlist) => wishlist, + Err(_) => { + error!("Failed to parse wishlist number: {}", wishlist_str); + continue; + } + } + } + None => continue, + }; + let mut name_series_split = match line_split.nth(0) { + Some(split) => split.split(" · "), + None => continue, + }; + let series = match name_series_split.next() { + Some(series) => series.trim().to_string(), + None => continue, + }; + let name = match name_series_split.next() { + Some(name) => { + let mut name_string = name.to_string(); + match name_string.find("** (") { + Some(i) => { + name_string.drain(i..); + } + None => {} + } + name_string.remove_matches("**"); + name_string + } + None => continue, + }; + let card = Character { + wishlist: Some(wishlist), + name, + series, + last_update_ts: 0, + }; + trace!("Parsed card: {:?}", card); + cards.push(card); + } + cards +} diff --git a/swordfish-user/src/main.rs b/swordfish-user/src/main.rs index 06f4514..96898d8 100644 --- a/swordfish-user/src/main.rs +++ b/swordfish-user/src/main.rs @@ -93,6 +93,29 @@ async fn parse_katana_embed(embed: &Embed) { }; } +async fn parse_calf_event(ctx: &Context, event: MessageUpdateEvent) -> Result<(), String> { + if event.content.is_none() { + return Ok(()); + } + let content = event.content.unwrap(); + if content.contains("Apricot v6 Drop Analysis Engine") { + let cards = utils::katana::parse_cards_from_calf_analysis(&content); + if cards.len() == 0 { + return Ok(()); + } + debug!("Importing cards from Calf Analysis"); + match database::katana::write_characters(cards).await { + Ok(_) => { + debug!("Imported successully"); + } + Err(why) => { + error!("Failed to import card: {:?}", why); + } + } + } + Ok(()) +} + async fn parse_qingque_event(ctx: &Context, event: MessageUpdateEvent) -> Result<(), String> { if event.embeds.is_none() || event.embeds.clone().unwrap().len() == 0 { return Ok(()); @@ -174,6 +197,9 @@ impl EventHandler for Handler { constants::QINGQUE_ID => { parse_qingque_event(&ctx, event).await.unwrap(); } + constants::CALF_ID => { + parse_calf_event(&ctx, event).await.unwrap(); + } _ => {} } } diff --git a/swordfish/src/debug.rs b/swordfish/src/debug.rs index e5a2053..246d7eb 100644 --- a/swordfish/src/debug.rs +++ b/swordfish/src/debug.rs @@ -254,6 +254,51 @@ pub async fn dbg_parse_katana_klu_lookup(ctx: &Context, msg: &Message) -> Comman Ok(()) } +pub async fn dbg_parse_calf_analysis(ctx: &Context, msg: &Message) -> CommandResult { + let target_msg = match dbg_get_message("embed", ctx, msg).await { + Ok(msg) => msg, + Err(_) => { + return Ok(()); + } + }; + let cards = utils::katana::parse_cards_from_calf_analysis(&target_msg.content); + helper::info_message( + ctx, + msg, + format!("Parsed cards: ```\n{:?}\n```", cards), + None, + ) + .await; + Ok(()) +} + +pub async fn dbg_message(ctx: &Context, msg: &Message) -> CommandResult { + let target_msg = match dbg_get_message("message", ctx, msg).await { + Ok(msg) => msg, + Err(_) => { + return Ok(()); + } + }; + let content = match target_msg.content.len() { + 0 => "None".to_string(), + _ => target_msg.content, + }; + helper::info_message( + ctx, + msg, + format!( + "Content: \n\ + ```\n\ + {}\n\ + ```", + content + ), + Some("Message information".to_string()), + ) + .await; + Ok(()) +} + pub async fn dbg_embed(ctx: &Context, msg: &Message) -> CommandResult { let target_msg = match dbg_get_message("embed", ctx, msg).await { Ok(msg) => msg, diff --git a/swordfish/src/main.rs b/swordfish/src/main.rs index 01c35ee..9a7f4c8 100644 --- a/swordfish/src/main.rs +++ b/swordfish/src/main.rs @@ -70,11 +70,37 @@ impl EventHandler for Handler { constants::QINGQUE_ID => { parse_qingque_event(&ctx, event).await.unwrap(); } + constants::CALF_ID => { + parse_calf_event(&ctx, event).await.unwrap(); + } _ => {} } } } +async fn parse_calf_event(ctx: &Context, event: MessageUpdateEvent) -> Result<(), String> { + if event.content.is_none() { + return Ok(()); + } + let content = event.content.unwrap(); + if content.contains("Apricot v6 Drop Analysis Engine") { + let cards = utils::katana::parse_cards_from_calf_analysis(&content); + if cards.len() == 0 { + return Ok(()); + } + debug!("Importing cards from Calf Analysis"); + match database::katana::write_characters(cards).await { + Ok(_) => { + debug!("Imported successully"); + } + Err(why) => { + error!("Failed to import card: {:?}", why); + } + } + } + Ok(()) +} + async fn parse_qingque_event(ctx: &Context, event: MessageUpdateEvent) -> Result<(), String> { if event.embeds.is_none() || event.embeds.clone().unwrap().len() == 0 { return Ok(()); @@ -320,10 +346,12 @@ async fn debug(ctx: &Context, msg: &Message) -> CommandResult { "kdropanalyze" => debug::dbg_kdropanalyze(ctx, msg).await?, "kda" => debug::dbg_kdropanalyze(ctx, msg).await?, "embed" => debug::dbg_embed(ctx, msg).await?, + "message" => debug::dbg_message(ctx, msg).await?, "parse-qingque-atopwl" => debug::dbg_parse_qingque_atopwl(ctx, msg).await?, "parse-katana-kc_ow" => debug::dbg_parse_katana_kc_ow(ctx, msg).await?, "parse-katana-klu_lookup" => debug::dbg_parse_katana_klu_lookup(ctx, msg).await?, "parse-katana-klu_results" => debug::dbg_parse_katana_klu_results(ctx, msg).await?, + "parse-calf-analysis" => debug::dbg_parse_calf_analysis(ctx, msg).await?, _ => { helper::error_message( ctx,