Add working API calls, fix warnings

src/templates/add_game_form.rs

@@ -1,47 +1,70 @@
-use std::ops::Deref;
 use crate::components::layout::Layout;
 use perseus::prelude::*;
 use serde::{Deserialize, Serialize};
 use sycamore::prelude::*;
-use crate::data::global_state::AppStateRx;
-use web_sys::{window, Event};
-use crate::data::pool_match::PoolMatch;
-#[cfg(client)]
-use perseus::utils::get_path_prefix_client;
-use crate::templates::get_api_path;
+use web_sys::{Event};
+
+cfg_if::cfg_if! {
+    if #[cfg(client)] {
+        use crate::data::pool_match::{PoolMatch, PoolMatchList};
+        use crate::templates::global_state::AppStateRx;
+        use crate::endpoints::MATCH;
+        use crate::templates::get_api_path;
+    }
+}
 
 
 // Reactive page
 
 #[derive(Serialize, Deserialize, Clone, ReactiveState)]
 #[rx(alias = "PageStateRx")]
-struct PageState {}
-
+struct PageState {
+    name: String,
+}
 
 
 fn add_game_form_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a PageStateRx) -> View<G> {
-    let global_state = Reactor::<G>::from_cx(cx).get_global_state::<AppStateRx>(cx);
-    let api_path = get_api_path("/api/test");
 
-    let handle_add_match = move |event: Event| {
+    let handle_add_match = move |_event: Event| {
         #[cfg(client)]
         {
-            let path = get_api_path("/api/test");
-            println!("{}", path);
             spawn_local_scoped(cx, async move {
-                reqwest::get(get_api_path("/api/test").as_str()).await.unwrap();
+                let new_match = PoolMatch {
+                    players: vec![],
+                    winner: state.name.get().as_ref().clone(),
+                };
+
+                let client = reqwest::Client::new();
+                let new_matches = client.post(get_api_path(MATCH).as_str())
+                    .json(&new_match)
+                    .send()
+                    .await
+                    .unwrap()
+                    .json::<PoolMatchList>()
+                    .await
+                    .unwrap();
+                let global_state = Reactor::<G>::from_cx(cx).get_global_state::<AppStateRx>(cx);
+                global_state.matches.set(new_matches);
+
             })
         }
     };
 
     view! { cx,
         Layout(title = "Add Game Results") {
-            // Anything we put in here will be rendered inside the `<main>` block of the layout
-            button(on:click=handle_add_match) {
-                "Add result"
+            div (class = "flex flex-wrap") {
+                input (bind:value = state.name,
+                       class = "appearance-none block w-full bg-gray-200 text-gray-700 border \
+                       border-red-500 rounded py-3 px-4 mb-3 leading-tight focus:outline-none \
+                       focus:bg-white",)
             }
-            p {
-                (api_path)
+            div (class = "flex flex-wrap") {
+                button(on:click = handle_add_match,
+                       class = "flex-shrink-0 bg-teal-500 hover:bg-teal-700 border-teal-500 \
+                       hover:border-teal-700 text-sm border-4 text-white py-1 px-2 rounded",
+                ) {
+                    "Add result"
+                }
             }
         }
     }
@@ -50,9 +73,9 @@ fn add_game_form_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a PageStat
 #[engine_only_fn]
 async fn get_request_state(
     _info: StateGeneratorInfo<()>,
-    req: Request,
+    _req: Request,
 ) -> Result<PageState, BlamedError<std::convert::Infallible>> {
-    Ok(PageState {})
+    Ok(PageState { name: "Ferris".to_string() })
 }
 
 #[engine_only_fn]

src/templates/global_state.rs

@@ -0,0 +1,47 @@
+use perseus::{prelude::*, state::GlobalStateCreator};
+use serde::{Deserialize, Serialize};
+
+cfg_if::cfg_if! {
+    if #[cfg(engine)] {
+        use std::thread;
+        use std::ops::Deref;
+    }
+}
+
+#[cfg(engine)]
+use crate::data::store::DATA;
+use crate::data::pool_match::PoolMatchList;
+
+#[derive(Serialize, Deserialize, ReactiveState, Clone)]
+#[rx(alias = "AppStateRx")]
+pub struct AppState {
+    pub matches: PoolMatchList,
+}
+
+pub fn get_global_state_creator() -> GlobalStateCreator {
+    GlobalStateCreator::new()
+        .build_state_fn(get_build_state)
+        .request_state_fn(get_request_state)
+}
+
+#[engine_only_fn]
+fn get_state() -> AppState {
+    let matches = thread::spawn(move || {
+        DATA.lock().unwrap().deref().matches.clone()
+    }).join().unwrap();
+
+    AppState {
+        matches
+    }
+}
+
+
+#[engine_only_fn]
+pub async fn get_build_state() -> AppState {
+    get_state()
+}
+
+#[engine_only_fn]
+pub async fn get_request_state(_req: Request) -> AppState {
+    get_state()
+}

src/templates/mod.rs

@@ -2,10 +2,12 @@ pub mod index;
 pub mod add_game_form;
 pub mod one_v_one_board;
 pub mod overall_board;
+pub mod global_state;
 
 #[cfg(client)]
 use perseus::utils::get_path_prefix_client;
 
+#[allow(dead_code)]
 pub fn get_api_path(path: &str) -> String {
     #[cfg(engine)]
     {
@@ -13,9 +15,8 @@ pub fn get_api_path(path: &str) -> String {
     }
     #[cfg(client)]
     {
-        let path = web_sys::window().unwrap().location().pathname().unwrap();
-        // let base_path = get_path_prefix_client();
-        // format!("{}{}", base_path, path)
-        path.to_string()
+        let origin = web_sys::window().unwrap().origin();
+        let base_path = get_path_prefix_client();
+        format!("{}{}{}", origin, base_path, path)
     }
-}
+}

src/templates/one_v_one_board.rs

@@ -11,7 +11,7 @@ struct PageState {
 
 }
 
-fn one_v_one_board_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a PageStateRx) -> View<G> {
+fn one_v_one_board_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, _state: &'a PageStateRx) -> View<G> {
     view! { cx,
         Layout(title = "1v1 Leaderboard") {
             // Anything we put in here will be rendered inside the `<main>` block of the layout
@@ -23,7 +23,7 @@ fn one_v_one_board_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a PageSt
 #[engine_only_fn]
 async fn get_request_state(
     _info: StateGeneratorInfo<()>,
-    req: Request,
+    _req: Request,
 ) -> Result<PageState, BlamedError<std::convert::Infallible>> {
     Ok(PageState {})
 }

src/templates/overall_board.rs

@@ -1,16 +1,8 @@
 use crate::components::layout::Layout;
 use perseus::prelude::*;
 use serde::{Deserialize, Serialize};
-#[cfg(engine)]
-use crate::data::store::DATA;
-#[cfg(engine)]
-use std::thread;
 use sycamore::prelude::*;
-use crate::data::global_state::AppStateRx;
-
-use crate::data::pool_match::{
-    PoolMatchList, PoolMatch
-};
+use crate::templates::global_state::AppStateRx;
 
 // Reactive page
 
@@ -20,7 +12,7 @@ struct PageState {
 
 }
 
-fn overall_board_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a PageStateRx) -> View<G> {
+fn overall_board_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, _state: &'a PageStateRx) -> View<G> {
     let global_state = Reactor::<G>::from_cx(cx).get_global_state::<AppStateRx>(cx);
 
     view! { cx,
@@ -28,13 +20,12 @@ fn overall_board_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a PageStat
             // Anything we put in here will be rendered inside the `<main>` block of the layout
             ul {
                 (View::new_fragment(
-                    global_state.store.get()
-                        .matches
+                    global_state.matches.get()
                         .pool_matches
                         .iter()
                         .rev()
                         .enumerate()
-                        .map(|(index, item)| {
+                        .map(|(_index, item)| {
                             let game = item.clone();
                             view! { cx,
                                 li {
@@ -52,7 +43,7 @@ fn overall_board_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a PageStat
 #[engine_only_fn]
 async fn get_request_state(
     _info: StateGeneratorInfo<()>,
-    req: Request,
+    _req: Request,
 ) -> Result<PageState, BlamedError<std::convert::Infallible>> {
     Ok(PageState {})
 }