Co-authored-by: jkassman <jkassman@users.noreply.github.com>

Reviewed-on: https://questia.dev/git/vsquad/pool-elo/pulls/4

.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+rustflags = [ "--cfg", "engine" ]

.gitignore

@@ -6,3 +6,4 @@ static
 pkg 
 ./Cargo.lock
 package-lock.json
+/data/

Cargo.toml

@@ -5,18 +5,30 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-perseus = { version = "0.4.2", features = [ "hydrate" ] }
+perseus = { version = "0.4.2", features = ["hydrate"] }
-sycamore = "0.8.2"
+sycamore = { version = "0.8.2", features = [
+    "suspense",
+    "web",
+    "wasm-bindgen-interning",
+] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 env_logger = "0.10.0"
 log = "0.4.20"
+once_cell = "1.18.0"
+web-sys = "0.3.64"
+cfg-if = "1.0.0"
+chrono = { version = "0.4.31", features = ["serde"] }
 
 [target.'cfg(engine)'.dev-dependencies]
 fantoccini = "0.19"
 
 [target.'cfg(engine)'.dependencies]
-tokio = { version = "1", features = [ "macros", "rt", "rt-multi-thread" ] }
+tokio = { version = "1", features = ["macros", "rt", "rt-multi-thread"] }
-perseus-axum = { version = "0.4.2", features = [ "dflt-server" ] }
+perseus-axum = { version = "0.4.2" }
+axum = "0.6"
+tower-http = { version = "0.3", features = ["fs"] }
 
 [target.'cfg(client)'.dependencies]
+wasm-bindgen = "0.2"
+reqwest = { version = "0.11", features = ["json"] }

README.md

@@ -23,7 +23,7 @@ https://nodejs.org/en
 ## 3. Install Perseus, for real-time updates while developing
 
 `cargo install perseus-cli`
-`cargo build --target wasm32-unknown-unknown`
+`rustup target add wasm32-unknown-unknown`
 
 ## 4. Install tailwindcss, for styling
 
@@ -43,7 +43,7 @@ To build CSS run:
 `npm run build`
 
 To build the project for testing, run
-`perseus serve`
+`perseus serve --verbose`
 
 # Deploying the project
 

src/components/layout.rs

@@ -2,24 +2,18 @@ use sycamore::prelude::*;
 
 #[derive(Prop)]
 pub struct LayoutProps<'a, G: Html> {
-    /// The title of the page, which will be displayed in the header.
     pub title: &'a str,
-    /// The content to put inside the layout.
     pub children: Children<'a, G>,
 }
 
 #[component]
 pub fn Layout<'a, G: Html>(
     cx: Scope<'a>,
