Init

src/smashrequest.rs

@@ -0,0 +1,110 @@
+use crate::smashquery::{MyQuery, MyQueryVariables, Set, SetSlot,StreamQueue};
+use cynic::{http::SurfExt, GraphQlResponse, QueryBuilder};
+
+static URL_SMASH: &str = "https://api.start.gg/gql/alpha";
+
+#[derive(Debug,Clone)]
+pub struct Match {
+    pub player1 : String,
+    pub player2 : String,
+    pub station : String,
+    pub round : i32,
+    pub full_round_test: String
+}
+
+#[derive(Debug,Clone)]
+pub struct SmashQueue {
+    pub name : String,
+    pub matches : Vec<Match>
+}
+
+impl Match {
+    pub fn new() -> Self {
+        Self { player1: String::from(""), player2: String::from("") , station: String::from("") , round: 0 , full_round_test: String::from("")}
+    }
+    
+}
+
+impl SmashQueue{
+    pub fn new() -> Self{
+        Self { name:String::from(""),matches : vec![] }
+    }
+}
+fn request_stream_queue(tournament :&str, key : &str ) -> GraphQlResponse<MyQuery>{
+
+    let resp = async_std::task::block_on(async {
+
+        let query =  MyQuery::build(MyQueryVariables
+            {
+                slug:Some(tournament)
+            } );
+
+        let resp = surf::post(URL_SMASH).header("Authorization", key).run_graphql(query).await.unwrap();
+        return resp;
+    });
+
+    return resp;
+
+}
+
+pub fn get_matches(tournament : &str, key : &str) -> Vec<SmashQueue> {
+    let mut queues :Vec<SmashQueue> = Vec::new();
+    let query = request_stream_queue(tournament,key);
+    let st :Vec<StreamQueue> = query.data.unwrap()
+        .tournament.unwrap()
+        .stream_queue.unwrap().into_iter()
+        .filter(|x| x.is_some()).map(|x| x.unwrap()).collect();
+
+    for s in st {
+        let mut current_queue = SmashQueue { 
+            name : s.stream.unwrap().stream_name.unwrap_or(String::from("Stream Queue Not Named")), 
+            matches : Vec::new() };
+
+        if s.sets.is_some() {
+            let sets : Vec<Set> = s.sets.unwrap().into_iter().filter(|x| x.is_some()).map(|x| x.unwrap()).collect();
+            for set in sets {
+
+                let slot: Vec<SetSlot> = set.slots.unwrap().into_iter().filter(|x| x.is_some()).map(|x| x.unwrap()).collect();
+                let mut iter = slot.into_iter();
+                let p1 = iter.next();
+                let p2 = iter.next();
+
+
+                let p1name = match p1 { 
+                    Some(x) => match x.entrant {
+                        Some(n) => n.name.unwrap(),
+                        _ => String::new()
+                    },
+                    _ => String::new()
+                };
+
+
+                let p2name = match p2 { 
+                    Some(x) => match x.entrant {
+                        Some(n) => n.name.unwrap(),
+                        _ => String::new()
+                    },
+                    _ => String::new()
+                };
+
+
+                if !(p1name.is_empty() & p2name.is_empty()){
+
+                    let mat = Match { full_round_test : String::from(set.full_round_text.unwrap()) ,
+                    player1: String::from(p1name),
+                    player2: String::from(p2name),
+                    round: set.round.unwrap(),
+                    station: String::from("LOL")
+                    };
+
+                    current_queue.matches.push(mat);
+                }
+
+            }
+
+        }
+        queues.push(current_queue)
+    }
+    return queues;
+}
+