feat(katana): implement character parsing from Calf's analysis

Also fix bug in kc o:w parsing

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;

swordfish-common/src/utils/katana.rs

@@ -64,6 +64,8 @@ pub fn parse_cards_from_qingque_atopwl(content: &String) -> Vec<Character> {
 pub fn parse_cards_from_katana_kc_ow(content: &String) -> Vec<Character> {
     let mut cards: Vec<Character> = 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<Character>
         last_update_ts: 0,
     })
 }
+
+pub fn parse_cards_from_calf_analysis(content: &String) -> Vec<Character> {
+    let mut cards: Vec<Character> = 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::<String>()
+                    .trim()
+                    .to_string();
+                trace!("Formatted wishlist number: {}", wl_string);
+                match wl_string.parse::<u32>() {
+                    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
+}

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();
+            }
             _ => {}
         }
     }

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,

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,