Add webui

src/main.rs

@@ -6,7 +6,8 @@ use actix_web::{
     HttpResponse,
     HttpRequest,
     web,
-    dev::Service
+    dev::Service,
+    http::header::ContentType
 };
 
 #[post("/v1.0/auth/initialize")]
@@ -216,7 +217,37 @@ async fn card_skill_reinforce(req: HttpRequest, body: String) -> HttpResponse {
 #[post("/api/card/evolve")]
 async fn card_evolve(req: HttpRequest, body: String) -> HttpResponse { router::card::evolve(req, body) }
 
+
+#[post("/api/webui/login")]
+async fn webui_login(req: HttpRequest, body: String) -> HttpResponse { router::webui::login(req, body) }
+
+#[get("/api/webui/userInfo")]
+async fn webui_user(req: HttpRequest) -> HttpResponse { router::webui::user(req) }
+
+#[get("/webui/logout")]
+async fn webui_logout(req: HttpRequest) -> HttpResponse { router::webui::logout(req) }
+
+fn unhandled(req: HttpRequest) -> HttpResponse {
+    router::webui::main(req)
+}
+#[get("/index.css")]
+async fn css(_req: HttpRequest) -> HttpResponse {
+    HttpResponse::Ok()
+        .insert_header(ContentType(mime::TEXT_CSS))
+        .body(include_str!("../webui/dist/index.css"))
+}
+#[get("/index.js")]
+async fn js(_req: HttpRequest) -> HttpResponse {
+    HttpResponse::Ok()
+        .insert_header(ContentType(mime::APPLICATION_JAVASCRIPT_UTF_8))
+        .body(include_str!("../webui/dist/index.js"))
+}
+
+
 async fn log_unknown_request(req: HttpRequest, body: String) -> HttpResponse {
+    if !req.path().starts_with("/api") {
+        return unhandled(req);
+    }
     if body != String::new() {
         println!("{}", encryption::decrypt_packet(&body).unwrap());
     }
@@ -233,6 +264,11 @@ async fn main() -> std::io::Result<()> {
             println!("Request: {}", req.path());
             srv.call(req)
         })
+        .service(css)
+        .service(js)
+        .service(webui_logout)
+        .service(webui_user)
+        .service(webui_login)
         .service(card_evolve)
         .service(card_skill_reinforce)
         .service(card_reinforce)

src/router.rs

@@ -19,3 +19,4 @@ pub mod gree;
 pub mod serial_code;
 pub mod web;
 pub mod card;
+pub mod webui;

src/router/userdata/mod.rs

@@ -3,6 +3,7 @@ use std::sync::{Mutex, MutexGuard};
 use lazy_static::lazy_static;
 use json::{JsonValue, array, object};
 use crate::router::global;
+use uuid::Uuid;
 use rand::Rng;
 
 lazy_static! {
@@ -398,3 +399,68 @@ pub fn get_random_uids(count: i32) -> JsonValue {
     }
     lock_and_select_all(&format!("SELECT user_id FROM uids ORDER BY RANDOM() LIMIT {}", count), params!()).unwrap()
 }
+
+fn create_webui_store() {
+    create_store_v2("CREATE TABLE IF NOT EXISTS webui (
+        user_id      BIGINT NOT NULL PRIMARY KEY,
+        token        TEXT NOT NULL,
+        last_login   BIGINT NOT NULL
+    )");
+}
+
+fn create_webui_token() -> String {
+    let token = format!("{}", Uuid::new_v4());
+    if lock_and_select("SELECT user_id FROM webui WHERE token=?1", params!(token)).is_ok() {
+        return create_webui_token();
+    }
+    token
+}
+
+pub fn webui_login(uid: i64, password: &str) -> Result<String, String> {
+    create_webui_store();
+    create_migration_store();
+    let pass = lock_and_select("SELECT password FROM migration WHERE token=?1", params!(crate::router::user::uid_to_code(uid.to_string()))).unwrap_or(String::new());
+    if pass != password.to_string() || password == "" {
+        if acc_exists(uid) {
+            return Err(String::from("Migration token not set. Set token in game settings."));
+        }
+        return Err(String::from("User/password don't match"));
+    }
+    
+    let new_token = create_webui_token();
+    
+    lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(uid));
+    lock_and_exec("INSERT INTO webui (user_id, token, last_login) VALUES (?1, ?2, ?3)", params!(uid, new_token, global::timestamp()));
+    Ok(new_token)
+}
+
+pub fn webui_get_user(token: &str) -> Option<JsonValue> {
+    let uid = lock_and_select("SELECT user_id FROM webui WHERE token=?1", params!(token)).unwrap_or(String::new());
+    if uid == String::new() || token == "" {
+        return None;
+    }
+    let uid = uid.parse::<i64>().unwrap_or(0);
+    if uid == 0 {
+        return None;
+    }
+    let last_login = lock_and_select("SELECT last_login FROM webui WHERE user_id=?1", params!(uid)).unwrap_or(String::new()).parse::<i64>().unwrap_or(0);
+    let limit = 24 * 60 * 60; //1 day
+    //Expired token
+    if (global::timestamp() as i64) > last_login + limit {
+        lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(uid));
+        return None;
+    }
+    
+    let login_token = lock_and_select("SELECT token FROM tokens WHERE user_id=?1", params!(uid)).unwrap_or(String::new());
+    if login_token == String::new() {
+        return None;
+    }
+    return Some(object!{
+        userdata: get_acc(&login_token),
+        loginbonus: get_acc_loginbonus(&login_token)
+    });
+}
+
+pub fn webui_logout(token: &str) {
+    lock_and_exec("DELETE FROM webui WHERE token=?1", params!(token));
+}