-    LayoutProps { title, children }: LayoutProps<'a, G>,
+    LayoutProps { title: _, children }: LayoutProps<'a, G>,
 ) -> View<G> {
     let children = children.call(cx);
 
-    // example params
-    // p { (title.to_string()) }
-
     view! { cx,
-        // These elements are styled with bright colors for demonstration purposes
         header {
             div (class = "flex items-center justify-between") {
                 div (class = "w-full text-gray-700 md:text-center text-2xl font-semibold") {
@@ -47,16 +41,11 @@ pub fn Layout<'a, G: Html>(
         main(style = "my-8") {
             div(class = "container mx-auto px-6") {
                 div(class = "md:flex mt-8 md:-mx-4") {
-                    div(class = "h-64 rounded-md overflow-hidden bg-cover bg-center") {
+                    div(class = "rounded-md overflow-hidden bg-cover bg-center") {
                         (children)
                     }
                 }
             }
         }
-        footer(class = "bg-gray-200") {
-            p(class = "container mx-auto px-6 py-3 flex justify-between items-center"){
-                "Hey there, I'm a footer!"
-            }
-        }
     }
 }

src/data/mod.rs

@@ -0,0 +1,5 @@
+pub mod pool_match;
+pub mod user;
+
+#[cfg(engine)]
+pub mod store;

src/data/pool_match.rs

@@ -0,0 +1,55 @@
+use crate::data::user::PlayerId;
+use chrono::serde::ts_seconds;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+pub type MatchId = u32;
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub enum MatchType {
+    Standard8Ball,
+    Standard9Ball,
+    CutThroat,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct MatchData {
+    pub type_: MatchType,
+    pub winners: Vec<PlayerId>,
+    pub losers: Vec<PlayerId>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct PoolMatch {
+    pub id: MatchId,
+    pub data: MatchData,
+    #[serde(with = "ts_seconds")]
+    pub time: DateTime<Utc>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct PoolMatchList {
+    pub pool_matches: Vec<PoolMatch>,
+    pub max_id: MatchId,
+}
+
+impl PoolMatch {
+    pub fn new(data: MatchData, time: DateTime<Utc>) -> PoolMatch {
+        PoolMatch { id: 0, data, time }
+    }
+}
+
+impl PoolMatchList {
+    pub fn new() -> PoolMatchList {
+        PoolMatchList {
+            pool_matches: vec![],
+            max_id: 0,
+        }
+    }
+
+    pub fn add_pool_match(&mut self, mut pool_match: PoolMatch) {
+        pool_match.id = self.max_id + 1;
+        self.max_id += 1;
+        self.pool_matches.push(pool_match);
+    }
+}

src/data/store.rs

@@ -0,0 +1,34 @@
+// (Server only) In-memory data storage and persistent storage
+
+use crate::data::pool_match::PoolMatchList;
+use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
+use std::{fs, path::Path, sync::Mutex};
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct Store {
+    pub matches: PoolMatchList,
+}
+
+impl Store {
+    fn new() -> Store {
+        fs::create_dir_all("data").unwrap();
+        match Path::new("data/store.json").exists() {
+            false => Store {
+                matches: PoolMatchList::new(),
+            },
+            true => {
+                let contents = fs::read_to_string("data/store.json").unwrap();
+                serde_json::from_str(&contents).unwrap()
+            }
+        }
+    }
+    // TODO -> Store data
+    #[allow(dead_code)]
+    pub fn write(&self) {
+        let contents = serde_json::to_string(&self).unwrap();
+        fs::write("data/store.json", contents).unwrap();
+    }
+}
+
+pub static DATA: Lazy<Mutex<Store>> = Lazy::new(|| Mutex::new(Store::new()));

src/data/user.rs

@@ -0,0 +1,3 @@
+
+pub type PlayerId = u32;
+

src/endpoints.rs

@@ -0,0 +1 @@
+pub const MATCH: &str = "/api/post-match";

src/main.rs

@@ -1,16 +1,52 @@
 mod components;
-mod templates;
+mod data;
+mod endpoints;
 mod error_views;
+#[cfg(engine)]
+mod server;
+mod templates;
 
 use perseus::prelude::*;
 use sycamore::prelude::view;
 
-#[perseus::main(perseus_axum::dflt_server)]
+cfg_if::cfg_if! {
+    if #[cfg(engine)] {
+        use std::net::SocketAddr;
+        use perseus::{
+            i18n::TranslationsManager,
+            server::ServerOptions,
+            stores::MutableStore,
+            turbine::Turbine,
+        };
+        use crate::server::routes::register_routes;
+    }
+}
+
+#[cfg(engine)]
+pub async fn dflt_server<M: MutableStore + 'static, T: TranslationsManager + 'static>(
+    turbine: &'static Turbine<M, T>,
+    opts: ServerOptions,
+    (host, port): (String, u16),
+) {
+    let addr: SocketAddr = format!("{}:{}", host, port)
+        .parse()
+        .expect("Invalid address provided to bind to.");
+    let mut app = perseus_axum::get_router(turbine, opts).await;
+
+    app = register_routes(app);
+
+    axum::Server::bind(&addr)
+        .serve(app.into_make_service())
+        .await
+        .unwrap();
+}
+
+#[perseus::main(dflt_server)]
 pub fn main<G: Html>() -> PerseusApp<G> {
-    use log::{info, warn};
     env_logger::init();
 
     PerseusApp::new()
+        .global_state_creator(crate::templates::global_state::get_global_state_creator())
         .template(crate::templates::index::get_template())
         .template(crate::templates::add_game_form::get_template())
         .template(crate::templates::one_v_one_board::get_template())

src/server/mod.rs

@@ -0,0 +1,2 @@
+pub mod routes;
+

src/server/routes.rs

@@ -0,0 +1,34 @@
+// (Server only) Routes
+
+use crate::{
+    data::{
+        pool_match::{PoolMatch, PoolMatchList},
+        store::DATA,
+    },
+    endpoints::MATCH,
+};
+use axum::{
+    extract::Json,
+    routing::{post, Router},
+};
+use std::thread;
+
+pub fn register_routes(app: Router) -> Router {
+    let app = app.route(MATCH, post(post_match));
+    app
+}
+
+async fn post_match(Json(pool_match): Json<PoolMatch>) -> Json<PoolMatchList> {
+    // Update the store with the new match
+    let matches = thread::spawn(move || {
+        // Get the store
+        let mut data = DATA.lock().unwrap();
+        (*data).matches.add_pool_match(pool_match);
+        println!("{:?}", (*data).matches.pool_matches);
+        (*data).matches.clone()
+    })
+    .join()
+    .unwrap();
+
+    Json(matches)
+}

src/templates/add_game_form.rs

@@ -1,22 +1,74 @@
-use crate::components::layout::Layout;
+use crate::data::pool_match::MatchType;
+use crate::{components::layout::Layout, data::pool_match::MatchData};
 use perseus::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::fs;
 use sycamore::prelude::*;
+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;
+        use chrono::Utc;
+    }
+}
 
 // Reactive page
 
 #[derive(Serialize, Deserialize, Clone, ReactiveState)]
 #[rx(alias = "PageStateRx")]
 struct PageState {
-
+    name: String,
 }
 
 fn add_game_form_page<'a, G: Html>(cx: BoundedScope<'_, 'a>, state: &'a PageStateRx) -> View<G> {
+    let handle_add_match = move |_event: Event| {
+        #[cfg(client)]
+        {
+            // state.name.get().as_ref().clone()
+            spawn_local_scoped(cx, async move {
+                let new_match = PoolMatch::new(
+                    MatchData {
+                        type_: MatchType::Standard8Ball,
+                        winners: vec![1],
+                        losers: vec![2, 3, 4],
+                    },
+                    Utc::now(),
+                );
+                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
+            div (class = "flex flex-wrap") {
-            p { "Results" }
+                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",)
+            }
+            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"
+                }
+            }
         }
     }
 }
@@ -24,9 +76,11 @@ 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]
@@ -36,7 +90,6 @@ fn head(cx: Scope) -> View<SsrNode> {
     }
 }
 
-
 // Template
 
 pub fn get_template<G: Html>() -> Template<G> {

src/templates/global_state.rs

@@ -0,0 +1,44 @@
+// Not a page, global state that is shared between all pages
+
+use crate::data::pool_match::PoolMatchList;
+use perseus::{prelude::*, state::GlobalStateCreator};
+use serde::{Deserialize, Serialize};
+
+cfg_if::cfg_if! {
+    if #[cfg(engine)] {
+        use std::thread;
+        use std::ops::Deref;
+        use crate::data::store::DATA;
+    }
+}
+
+#[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/index.rs

@@ -20,8 +20,5 @@ fn head(cx: Scope) -> View<SsrNode> {
 }
 
 pub fn get_template<G: Html>() -> Template<G> {
-    Template::build("")
+    Template::build("").view(index_page).head(head).build()
-        .view(index_page)
-        .head(head)
-        .build()
 }

src/templates/mod.rs

@@ -1,4 +1,22 @@
-pub mod index;
 pub mod add_game_form;
+pub mod global_state;
+pub mod index;
 pub mod one_v_one_board;
 pub mod overall_board;
+
+#[cfg(client)]
+use perseus::utils::get_path_prefix_client;
+
+#[allow(dead_code)]
+pub fn get_api_path(path: &str) -> String {
+    #[cfg(engine)]
+    {
+        path.to_string()
+    }
+    #[cfg(client)]
+    {
+        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

@@ -1,21 +1,15 @@
 use crate::components::layout::Layout;
 use perseus::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::fs;
 use sycamore::prelude::*;
 
-// Reactive page
-
 #[derive(Serialize, Deserialize, Clone, ReactiveState)]
 #[rx(alias = "PageStateRx")]
-struct PageState {
+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
             p { "leaderboard" }
         }
     }
@@ -24,7 +18,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 {})
 }
@@ -36,9 +30,6 @@ fn head(cx: Scope) -> View<SsrNode> {
     }
 }
 
