From fec84cee486d5d4444b286c7d92610150043a1ea Mon Sep 17 00:00:00 2001
From: ilotterytea <iltsu@alright.party>
Date: Wed, 9 Apr 2025 01:44:13 +0500
Subject: feat: methods for getting info about 7tv users

---
 src/lib.rs     |  36 ++++++++++++++++++++
 src/seventv.rs | 102 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 138 insertions(+)

(limited to 'src')

diff --git a/src/lib.rs b/src/lib.rs
index 404bc4b..3544321 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -81,4 +81,40 @@ mod tests {
 
         assert_eq!(emotes.len() >= 1, true);
     }
+
+    #[tokio::test]
+    async fn get_seventv_user_by_id() {
+        let stv = SevenTVAPIClient::new();
+        let user = stv.get_user_by_id("01F6J4NXTR0003KEX0NDQ3PS6P").await;
+
+        assert_eq!(user.is_some(), true);
+
+        let user = user.unwrap();
+
+        assert_eq!(user.username.eq("ilotterytea"), true);
+    }
+
+    #[tokio::test]
+    async fn get_seventv_emote_set_by_id() {
+        let stv = SevenTVAPIClient::new();
+        let user = stv.get_emote_set("01F6J4NXTR0003KEX0NDQ3PS6P").await;
+
+        assert_eq!(user.is_some(), true);
+
+        let set = user.unwrap();
+
+        assert_eq!(set.owner.username.eq("ilotterytea"), true);
+    }
+
+    #[tokio::test]
+    async fn get_seventv_user_by_twitch_id() {
+        let stv = SevenTVAPIClient::new();
+        let user = stv.get_user_by_twitch_id(191400264).await;
+
+        assert_eq!(user.is_some(), true);
+
+        let user = user.unwrap();
+
+        assert_eq!(user.id.eq("01F6J4NXTR0003KEX0NDQ3PS6P"), true);
+    }
 }
diff --git a/src/seventv.rs b/src/seventv.rs
index 4ca225a..dd4a939 100644
--- a/src/seventv.rs
+++ b/src/seventv.rs
@@ -2,6 +2,7 @@ use std::collections::HashSet;
 
 use futures::SinkExt;
 use reqwest::{Client, Error};
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tokio::net::TcpStream;
 use tokio_tungstenite::{
@@ -11,6 +12,21 @@ use tungstenite::{Message, Result, protocol::WebSocketConfig};
 
 use crate::emotes::{Emote, RetrieveEmoteAPI, RetrieveEmoteWS};
 
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct User {
+    pub id: String,
+    pub alias_id: usize,
+    pub username: String,
+    pub emote_set_id: String,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct EmoteSet {
+    pub id: String,
+    pub name: String,
+    pub owner: User,
+}
+
 pub struct SevenTVAPIClient {
     client: Client,
     base_url: String,
@@ -24,6 +40,92 @@ impl SevenTVAPIClient {
         }
     }
 
+    pub async fn get_user_by_twitch_id(&self, twitch_id: usize) -> Option<User> {
+        let client = Client::new();
+        let response: serde_json::Value = client
+            .get(format!("{}/users/twitch/{}", self.base_url, twitch_id))
+            .send()
+            .await
+            .ok()?
+            .error_for_status()
+            .ok()?
+            .json()
+            .await
+            .ok()?;
+
+        let alias_id = response["id"].as_str()?.parse::<usize>().ok()?;
+        let username = response["username"].as_str()?;
+        let emote_set_id = response["emote_set_id"].as_str()?;
+
+        let id = response["user"]["id"].as_str()?;
+
+        Some(User {
+            id: id.to_string(),
+            alias_id,
+            username: username.to_string(),
+            emote_set_id: emote_set_id.to_string(),
+        })
+    }
+
+    pub async fn get_user_by_id(&self, id: &str) -> Option<User> {
+        let client = Client::new();
+        let response: serde_json::Value = client
+            .get(format!("{}/users/{}", self.base_url, id))
+            .send()
+            .await
+            .ok()?
+            .error_for_status()
+            .ok()?
+            .json()
+            .await
+            .ok()?;
+
+        self.parse_user_json(&response)
+    }
+
+    pub async fn get_emote_set(&self, emote_set_id: &str) -> Option<EmoteSet> {
+        let client = Client::new();
+        let response: serde_json::Value = client
+            .get(format!("{}/emote-sets/{}", self.base_url, emote_set_id))
+            .send()
+            .await
+            .ok()?
+            .error_for_status()
+            .ok()?
+            .json()
+            .await
+            .ok()?;
+
+        let id = response["id"].as_str()?;
+        let name = response["name"].as_str()?;
+        let owner = self.parse_user_json(&response["owner"])?;
+
+        Some(EmoteSet {
+            id: id.to_string(),
+            name: name.to_string(),
+            owner,
+        })
+    }
+
+    fn parse_user_json(&self, json: &Value) -> Option<User> {
+        let id = json["id"].as_str()?;
+
+        let connections = json["connections"].as_array()?;
+        let twitch_connection = connections.iter().find(|x| {
+            let Some(platform) = x["platform"].as_str() else {
+                return false;
+            };
+            platform.eq("TWITCH")
+        })?;
+
+        Some(User {
+            id: id.to_string(),
+            alias_id: twitch_connection["id"].as_str()?.parse().ok()?,
+            username: twitch_connection["username"].as_str()?.to_string(),
+            emote_set_id: twitch_connection["emote_set_id"].as_str()?.to_string(),
+        })
+    }
+
     fn parse_emoteset(&self, emotesets_json: &Value) -> Vec<Emote> {
         let mut emotes = Vec::new();
 
-- 
cgit v1.2.3