src/router/webui.rs

@@ -0,0 +1,101 @@
+use actix_web::{HttpResponse, HttpRequest, http::header::HeaderValue, http::header::ContentType};
+use json::object;
+use crate::router::userdata;
+use crate::router::global;
+
+fn get_login_token(req: &HttpRequest) -> Option<String> {
+    let blank_header = HeaderValue::from_static("");
+    let cookies = req.headers().get("Cookie").unwrap_or(&blank_header).to_str().unwrap_or("");
+    if cookies == "" {
+        return None;
+    }
+    return Some(cookies.split("ew_token=").last().unwrap_or("").split(';').collect::<Vec<_>>()[0].to_string());
+}
+
+fn error(msg: &str) -> HttpResponse {
+    let resp = object!{
+        result: "ERR",
+        message: msg
+    };
+    HttpResponse::Ok()
+        .insert_header(("Access-Control-Allow-Origin", "*"))
+        .insert_header(ContentType::json())
+        .body(json::stringify(resp))
+    
+}
+
+pub fn login(_req: HttpRequest, body: String) -> HttpResponse {
+    let body = json::parse(&body).unwrap();
+    let token = userdata::webui_login(body["uid"].as_i64().unwrap(), &body["password"].to_string());
+    
+    if token.is_err() {
+        return error(&token.unwrap_err());
+    }
+    
+    let resp = object!{
+        result: "OK"
+    };
+    HttpResponse::Ok()
+        .insert_header(ContentType::json())
+        .insert_header(("Set-Cookie", format!("ew_token={}; SameSite=Strict; HttpOnly", token.unwrap())))
+        .body(json::stringify(resp))
+}
+
+pub fn user(req: HttpRequest) -> HttpResponse {
+    let token = get_login_token(&req);
+    if token.is_none() {
+        return error("Not logged in");
+    }
+    let data = userdata::webui_get_user(&token.unwrap());
+    if data.is_none() {
+        return error("Expired login");
+    }
+    let mut data = data.unwrap();
+    
+    data["userdata"]["user"]["rank"] = global::get_user_rank_data(data["userdata"]["user"]["exp"].as_i64().unwrap())["rank"].clone();
+    
+    let resp = object!{
+        result: "OK",
+        data: data
+    };
+    HttpResponse::Ok()
+        .insert_header(ContentType::json())
+        .body(json::stringify(resp))
+}
+
+pub fn logout(req: HttpRequest) -> HttpResponse {
+    let token = get_login_token(&req);
+    if !token.is_none() {
+        userdata::webui_logout(&token.unwrap());
+    }
+    let resp = object!{
+        result: "OK"
+    };
+    HttpResponse::Found()
+        .insert_header(ContentType::json())
+        .insert_header(("Set-Cookie", "ew_token=deleted; expires=Thu, 01 Jan 1970 00:00:00 GMT"))
+        .insert_header(("Location", "/"))
+        .body(json::stringify(resp))
+}
+
+pub fn main(req: HttpRequest) -> HttpResponse {
+    if req.path() == "/" {
+        let token = get_login_token(&req);
+        if !token.is_none() {
+            let data = userdata::webui_get_user(&token.unwrap());
+            if !data.is_none() {
+                return HttpResponse::Found()
+                    .insert_header(("Location", "/home/"))
+                    .body("");
+            }
+        }
+    }
+    if req.path() != "/" && req.path() != "/home/" {
+        return HttpResponse::Found()
+            .insert_header(("Location", "/"))
+            .body("");
+    }
+    HttpResponse::Ok()
+        .insert_header(ContentType::html())
+        .body(include_str!("../../webui/dist/index.html"))
+}