Form for extractor html

Cargo.toml

@@ -22,7 +22,4 @@ members = ["src-tauri"]
 
 [dependencies.web-sys]
 version = "0.3"
-features = [
+features = ["Window", "console", "HtmlSelectElement"]
-  "Window",
-  "console"
-]

public/glue.js

@@ -10,4 +10,8 @@ export async function write_config_js(config) {
 
 export async function load_config_js() {
     return await invoke("load_config");
+}
+
+export async function load_champions_js() {
+    return await invoke("load_champions");
 }

src-tauri/Cargo.toml

@@ -17,6 +17,7 @@ serde_json = "1"
 toml = "0.5"
 tokio = "1.38.0"
 serde-wasm-bindgen = "0.4"
+walkdir = "2"
 
 [features]
 # This feature is used for production builds or when a dev server is not specified, DO NOT REMOVE!!

src-tauri/config.toml

@@ -1,3 +1,3 @@
-cslol_dir = "WHY U FUCK NO WORK"
+cslol_dir = ""
-wad_dir = ""
+wad_dir = "C:\\Riot Games\\League of Legends\\Game\\DATA\\FINAL\\Champions"
 extract_dir = ""

src-tauri/src/config_settings.rs

@@ -1,4 +1,4 @@
-use tokio::fs;
+use std::fs;
 
 use serde::{Deserialize, Serialize};
 
@@ -11,35 +11,29 @@ pub struct Config {
 
 #[tauri::command]
 pub async fn init_config() {
-    // Check if the config file exists asynchronously
+    if fs::metadata("config.toml").is_err() {
-    if fs::metadata("config.toml").await.is_err() {
         let config = Config {
             cslol_dir: "".to_string(),
             wad_dir: "C:\\Riot Games\\League of Legends\\Game\\DATA\\FINAL\\Champions".to_string(),
             extract_dir: "".to_string(),
         };
-        write_config(config).await; // Call the async version of write_config
+        write_config(config).await;
     }
 }
 
 #[tauri::command]
 pub async fn load_config() -> Config {
-    // Read the config file asynchronously
+    let config = fs::read_to_string("config.toml")
-    let config = fs::read_to_string("config.toml").await
         .expect("Failed to read config.toml file");
-
-    // Parse the config synchronously as before (no async TOML parser by default)
     toml::from_str(&config)
         .expect("Failed to parse config.toml file")
 }
 
 #[tauri::command]
 pub async fn write_config(config: Config) {
-    // Serialize the config synchronously (no async TOML serializer by default)
     let config_content = toml::to_string(&config)
         .expect("Failed to serialize config");
 
-    // Write the config file asynchronously
+    fs::write("config.toml", config_content)
-    fs::write("config.toml", config_content).await
         .expect("Failed to write to config.toml file");
 }

src-tauri/src/extractor.rs

@@ -0,0 +1,68 @@
+use std::process::Command;
+use std::env;
+use std::fs;
+use std::process::ExitStatus;
+use serde::de::value::Error;
+use serde::Deserialize;
+use serde::Serialize;
+use walkdir::WalkDir;
+use std::ffi::OsString;
+use std::path::PathBuf;
+
+use crate::config_settings;
+
+#[derive(Serialize, Deserialize)]
+pub struct Champion {
+    name: String,
+    location: String,
+}
+
+#[tauri::command]
+pub async fn load_champions() -> Vec<Champion> {
+
+    let config = config_settings::load_config().await;
+    
+    let champions: Vec<Champion> = WalkDir::new(&config.wad_dir)
+        .into_iter()
+        .filter_map(|entry| entry.ok())
+        .filter_map(|entry| {
+            let path = entry.path();
+            let file_name = path.file_name().and_then(|name| name.to_str())?;
+            let extension = path.extension().and_then(|ext| ext.to_str())?;
+            if extension == "client" &&
+               file_name.ends_with(".wad.client") &&
+               file_name.split('.').count() == 3
+            {
+                let name = file_name.split('.').next().unwrap_or("").to_string();
+                let location = path.to_str().unwrap_or("").to_string();
+                Some(Champion {
+                    name,
+                    location,
+                })
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    champions
+}
+
+#[tauri::command]
+pub async fn extract_wad(champion: Champion) {
+    let config = config_settings::load_config().await;
+
+
+    let current_dir = env::current_dir().expect("Failed to get current directory");
+    let extraction_path = current_dir.join("champions").join(champion.name);
+    let bat_path = PathBuf::from(config.cslol_dir).join("cslol-tools\\wad-extract.exe");
+
+    if !extraction_path.exists() {
+        fs::create_dir_all(&extraction_path).expect("Failed to create extraction folder");
+    }
+
+    let _status = Command::new(&bat_path)
+        .arg(&champion.location)
+        .arg(&extraction_path)
+        .status().unwrap();
+}

src-tauri/src/main.rs

@@ -2,7 +2,10 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 mod config_settings;
+mod extractor;
+
 use config_settings::*;
+use extractor::*;
 
 #[tauri::command]
 fn greet(name: &str) -> String {
@@ -11,7 +14,7 @@ fn greet(name: &str) -> String {
 
 fn main() {
     tauri::Builder::default()
-        .invoke_handler(tauri::generate_handler![greet, init_config, load_config, write_config])
+        .invoke_handler(tauri::generate_handler![greet, init_config, load_config, write_config, extract_wad, load_champions])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }

src/app.rs

@@ -1,9 +1,8 @@
 use wasm_bindgen::prelude::*;
-use wasm_bindgen_futures::spawn_local;
 use yew::prelude::*;
 use yew_router::prelude::*;
 
-use crate::{config_settings::init_config, views::*};
+use crate::views::*;
 
 #[wasm_bindgen]
 extern "C" {
@@ -16,6 +15,8 @@ pub enum Route {
     #[at("/")]
     Home,
     #[at("/extract")]
+    ExtractRoot,
+    #[at("/extract/*")]
     Extract,
     #[at("/settings")]
     Settings,
@@ -27,20 +28,32 @@ pub enum Route {
 
 #[function_component(App)]
 pub fn app() -> Html { 
+    let fallback = html! {<div class="content" >{"Loading..."}</div>};
+
     html! {
         <BrowserRouter>
-            <nav::Nav/>
+        <nav::Nav/>
-            <Switch<Route> render={switch} />
+            <Suspense {fallback}>
+                <Switch<Route> render={switch} />
+            </Suspense>
         </BrowserRouter>
     }
 }
 
-fn switch(routes: Route) -> Html {
+fn switch(route: Route) -> Html {
-    match routes {
+    match route {
         Route::Home => html! { <Home/> },
-        Route::Extract => html! { <Extract/> },
+        Route::ExtractRoot | Route::Extract => html! { <Switch<ExtractRoute> render={switch_extract}/> },
         Route::Settings => html! { <Settings/> },
-        Route::NotFound => html! { <h1>{"404 Page Not Found"}</h1> },
+        Route::NotFound => html! { <NotFound/> },
     }
 }
 
+#[function_component(NotFound)]
+pub fn not_found() -> Html {
+    html! {
+        <h2 class={"content"}>
+            {"Not Found"}
+        </h2>
+    }
+}

src/config_settings.rs

@@ -1,5 +1,5 @@
 use serde::{Deserialize, Serialize};
-use serde_wasm_bindgen::to_value;
+use serde_wasm_bindgen::*;
 use wasm_bindgen::prelude::*;
 
 #[derive(Default, Clone, Serialize, Deserialize)]
@@ -25,8 +25,6 @@ pub async fn write_config(config: Config) -> Result<JsValue, JsValue> {
     write_config_js(to_value(&config).unwrap()).await
 }
 
-pub async fn load_config() -> Result<Config, JsValue> {
+pub async fn load_config() -> Result<Config, Error> {
-    Ok(serde_wasm_bindgen::from_value(load_config_js().await.unwrap()).unwrap())
+    from_value(load_config_js().await.unwrap())
-}
+}
-
-

src/extractor.rs

@@ -1,56 +1,19 @@
-use std::process::Command;
+use serde::{Deserialize, Serialize};
-use std::env;
+use serde_wasm_bindgen::*;
-use std::fs;
+use wasm_bindgen::prelude::*;
-use walkdir::WalkDir;
-use std::ffi::OsString;
-use std::path::PathBuf;
 
-use crate::config_settings;
+#[derive(Serialize, Deserialize, Clone)]
-
+pub struct Champion {
-pub fn extract_wad() {
+    pub name: String,
-    let config = config_settings::load_config();
+    pub location: String,
-    let wad_files: Vec<OsString> = WalkDir::new(config.wad_dir)
-        .into_iter()
-        .filter_map(|entry| entry.ok())
-        .filter(|entry| {
-            let path = entry.path();
-            let file_name = path.file_name().and_then(|name| name.to_str()).unwrap_or("");
-            let extension = path.extension().and_then(|ext| ext.to_str()).unwrap_or("");
-            extension == "client" &&
-            file_name.ends_with(".wad.client") &&
-            file_name.split('.').count() == 3
-        })
-        .map(|entry| entry.path().to_owned().into_os_string())
-        .collect();
-
-    if wad_files.is_empty() {
-        eprintln!("No valid .wad.client files found in the directory");
-        return;
-    }
-
-    let current_dir = env::current_dir().expect("Failed to get current directory");
-    let extraction_path = current_dir.join("wads");
-    let bat_path = PathBuf::from(config.cslol_dir).join("cslol-tools\\wad-extract.exe");
-
-    if !extraction_path.exists() {
-        fs::create_dir_all(&extraction_path).expect("Failed to create extraction folder");
-    }
-
-    for (i, wad_file) in wad_files.iter().enumerate() {
-        let status = Command::new(&bat_path)
-            .arg(&wad_file)
-            .arg(&extraction_path)
-            .status()
-            .expect("Failed to execute command");
-
-        if status.success() {
-            println!("Successfully executed wad-extract.bat for {:?}", wad_file);
-        } else {
-            eprintln!("wad-extract.bat returned a non-zero status for {:?}", wad_file);
-        }
-        
-        if i >= 3 {
-            break;
-        }
-    }
 }
+
+#[wasm_bindgen(module = "/public/glue.js")]
+extern "C" {
+    #[wasm_bindgen(js_name = load_champions_js, catch)]
+    pub async fn load_champions_js() -> Result<JsValue, JsValue>;
+}
+
+pub async fn load_champions() -> Result<Vec<Champion>, Error> {
+    from_value(load_champions_js().await.unwrap())
+}

src/main.rs

@@ -1,12 +1,16 @@
 mod app;
 mod views;
-// mod extractor;
+mod extractor;
 mod config_settings;
 
 use app::App;
+use config_settings::init_config;
+use yew::platform::spawn_local;
 
 fn main() {
-
     console_error_panic_hook::set_once();
     yew::Renderer::<App>::new().render();
+    spawn_local(async move {
+        let _ = init_config().await;
+    })
 }

src/views/extract.rs

@@ -1,18 +1,76 @@
-use yew::prelude::*;
+use wasm_bindgen::convert::IntoWasmAbi;
+use yew::{prelude::*, suspense::use_future};
+use yew_router::prelude::*;
+use web_sys::{console, HtmlSelectElement};
+
+use crate::{app::Route, extractor::load_champions};
+
+#[derive(Clone, Routable, PartialEq)]
+pub enum ExtractRoute {
+    #[at("/extract")]
+    Extract,
+    #[at("/extract/skinselect")]
+    SkinSelect,
+    #[not_found]
+    #[at("/404")]
+    NotFound,
+}
+
+pub fn switch_extract(route: ExtractRoute) -> Html {
+    match route {
+        ExtractRoute::Extract => html! { <Extract/> },
+        ExtractRoute::SkinSelect => html! { <SkinSelect/> },
+        ExtractRoute::NotFound => html!{ <Redirect<Route> to={Route::NotFound}/> },
+    }
+}
 
 #[function_component(Extract)]
-pub fn extract() -> Html {
+pub fn extract() -> HtmlResult {
-    html! {
-        <div class="content">
-        <h2>{"Extract"}</h2>
-        <p>{"Exctract shit"}</p>
 
-        <form action="/extract-wads" method="post">
+    let champions_future = use_future(|| async {load_champions().await})?;
-            <div class="option">
+
-                <button type="submit">{"Extract WADs"}</button>
+    let champions = champions_future.as_ref().unwrap().clone();
+
+    let champion_selected_handle = use_state(|| champions[0].name.clone());
+    let champion_selected = (*champion_selected_handle).clone();
+
+    let on_submit = {
+        let champion_selected_handle = champion_selected_handle.clone();
+
+        Callback::from(move |event: SubmitEvent| {
+            let champion_selected_event = event.target_unchecked_into::<web_sys::HtmlSelectElement>();
+
+            web_sys::console::log_1(&(*champion_selected_handle).clone().into());
+            champion_selected_handle.set(champion_selected_event.value());
+        })
+    };
+
+    Ok(
+        html! {
+            <div class="content">
+                <h2>{"Extract"}</h2>
+                <p>{"Exctract shit"}</p>
+
+                <div class="option">
+                    <form id="champion" onsubmit={on_submit}>
+                        <select id="champion">
+                        { for champions.iter().enumerate().map(|(index, champion)| html! {
+                            <option value={champion.name.clone()} selected={champion.name == champion_selected}>{&champion.name}</option>
+                        }) }
+                        </select>
+                        <br/>
+                        <button type="submit">{"Select"} </button>
+                    </form>
+                </div>
             </div>
-        </form>
+        }
+    )
+
+}
+
+#[function_component(SkinSelect)]
+pub fn skinselect() -> Html {
+    html! {
 
-    </div>
     }
 }

src/views/nav.rs

@@ -7,7 +7,7 @@ pub fn nav() -> Html {
     html! {
         <div class="nav">
             <Link<Route> to={Route::Home}>{"Home"}</Link<Route>>
-            <Link<Route> to={Route::Extract}>{"Extract"}</Link<Route>>
+            <Link<Route> to={Route::ExtractRoot}>{"Extract"}</Link<Route>>
             <Link<Route> to={Route::Settings}>{"Settings"}</Link<Route>>
         </div>
     }

src/views/settings.rs

@@ -1,31 +1,14 @@
-use std::{cell::RefCell, rc::Rc};
+use yew::suspense::use_future;
-
 use crate::config_settings::*;
 use wasm_bindgen_futures::spawn_local;
-use web_sys::{console, HtmlInputElement};
+use web_sys::HtmlInputElement;
 use yew::prelude::*;
 
 #[function_component(Settings)]
-pub fn settings() -> Html {
+pub fn settings() -> HtmlResult {
+    let config_future = use_future(|| async {load_config().await})?;
 
-    let config = Rc::new(RefCell::new(Config::default()));
+    let config = config_future.as_ref().unwrap().clone();
-    {
-        let config = config.clone();
-
-        use_effect(move || {
-            spawn_local(async move {
-                init_config().await.unwrap();
-                *config.borrow_mut() = load_config().await.unwrap();
-                console::log_1(&config.borrow().cslol_dir.clone().into());
-            })
-        })
-
-        // spawn_local(async move {
-        //     init_config().await.unwrap();
-        //     *config.borrow_mut() = load_config().await.unwrap();
-        //     console::log_1(&config.borrow().cslol_dir.clone().into());
-        // })
-    }
 
     let cslol_dir_ref = use_node_ref();
     let wad_dir_ref = use_node_ref();
@@ -36,9 +19,7 @@ pub fn settings() -> Html {
         let wad_dir_ref = wad_dir_ref.clone();
         let extract_dir_ref = extract_dir_ref.clone();
 
-        Callback::from(move |event: SubmitEvent| {
+        Callback::from(move |_event: SubmitEvent| {
-            event.prevent_default();
-
             let cslol_dir = cslol_dir_ref.cast::<HtmlInputElement>().unwrap().value();
             let wad_dir = wad_dir_ref.cast::<HtmlInputElement>().unwrap().value();
             let extract_dir = extract_dir_ref.cast::<HtmlInputElement>().unwrap().value();
@@ -48,16 +29,14 @@ pub fn settings() -> Html {
                 wad_dir,
                 extract_dir,
             };
+
             spawn_local(async move {
                 write_config(config).await.unwrap();
             });
         })
     };
-    
-    let mut tconfig = config.try_borrow().unwrap().clone();
-    console::log_1(&tconfig.cslol_dir.clone().into());
-    console::log_1(&"IM MAD".into());
 
+    Ok(
     html! {
         <div class="content">
             <h2>{"Settings"}</h2>
@@ -66,19 +45,19 @@ pub fn settings() -> Html {
                     <div>
                         <label for="cslol_dir">{"Location of CSLoL"}</label>
                         <br/>
-                        <input id="cslol_dir" ref={cslol_dir_ref} value={tconfig.cslol_dir.clone()}/>
+                        <input id="cslol_dir" ref={cslol_dir_ref} value={config.cslol_dir.clone()}/>
                     </div>
 
                     <div>
                         <label for="wad_dir">{"Custom location of Champion Wads"}</label>
                         <br/>
-                        <input id="wad_dir" ref={wad_dir_ref} />
+                        <input id="wad_dir" ref={wad_dir_ref} value={config.wad_dir.clone()}/>
                     </div>
 
                     <div>
                         <label for="extract_dir">{"Custom location to Extract to"}</label>
                         <br/>
-                        <input id="extract_dir" ref={extract_dir_ref} />
+                        <input id="extract_dir" ref={extract_dir_ref} value={config.extract_dir.clone()}/>
                     </div>
 
 
@@ -87,4 +66,5 @@ pub fn settings() -> Html {
             </div>
         </div>
     }
+)
 }