-
-// Template
-
 pub fn get_template<G: Html>() -> Template<G> {
     Template::build("one-v-one-board")
         .request_state_fn(get_request_state)

src/templates/overall_board.rs

@@ -1,22 +1,49 @@
-use crate::components::layout::Layout;
+use crate::{components::layout::Layout, templates::global_state::AppStateRx, data::user::PlayerId};
+
 use perseus::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::fs;
 use sycamore::prelude::*;
 
-// Reactive page
+use crate::data::pool_match::PoolMatch;
 
 #[derive(Serialize, Deserialize, Clone, ReactiveState)]
 #[rx(alias = "PageStateRx")]
-struct PageState {
+struct PageState {}
 
+fn format_list_or_single(to_format: &Vec<PlayerId>) -> String{
+    match to_format.len() {
+        1 => to_format[0].to_string(),
+        _ => format!("{:?}", to_format),
+    }
 }
 
-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,
         Layout(title = "Overall Leaderboard") {
-            // Anything we put in here will be rendered inside the `<main>` block of the layout
+            ul {
-            p { "leaderboard" }
+                (View::new_fragment(
+                    global_state.matches.get()
+                        .pool_matches
+                        .iter()
+                        .rev()
+                        .map(|item: &PoolMatch| {
+                            let game = item.clone();
+                            
+                            view! { cx,
+                                li (class = "text-blue-700", id = "ha",) {
+                                    (game.id)
+                                    ("  ")
+                                    (format_list_or_single(&game.data.winners))
+                                    ("  ")
+                                    (format_list_or_single(&game.data.losers))
+                                }
+                            }
+                        })
+                        .collect(),
+                ))
+            }
         }
     }
 }
@@ -24,7 +51,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 {})
 }
@@ -36,9 +63,6 @@ fn head(cx: Scope) -> View<SsrNode> {
     }
 }
 
-
-// Template
-
 pub fn get_template<G: Html>() -> Template<G> {
     Template::build("overall-board")
         .request_state_fn(get_request_state)