stuff idk

Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 [dependencies]
 actix-web = { version = "4.5.1", features = [ "openssl" ] }
 rusqlite = { version = "0.30.0", features = ["bundled"] }
-openssl = { version = "0.10", features = [ "vendored" ] }
+openssl = { version = "0.10" }
 base64 = "0.21.5"
 json = "0.12.4"
 rand = "0.8.5"

src/main.rs

@@ -11,34 +11,28 @@ use actix_web::{
     HttpRequest,
     web,
     dev::Service,
-    http::header::ContentType
+    http::header::ContentType,
+    http::header::HeaderValue
 };
+use crate::router::global;
+use json::JsonValue;
 
-fn unhandled(req: HttpRequest, body: String) -> HttpResponse {
+fn unhandled(req: HttpRequest, body: String) -> Option<JsonValue> {
-    if !req.path().starts_with("/api") {
-        return router::webui::main(req);
-    }
     if body != String::new() {
         println!("{}", encryption::decrypt_packet(&body).unwrap_or(body));
     }
     println!("Unhandled request: {}", req.path());
-    let resp = object!{
+    None
-        "code": 2,
-        "server_time": router::global::timestamp(),
-        "data": ""
-    };
-    router::global::send(resp, req)
 }
 
-async fn request(req: HttpRequest, body: String) -> HttpResponse {
+fn api_req(req: HttpRequest, body: String) -> HttpResponse {
-    if req.method() == "POST" {
+    if !req.path().starts_with("/api") && !req.path().starts_with("/v1.0") {
+        return router::webui::main(req);
+    }
+    let blank_header = HeaderValue::from_static("");
+    let uid = req.headers().get("aoharu-user-id").unwrap_or(&blank_header).to_str().unwrap_or("").parse::<i64>().unwrap_or(0);
+    let resp: Option<JsonValue> = if req.method() == "POST" {
         match req.path() {
-            "/v1.0/auth/initialize" => router::gree::initialize(req, body),
-            "/v1.0/moderate/filtering/commit" => router::gree::moderate_commit(req, body),
-            "/v1.0/auth/authorize" => router::gree::authorize(req, body),
-            "/v1.0/migration/code/verify" => router::gree::migration_verify(req, body),
-            "/v1.0/migration/password/register" => router::gree::migration_password_register(req, body),
-            "/v1.0/migration" => router::gree::migration(req, body),
             "/api/debug/error" => router::debug::error(req, body),
             "/api/start" => router::start::start(req, body),
             "/api/start/assetHash" => router::start::asset_hash(req, body),
@@ -93,10 +87,6 @@ async fn request(req: HttpRequest, body: String) -> HttpResponse {
             "/api/card/skill/reinforce" => router::card::skill_reinforce(req, body),
             "/api/card/evolve" => router::card::evolve(req, body),
             "/api/shop/buy" => router::shop::buy(req, body),
-            "/api/webui/login" => router::webui::login(req, body),
-            "/api/webui/startLoginbonus" => router::webui::start_loginbonus(req, body),
-            "/api/webui/import" => router::webui::import(req, body),
-            "/api/webui/set_time" => router::webui::set_time(req, body),
             "/api/user/getregisteredplatformlist" => router::user::getregisteredplatformlist(req, body),
             "/api/user/sif/migrate" => router::user::sif_migrate(req, body),
             "/api/user/ss/migrate" => router::user::sifas_migrate(req, body),
@@ -106,13 +96,6 @@ async fn request(req: HttpRequest, body: String) -> HttpResponse {
         }
     } else {
         match req.path() {
-            "/v1.0/auth/x_uid" => router::gree::uid(req),
-            "/v1.0/payment/productlist" => router::gree::payment(req),
-            "/v1.0/payment/subscription/productlist" => router::gree::payment(req),
-            "/v1.0/payment/ticket/status" => router::gree::payment_ticket(req),
-            "/v1.0/moderate/keywordlist" => router::gree::moderate_keyword(req),
-            "/v1.0/migration/code" => router::gree::migration_code(req),
-            "/v1.0/payment/balance" => router::gree::balance(req),
             "/api/user" => router::user::user(req),
             "/api/gift" => router::home::gift_get(req),
             "/api/purchase" => router::purchase::purchase(req),
@@ -125,14 +108,58 @@ async fn request(req: HttpRequest, body: String) -> HttpResponse {
             "/api/notice/reward" => router::notice::reward(req),
             "/api/serial_code/events" => router::serial_code::events(req),
             "/api/album/sif" => router::user::sif(req),
-            "/web/announcement" => router::web::announcement(req),
             "/api/home/announcement" => router::user::announcement(req),
             "/api/shop" => router::shop::shop(req),
-            "/api/webui/userInfo" => router::webui::user(req),
-            "/webui/logout" => router::webui::logout(req),
             "/api/exchange" => router::exchange::exchange(req),
             _ => unhandled(req, body)
         }
+    };
+    if resp.is_some() {
+        let rv = object!{
+            "code": 0,
+            "server_time": global::timestamp(),
+            "data": resp.unwrap()
+        };
+        return global::send(rv, uid);
+    } else {
+        let rv = object!{
+            "code": 2,//Idontnermemrmemremremermrme
+            "server_time": global::timestamp(),
+            "data": ""
+        };
+        return global::send(rv, uid);
+    }
+}
+
+async fn request(req: HttpRequest, body: String) -> HttpResponse {
+    if req.method() == "POST" {
+        match req.path() {
+            "/v1.0/auth/initialize" => router::gree::initialize(req, body),
+            "/v1.0/moderate/filtering/commit" => router::gree::moderate_commit(req, body),
+            "/v1.0/auth/authorize" => router::gree::authorize(req, body),
+            "/v1.0/migration/code/verify" => router::gree::migration_verify(req, body),
+            "/v1.0/migration/password/register" => router::gree::migration_password_register(req, body),
+            "/v1.0/migration" => router::gree::migration(req, body),
+            "/api/webui/login" => router::webui::login(req, body),
+            "/api/webui/startLoginbonus" => router::webui::start_loginbonus(req, body),
+            "/api/webui/import" => router::webui::import(req, body),
+            "/api/webui/set_time" => router::webui::set_time(req, body),
+            _ => api_req(req, body)
+        }
+    } else {
+        match req.path() {
+            "/v1.0/auth/x_uid" => router::gree::uid(req),
+            "/v1.0/payment/productlist" => router::gree::payment(req),
+            "/v1.0/payment/subscription/productlist" => router::gree::payment(req),
+            "/v1.0/payment/ticket/status" => router::gree::payment_ticket(req),
+            "/v1.0/moderate/keywordlist" => router::gree::moderate_keyword(req),
+            "/v1.0/migration/code" => router::gree::migration_code(req),
+            "/v1.0/payment/balance" => router::gree::balance(req),
+            "/web/announcement" => router::web::announcement(req),
+            "/api/webui/userInfo" => router::webui::user(req),
+            "/webui/logout" => router::webui::logout(req),
+            _ => api_req(req, body)
+        }
     }
 }
 

src/router/card.rs

@@ -35,7 +35,7 @@ fn do_reinforce(user: &mut JsonValue, body: &JsonValue, exp_id: &str, money_mult
     object!{}
 }
 
-pub fn reinforce(req: HttpRequest, body: String) -> HttpResponse {
+pub fn reinforce(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -44,20 +44,15 @@ pub fn reinforce(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         card: card,
         item_list: user["item_list"].clone(),
         point_list: user["point_list"].clone(),
         clear_mission_ids: []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn skill_reinforce(req: HttpRequest, body: String) -> HttpResponse {
+pub fn skill_reinforce(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -66,20 +61,15 @@ pub fn skill_reinforce(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         card: card,
         item_list: user["item_list"].clone(),
         point_list: user["point_list"].clone(),
         clear_mission_ids: []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn evolve(req: HttpRequest, body: String) -> HttpResponse {
+pub fn evolve(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -88,15 +78,10 @@ pub fn evolve(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         card: card,
         item_list: user["item_list"].clone(),
         point_list: user["point_list"].clone(),
         clear_mission_ids: []
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/chat.rs

@@ -14,7 +14,7 @@ pub fn add_chat(id: i64, num: i64, chats: &mut JsonValue) {
     }).unwrap();
 }
 
-pub fn home(req: HttpRequest, body: String) -> HttpResponse {
+pub fn home(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let chats = userdata::get_acc_chats(&key);
     
@@ -23,30 +23,19 @@ pub fn home(req: HttpRequest, body: String) -> HttpResponse {
         rooms.push(databases::CHATS[data["chat_id"].to_string()][data["room_id"].to_string()]["id"].clone()).unwrap();
     }
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "progress_list": chats,
         "master_chat_room_ids": rooms,
         "master_chat_stamp_ids": [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,43,44,45,46,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,11001003,22001001,33001001,44001002],
         "master_chat_attachment_ids": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn start(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn start(req: HttpRequest, _body: String) -> Option<JsonValue> {
-    
+    Some(object!{"select_talk_id_list":[],"get_item_list":[],"is_read":0})
-    let resp = object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {"select_talk_id_list":[],"get_item_list":[],"is_read":0}
-    };
-    global::send(resp, req)
 }
 
-pub fn end(req: HttpRequest, body: String) -> HttpResponse {
+pub fn end(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut missions = userdata::get_acc_missions(&key);
@@ -64,10 +53,5 @@ pub fn end(req: HttpRequest, body: String) -> HttpResponse {
         }
     }
     
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }

src/router/clear_rate.rs

@@ -201,16 +201,11 @@ fn get_clearrate_json() -> JsonValue {
     }
 }
 
-pub fn clearrate(req: HttpRequest) -> HttpResponse {
+pub fn clearrate(req: HttpRequest) -> Option<JsonValue> {
-    let resp = object!{
+    Some(get_clearrate_json())
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": get_clearrate_json()
-    };
-    global::send(resp, req)
 }
 
-pub fn ranking(req: HttpRequest, body: String) -> HttpResponse {
+pub fn ranking(req: HttpRequest, body: String) -> Option<JsonValue> {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let live = body["master_live_id"].as_i64().unwrap();
     
@@ -232,12 +227,7 @@ pub fn ranking(req: HttpRequest, body: String) -> HttpResponse {
         }).unwrap();
     }
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "ranking_list": rank
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/debug.rs

@@ -1,18 +1,13 @@
-use json::object;
+use json::{object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::global;
 use crate::encryption;
 
-pub fn error(req: HttpRequest, body: String) -> HttpResponse {
+pub fn error(req: HttpRequest, body: String) -> Option<JsonValue> {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
     println!("client error: {}", body["code"]);
     
-    let resp = object!{
+    None
-        "code": 2,
-        "server_time": global::timestamp(),
-        "message": ""
-    };
-    global::send(resp, req)
 }

src/router/event.rs

@@ -3,7 +3,7 @@ use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::{userdata, global};
 
-pub fn event(req: HttpRequest, body: String) -> HttpResponse {
+pub fn event(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let mut event = userdata::get_acc_event(&key);
     
@@ -11,12 +11,7 @@ pub fn event(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc_event(&key, event.clone());
     
-    let resp = object!{
+    Some(event["event_data"].clone())
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": event["event_data"].clone()
-    };
-    global::send(resp, req)
 }
 
 fn switch_music(event: &mut JsonValue, music_id: i32, target_score: i64, index: i32) {
@@ -44,36 +39,26 @@ fn init_star_event(event: &mut JsonValue) {
     switch_music(event, 2160, 21991, 5);
 }
 
-pub fn star_event(req: HttpRequest, body: String) -> HttpResponse {
+pub fn star_event(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let mut event = userdata::get_acc_event(&key);
     init_star_event(&mut event);
     
     userdata::save_acc_event(&key, event.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         star_event: event["event_data"]["star_event"].clone(),
         gift_list: [],
         reward_list: []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
 //todo - randomize
-pub fn change_target_music(req: HttpRequest, body: String) -> HttpResponse {
+pub fn change_target_music(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let event = userdata::get_acc_event(&key);
     
     //event["star_event"]["music_change_count"] += 1;
     
-    let resp = object!{
+    Some(event["event_data"]["star_event"].clone())
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": event["event_data"]["star_event"].clone()
-    };
-    global::send(resp, req)
 }

src/router/exchange.rs

@@ -1,19 +1,14 @@
-use json::{object, array};
+use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::{global, userdata, items, databases};
 use crate::encryption;
 
-pub fn exchange(req: HttpRequest) -> HttpResponse {
+pub fn exchange(req: HttpRequest) -> Option<JsonValue> {
-    let resp = object!{
+    Some(object!{"exchange_list":[]})
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {"exchange_list":[]}
-    };
-    global::send(resp, req)
 }
 
-pub fn exchange_post(req: HttpRequest, body: String) -> HttpResponse {
+pub fn exchange_post(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -36,10 +31,7 @@ pub fn exchange_post(req: HttpRequest, body: String) -> HttpResponse {
     userdata::save_acc(&key, user.clone());
     userdata::save_acc_missions(&key, missions);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "exchange": body,
         "updated_value_list": {
             "card_list": user["card_list"].clone(),
@@ -47,7 +39,5 @@ pub fn exchange_post(req: HttpRequest, body: String) -> HttpResponse {
             "point_list": user["point_list"].clone()
         },
         "clear_mission_ids": cleared_missions
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/friend.rs

@@ -1,4 +1,4 @@
-use json::{object, array};
+use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::{userdata, global};
@@ -6,7 +6,7 @@ use crate::encryption;
 
 pub const FRIEND_LIMIT: usize = 40;
 
-pub fn friend(req: HttpRequest, body: String) -> HttpResponse {
+pub fn friend(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let friends = userdata::get_acc_friends(&key);
@@ -27,29 +27,19 @@ pub fn friend(req: HttpRequest, body: String) -> HttpResponse {
         rv.push(global::get_user(uid.as_i64().unwrap(), &friends, false)).unwrap();
     }
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "friend_list": rv
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn ids(req: HttpRequest) -> HttpResponse {
+pub fn ids(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     let friends = userdata::get_acc_friends(&key);
     
-    let resp = object!{
+    Some(friends)
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": friends
-    };
-    global::send(resp, req)
 }
 
-pub fn recommend(req: HttpRequest, body: String) -> HttpResponse {
+pub fn recommend(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
     let friends = userdata::get_acc_friends(&key);
@@ -69,17 +59,12 @@ pub fn recommend(req: HttpRequest, body: String) -> HttpResponse {
         rv.push(user).unwrap();
     }
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         friend_list: rv
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn search(req: HttpRequest, body: String) -> HttpResponse {
+pub fn search(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let friends = userdata::get_acc_friends(&key);
@@ -87,15 +72,10 @@ pub fn search(req: HttpRequest, body: String) -> HttpResponse {
     let uid = body["user_id"].as_i64().unwrap();
     let user = global::get_user(uid, &friends, false);
     
-    let resp = object!{
+    Some(user)
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": user
-    };
-    global::send(resp, req)
 }
 
-pub fn request(req: HttpRequest, body: String) -> HttpResponse {
+pub fn request(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
@@ -110,15 +90,10 @@ pub fn request(req: HttpRequest, body: String) -> HttpResponse {
         userdata::friend_request(uid, user_id);
     }
     
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }
 
-pub fn approve(req: HttpRequest, body: String) -> HttpResponse {
+pub fn approve(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
@@ -136,15 +111,10 @@ pub fn approve(req: HttpRequest, body: String) -> HttpResponse {
         userdata::save_acc_friends(&key, friends);
     }
     
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }
 
-pub fn cancel(req: HttpRequest, body: String) -> HttpResponse {
+pub fn cancel(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
@@ -158,15 +128,10 @@ pub fn cancel(req: HttpRequest, body: String) -> HttpResponse {
     userdata::friend_request_approve(uid, user_id, false, "pending_user_id_list");
     userdata::save_acc_friends(&key, friends);
     
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }
 
-pub fn delete(req: HttpRequest, body: String) -> HttpResponse {
+pub fn delete(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
@@ -180,10 +145,5 @@ pub fn delete(req: HttpRequest, body: String) -> HttpResponse {
     userdata::friend_remove(uid, user_id);
     userdata::save_acc_friends(&key, friends);
     
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }

src/router/global.rs

@@ -95,9 +95,7 @@ fn init_time(server_data: &mut JsonValue, token: &str) {
     }
 }
 
-fn set_time(data: &mut JsonValue, req: HttpRequest) {
+fn set_time(data: &mut JsonValue, uid: i64) {
-    let blank_header = HeaderValue::from_static("");
-    let uid = req.headers().get("aoharu-user-id").unwrap_or(&blank_header).to_str().unwrap_or("").parse::<i64>().unwrap_or(0);
     if uid == 0 {
         return;
     }
@@ -115,9 +113,9 @@ fn set_time(data: &mut JsonValue, req: HttpRequest) {
     data["server_time"] = (server_time + time_since_set).into();
 }
 
-pub fn send(mut data: JsonValue, req: HttpRequest) -> HttpResponse {
+pub fn send(mut data: JsonValue, uid: i64) -> HttpResponse {
     //println!("{}", json::stringify(data.clone()));
-    set_time(&mut data, req);
+    set_time(&mut data, uid);
     
     let encrypted = encryption::encrypt_packet(&json::stringify(data)).unwrap();
     let resp = encrypted.into_bytes();
@@ -125,10 +123,6 @@ pub fn send(mut data: JsonValue, req: HttpRequest) -> HttpResponse {
     HttpResponse::Ok().body(resp)
 }
 
-pub fn error_resp(req: HttpRequest) -> HttpResponse {
-    send(object!{}, req)
-}
-
 pub fn start_login_bonus(id: i64, bonus: &mut JsonValue) -> bool {
     if crate::router::login::get_login_bonus_info(id).is_empty() {
         return false;

src/router/home.rs

@@ -5,7 +5,7 @@ use lazy_static::lazy_static;
 use crate::router::{global, userdata, items};
 use crate::encryption;
 
-pub fn preset(req: HttpRequest, body: String) -> HttpResponse {
+pub fn preset(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc_home(&key);
@@ -17,12 +17,7 @@ pub fn preset(req: HttpRequest, body: String) -> HttpResponse {
     }
     userdata::save_acc_home(&key, user);
     
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }
 
 fn check_gifts(user: &mut JsonValue) {
@@ -37,35 +32,25 @@ fn check_gifts(user: &mut JsonValue) {
     }
 }
 
-pub fn gift_get(req: HttpRequest) -> HttpResponse {
+pub fn gift_get(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     let mut user = userdata::get_acc_home(&key);
     check_gifts(&mut user);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "gift_list": user["home"]["gift_list"].clone()
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn preset_get(req: HttpRequest) -> HttpResponse {
+pub fn preset_get(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     let user = userdata::get_acc(&key);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "master_preset_background_ids": [1,2,3,4,5],
         "master_preset_foreground_ids": [1,2,3],
         "card_list": user["card_list"].clone()
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
 
@@ -94,7 +79,7 @@ lazy_static! {
     };
 }
 
-pub fn home(req: HttpRequest) -> HttpResponse {
+pub fn home(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     let mut user = userdata::get_acc_home(&key);
     
@@ -127,10 +112,5 @@ pub fn home(req: HttpRequest) -> HttpResponse {
     user["home"]["clear_mission_count"] = clear_ct.into();
     user["home"]["not_cleared_daily_mission_count"] = (6 - daily_ct).into();
     
-    let resp = object!{
+    Some(user)
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": user
-    };
-    global::send(resp, req)
 }

src/router/items.rs

@@ -422,7 +422,7 @@ pub fn completed_daily_mission(id: i64, missions: &mut JsonValue) -> JsonValue {
     rv
 }
 
-pub fn use_item_req(req: HttpRequest, body: String) -> HttpResponse {
+pub fn use_item_req(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -439,13 +439,8 @@ pub fn use_item_req(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         item_list: user["item_list"].clone(),
         stamina: user["stamina"].clone()
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/live.rs

@@ -7,33 +7,23 @@ use crate::router::{global, userdata, items, databases};
 use crate::encryption;
 use crate::router::clear_rate::live_completed;
 
-pub fn retire(req: HttpRequest, body: String) -> HttpResponse {
+pub fn retire(req: HttpRequest, body: String) -> Option<JsonValue> {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     if body["live_score"]["play_time"].as_i64().unwrap_or(0) > 5 {
         live_completed(body["master_live_id"].as_i64().unwrap(), body["level"].as_i32().unwrap(), true, 0, 0);
     }
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "stamina": {},
         "item_list": [],
         "event_point_list": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn reward(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn reward(req: HttpRequest, _body: String) -> Option<JsonValue> {
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "ensured_list": [],
         "random_list": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
 fn random_number(lowest: usize, highest: usize) -> usize {
@@ -45,7 +35,7 @@ fn random_number(lowest: usize, highest: usize) -> usize {
     rand::thread_rng().gen_range(lowest..highest + 1)
 }
 
-pub fn guest(req: HttpRequest, body: String) -> HttpResponse {
+pub fn guest(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
     let friends = userdata::get_acc_friends(&key);
@@ -169,49 +159,29 @@ pub fn guest(req: HttpRequest, body: String) -> HttpResponse {
         }
     }
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "guest_list": guest_list
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn mission(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn mission(req: HttpRequest, _body: String) -> Option<JsonValue> {
     //todo
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "score_ranking": "",
         "combo_ranking": "",
         "clear_count_ranking": ""
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn start(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn start(req: HttpRequest, _body: String) -> Option<JsonValue> {
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }
 
-pub fn event_start(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn event_start(req: HttpRequest, _body: String) -> Option<JsonValue> {
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }
 
-pub fn continuee(req: HttpRequest, body: String) -> HttpResponse {
+pub fn continuee(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let mut user = userdata::get_acc(&key);
     
@@ -219,12 +189,7 @@ pub fn continuee(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(user["gem"].clone())
-        "code": 0,
-        "server_time": global::timestamp(),
-        "gem": user["gem"].clone()
-    };
-    global::send(resp, req)
 }
 
 pub fn update_live_data(user: &mut JsonValue, data: &JsonValue, add: bool) -> JsonValue {
@@ -558,9 +523,6 @@ fn live_end(req: &HttpRequest, body: &String, skipped: bool) -> JsonValue {
     userdata::save_acc_missions(&key, user_missions);
     
     object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "gem": user["gem"].clone(),
         "high_score": live["high_score"].clone(),
         "item_list": user["item_list"].clone(),
@@ -579,19 +541,16 @@ fn live_end(req: &HttpRequest, body: &String, skipped: bool) -> JsonValue {
         "event_ranking_data": []
     }
 }
+
+pub fn end(req: HttpRequest, body: String) -> Option<JsonValue> {
+    Some(live_end(&req, &body, false))
 }
 
-pub fn end(req: HttpRequest, body: String) -> HttpResponse {
+pub fn skip(req: HttpRequest, body: String) -> Option<JsonValue> {
-    let resp = live_end(&req, &body, false);
+    Some(live_end(&req, &body, true))
-    global::send(resp, req)
 }
 
-pub fn skip(req: HttpRequest, body: String) -> HttpResponse {
+pub fn event_end(req: HttpRequest, body: String) -> Option<JsonValue> {
-    let resp = live_end(&req, &body, true);
-    global::send(resp, req)
-}
-
-pub fn event_end(req: HttpRequest, body: String) -> HttpResponse {
     let mut resp = live_end(&req, &body, false);
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
@@ -637,5 +596,5 @@ pub fn event_end(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc_event(&key, event);
     
-    global::send(resp, req)
+    Some(resp)
 }

src/router/login.rs

@@ -3,18 +3,13 @@ use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::{global, userdata, items, databases};
 
-pub fn dummy(req: HttpRequest, body: String) -> HttpResponse {
+pub fn dummy(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let user = userdata::get_acc(&key);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "user_id": user["user"]["id"].clone()
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
 pub fn get_login_bonus_info(id: i64) -> JsonValue {
@@ -52,7 +47,7 @@ fn do_bonus(user_home: &mut JsonValue, bonuses: &mut JsonValue) -> JsonValue {
     to_send
 }
 
-pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
+pub fn bonus(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let mut user_home = userdata::get_acc_home(&key);
     let mut user_missions = userdata::get_acc_missions(&key);
@@ -72,19 +67,14 @@ pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
     userdata::save_acc_loginbonus(&key, bonuses.clone());
     userdata::save_acc_home(&key, user_home.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "login_bonus_list": to_send,
         "start_time": bonuses["start_time"].clone(),
         "clear_mission_ids": cleared_missions
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn bonus_event(req: HttpRequest, body: String) -> HttpResponse {
+pub fn bonus_event(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let mut user_home = userdata::get_acc_home(&key);
     
@@ -97,14 +87,9 @@ pub fn bonus_event(req: HttpRequest, body: String) -> HttpResponse {
     userdata::save_acc_eventlogin(&key, bonuses.clone());
     userdata::save_acc_home(&key, user_home.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "login_bonus_list": to_send,
         "start_time": bonuses["start_time"].clone(),
         "clear_mission_ids": []
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/lottery.rs

@@ -5,7 +5,7 @@ use rand::Rng;
 use crate::router::{global, userdata, items, databases};
 use crate::encryption;
 
-pub fn tutorial(req: HttpRequest, body: String) -> HttpResponse {
+pub fn tutorial(req: HttpRequest, body: String) -> Option<JsonValue> {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
     let id = body["master_character_id"].to_string();
@@ -20,10 +20,7 @@ pub fn tutorial(req: HttpRequest, body: String) -> HttpResponse {
     }
     lotteryid += user;
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "lottery_list": [
             {
                 "master_lottery_id": lotteryid,
@@ -34,9 +31,7 @@ pub fn tutorial(req: HttpRequest, body: String) -> HttpResponse {
             }
         ],
         "item_list": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
 fn get_card_master_id(lottery_id: String, lottery_number: String) -> Option<i64> {
@@ -98,18 +93,13 @@ fn get_random_cards(id: i64, mut count: usize) -> JsonValue {
     rv
 }
 
-pub fn lottery(req: HttpRequest) -> HttpResponse {
+pub fn lottery(req: HttpRequest) -> Option<JsonValue> {
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "lottery_list": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn lottery_post(req: HttpRequest, body: String) -> HttpResponse {
+pub fn lottery_post(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     println!("lottery: {}", body);
@@ -179,10 +169,7 @@ pub fn lottery_post(req: HttpRequest, body: String) -> HttpResponse {
     userdata::save_acc(&key, user.clone());
     userdata::save_acc_missions(&key, missions);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "lottery_item_list": lottery_list,
         "updated_value_list": {
             "card_list": new_cards,
@@ -191,7 +178,5 @@ pub fn lottery_post(req: HttpRequest, body: String) -> HttpResponse {
         "gift_list": user2["home"]["gift_list"].clone(),
         "clear_mission_ids": cleared_missions,
         "draw_count_list": []
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/mission.rs

@@ -1,24 +1,19 @@
-use json::{array, object};
+use json::{array, object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::{global, userdata, items, databases};
 use crate::encryption;
 
-pub fn mission(req: HttpRequest) -> HttpResponse {
+pub fn mission(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     let missions = userdata::get_acc_missions(&key);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "mission_list": missions
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn clear(req: HttpRequest, body: String) -> HttpResponse {
+pub fn clear(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     
     let mut missions = userdata::get_acc_missions(&key);
@@ -30,17 +25,12 @@ pub fn clear(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc_missions(&key, missions);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "clear_mission_ids": body["master_mission_ids"].clone()
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn receive(req: HttpRequest, body: String) -> HttpResponse {
+pub fn receive(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
@@ -79,10 +69,7 @@ pub fn receive(req: HttpRequest, body: String) -> HttpResponse {
     userdata::save_acc(&key, user.clone());
     userdata::save_acc_missions(&key, missions.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "reward_list": rewards,
         "updated_value_list": {
             "gem": user["gem"].clone(),
@@ -90,7 +77,5 @@ pub fn receive(req: HttpRequest, body: String) -> HttpResponse {
             "point_list": user["point_list"].clone()
         },
         "mission_list": missions
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/notice.rs

@@ -1,26 +1,16 @@
-use json::object;
+use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::global;
 
 //todo
-pub fn reward(req: HttpRequest) -> HttpResponse {
+pub fn reward(req: HttpRequest) -> Option<JsonValue> {
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "reward_list": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn reward_post(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn reward_post(req: HttpRequest, _body: String) -> Option<JsonValue> {
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }

src/router/purchase.rs

@@ -1,13 +1,10 @@
-use json::object;
+use json::{object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::global;
 
-pub fn purchase(req: HttpRequest) -> HttpResponse {
+pub fn purchase(req: HttpRequest) -> Option<JsonValue> {
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "product_list": [//Client will error if this is an empty array
             {
                 "product_id": "com.bushiroad.global.lovelive.sif2.google.promo.4199",
@@ -33,7 +30,5 @@ pub fn purchase(req: HttpRequest) -> HttpResponse {
                 "total_gem": 6000
             }
         ]
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/serial_code.rs

@@ -1,21 +1,16 @@
-use json::{array, object};
+use json::{array, object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::{global, userdata, items};
 use crate::encryption;
 
-pub fn events(req: HttpRequest) -> HttpResponse {
+pub fn events(req: HttpRequest) -> Option<JsonValue> {
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "serial_code_list": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn serial_code(req: HttpRequest, body: String) -> HttpResponse {
+pub fn serial_code(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc_home(&key);
@@ -190,30 +185,20 @@ pub fn serial_code(req: HttpRequest, body: String) -> HttpResponse {
             items::gift_item_basic(15540001, 500, 3, "Okay...............", &mut user),
         ];
     } else {
-        let resp = object!{
+        return Some(object!{
-            "code": 0,
-            "server_time": global::timestamp(),
-            "data": {
             "result_code": 3
-            }
+        });
-        };
-        return global::send(resp, req);
     }
     
     if body["receive_flg"].as_i32().unwrap_or(1) == 1 {
         userdata::save_acc_home(&key, user.clone());
     }
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "serial_code_event": {"id":42,"name":"Serial Code Reward","unique_limit_count":0,"min_user_rank":0,"max_user_rank":0,"end_date":null},
         "reward_list": itemz,
         "result_code": 0,
         "gift_list": user["gift_list"].clone(),
         "excluded_gift_list": []
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/shop.rs

@@ -1,24 +1,19 @@
-use json::object;
+use json::{object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::{userdata, global, items, databases};
 use crate::encryption;
 
-pub fn shop(req: HttpRequest) -> HttpResponse {
+pub fn shop(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     let user = userdata::get_acc(&key);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "shop_list": user["shop_list"].clone()
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn buy(req: HttpRequest, body: String) -> HttpResponse {
+pub fn buy(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -32,17 +27,12 @@ pub fn buy(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "gem": user["gem"].clone(),
         "shop_list": user["shop_list"].clone(),
         "gift_list": user_home["home"]["gift_list"].clone(),
         "updated_value_list": {
             "stamina": user["stamina"].clone()
         }
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/start.rs

@@ -27,20 +27,15 @@ fn get_asset_hash(req: &HttpRequest, body: &JsonValue) -> String {
     hash.to_string()
 }
 
-pub fn asset_hash(req: HttpRequest, body: String) -> HttpResponse {
+pub fn asset_hash(req: HttpRequest, body: String) -> Option<JsonValue> {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "asset_hash": get_asset_hash(&req, &body)
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn start(req: HttpRequest, body: String) -> HttpResponse {
+pub fn start(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -51,13 +46,8 @@ pub fn start(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "asset_hash": get_asset_hash(&req, &body),
         "token": hex::encode("Hello") //what is this?
-        }
+    })
-    };
-    global::send(resp, req)
 }

src/router/story.rs

@@ -1,13 +1,8 @@
-use json::object;
+use json::{object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::global;
 
-pub fn read(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn read(req: HttpRequest, _body: String) -> Option<JsonValue> {
-    let resp = object!{
+    Some(object!{"gift_list":[],"updated_value_list":{"master_chat_room_ids":[3001001,3101001],"master_chat_chapter_ids":[300100101,310100101]},"reward_list":[{"type":16,"value":3001001,"level":0,"amount":1},{"type":16,"value":3101001,"level":0,"amount":1},{"type":17,"value":300100101,"level":0,"amount":1},{"type":17,"value":310100101,"level":0,"amount":1}],"clear_mission_ids":[]})
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {"gift_list":[],"updated_value_list":{"master_chat_room_ids":[3001001,3101001],"master_chat_chapter_ids":[300100101,310100101]},"reward_list":[{"type":16,"value":3001001,"level":0,"amount":1},{"type":16,"value":3101001,"level":0,"amount":1},{"type":17,"value":300100101,"level":0,"amount":1},{"type":17,"value":310100101,"level":0,"amount":1}],"clear_mission_ids":[]}
-    };
-    global::send(resp, req)
 }

src/router/tutorial.rs

@@ -1,10 +1,10 @@
-use json::object;
+use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
 use crate::router::{userdata, global};
 use crate::encryption;
 
-pub fn tutorial(req: HttpRequest, body: String) -> HttpResponse {
+pub fn tutorial(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -15,10 +15,5 @@ pub fn tutorial(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user);
     
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }

src/router/user.rs

@@ -5,7 +5,7 @@ use crate::encryption;
 use crate::router::{userdata, global, items};
 use crate::include_file;
 
-pub fn deck(req: HttpRequest, body: String) -> HttpResponse {
+pub fn deck(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
@@ -28,36 +28,26 @@ pub fn deck(req: HttpRequest, body: String) -> HttpResponse {
     }
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "deck": {
             "slot": body["slot"].clone(),
             "leader_role": 0,
             "main_card_ids": body["main_card_ids"].clone()
         },
         "clear_mission_ids": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn user(req: HttpRequest) -> HttpResponse {
+pub fn user(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     let mut user = userdata::get_acc(&key);
     
     user["lottery_list"] = array![];
     
-    let resp = object!{
+    Some(user)
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": user
-    };
-    global::send(resp, req)
 }
 
-pub fn gift(req: HttpRequest, body: String) -> HttpResponse {
+pub fn gift(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
@@ -100,10 +90,7 @@ pub fn gift(req: HttpRequest, body: String) -> HttpResponse {
     userdata::save_acc(&key, userr.clone());
     let userr = userdata::get_acc(&key);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "failed_gift_ids": failed,
         "updated_value_list": {
             "gem": userr["gem"].clone(),
@@ -112,12 +99,10 @@ pub fn gift(req: HttpRequest, body: String) -> HttpResponse {
         },
         "clear_mission_ids": cleared_missions,
         "reward_list": rewards
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn user_post(req: HttpRequest, body: String) -> HttpResponse {
+pub fn user_post(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
@@ -160,18 +145,13 @@ pub fn user_post(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "user": user["user"].clone(),
         "clear_mission_ids": []
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn announcement(req: HttpRequest) -> HttpResponse {
+pub fn announcement(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     
     let mut user = userdata::get_acc_home(&key);
@@ -180,14 +160,9 @@ pub fn announcement(req: HttpRequest) -> HttpResponse {
     
     userdata::save_acc_home(&key, user);
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         new_announcement_flag: 0
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
 pub fn uid_to_code(uid: String) -> String {
@@ -221,22 +196,17 @@ pub fn code_to_uid(code: String) -> String {
         .replace('M', "0")
 }
 
-pub fn get_migration_code(req: HttpRequest, body: String) -> HttpResponse {
+pub fn get_migration_code(req: HttpRequest, body: String) -> Option<JsonValue> {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
     let code = uid_to_code(body["user_id"].to_string());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "migrationCode": code
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn register_password(req: HttpRequest, body: String) -> HttpResponse {
+pub fn register_password(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
@@ -245,15 +215,10 @@ pub fn register_password(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc_transfer(&code, &body["pass"].to_string());
     
-    let resp = object!{
+    Some(array![])
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": []
-    };
-    global::send(resp, req)
 }
 
-pub fn verify_migration_code(req: HttpRequest, body: String) -> HttpResponse {
+pub fn verify_migration_code(req: HttpRequest, body: String) -> Option<JsonValue> {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
     let uid = code_to_uid(body["migrationCode"].to_string()).parse::<i64>().unwrap_or(0);
@@ -261,29 +226,19 @@ pub fn verify_migration_code(req: HttpRequest, body: String) -> HttpResponse {
     let user = userdata::get_acc_transfer(uid, &body["migrationCode"].to_string(), &body["pass"].to_string());
     
     if !user["success"].as_bool().unwrap() || uid == 0 {
-        let resp = object!{
+        return None;
-            "code": 2,
-            "server_time": global::timestamp(),
-            "message": ""
-        };
-        return global::send(resp, req);
     }
     
     let data_user = userdata::get_acc(&user["login_token"].to_string());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "user_id": uid,
         "uuid": user["login_token"].to_string(),
         "charge": data_user["gem"]["charge"].clone(),
         "free": data_user["gem"]["free"].clone()
+    })
 }
-    };
+pub fn request_migration_code(req: HttpRequest, body: String) -> Option<JsonValue> {
-    global::send(resp, req)
-}
-pub fn request_migration_code(req: HttpRequest, body: String) -> HttpResponse {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
     let uid = code_to_uid(body["migrationCode"].to_string()).parse::<i64>().unwrap_or(0);
@@ -291,37 +246,22 @@ pub fn request_migration_code(req: HttpRequest, body: String) -> HttpResponse {
     let user = userdata::get_acc_transfer(uid, &body["migrationCode"].to_string(), &body["pass"].to_string());
     
     if !user["success"].as_bool().unwrap() || uid == 0 {
-        let resp = object!{
+        return None;
-            "code": 2,
-            "server_time": global::timestamp(),
-            "message": ""
-        };
-        return global::send(resp, req);
     }
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "twxuid": user["login_token"].to_string()
+    })
 }
-    };
+pub fn migration(req: HttpRequest, body: String) -> Option<JsonValue> {
-    global::send(resp, req)
-}
-pub fn migration(req: HttpRequest, body: String) -> HttpResponse {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
     let user = userdata::get_name_and_rank(body["user_id"].to_string().parse::<i64>().unwrap());
     
-    let resp = object!{
+    Some(user)
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": user
-    };
-    global::send(resp, req)
 }
 
-pub fn detail(req: HttpRequest, body: String) -> HttpResponse {
+pub fn detail(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let friends = userdata::get_acc_friends(&key);
@@ -332,17 +272,12 @@ pub fn detail(req: HttpRequest, body: String) -> HttpResponse {
         let user = global::get_user(uid, &friends, true);
         user_detail_list.push(user).unwrap();
     }
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         user_detail_list: user_detail_list
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn sif(req: HttpRequest) -> HttpResponse {
+pub fn sif(req: HttpRequest) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), "");
     let user = userdata::get_acc(&key);
     let mut cards = userdata::get_acc_sif(&key);
@@ -352,46 +287,32 @@ pub fn sif(req: HttpRequest) -> HttpResponse {
         cards = json::parse(&include_file!("src/router/userdata/full_sif.json")).unwrap();
     }
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         cards: cards
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn sifas_migrate(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn sifas_migrate(req: HttpRequest, _body: String) -> Option<JsonValue> {
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "ss_migrate_status": 1,
         "user": null,
         "gift_list": null,
         "lock_remain_time": null
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn sif_migrate(req: HttpRequest, body: String) -> HttpResponse {
+pub fn sif_migrate(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let mut user = userdata::get_acc(&key);
     user["user"]["sif_user_id"] = 111111111.into();
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "sif_migrate_status": 0,
         "user": user["user"].clone(),
         "master_title_ids": user["master_title_ids"].clone()
-        }
+    })
-    };
     
     
     /*
@@ -404,23 +325,17 @@ pub fn sif_migrate(req: HttpRequest, body: String) -> HttpResponse {
         }
     };
     */
-    global::send(resp, req)
 }
 
-pub fn getregisteredplatformlist(req: HttpRequest, _body: String) -> HttpResponse {
+pub fn getregisteredplatformlist(req: HttpRequest, _body: String) -> Option<JsonValue> {
-    let resp = object!{
+    Some(object!{
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": {
         "google": 0,
         "apple": 0,
         "twitter": 0
-        }
+    })
-    };
-    global::send(resp, req)
 }
 
-pub fn initialize(req: HttpRequest, body: String) -> HttpResponse {
+pub fn initialize(req: HttpRequest, body: String) -> Option<JsonValue> {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
@@ -460,7 +375,7 @@ pub fn initialize(req: HttpRequest, body: String) -> HttpResponse {
         cardstoreward = array![40010001, 40020001, 40030001, 40040001, 40050001, 40060001, 40070001, 40080001, 40090001]; //liella
         masterid += 9 + 9 + 12; //nijigasaki
     } else {
-        return global::error_resp(req);
+        return None;
     }
     masterid += userr;
     
@@ -482,10 +397,5 @@ pub fn initialize(req: HttpRequest, body: String) -> HttpResponse {
     userdata::save_acc_home(&key, user2);
     userdata::save_acc_missions(&key, missions);
     
-    let resp = object!{
+    Some(user["user"].clone())
-        "code": 0,
-        "server_time": global::timestamp(),
-        "data": user["user"].clone()
-    };
-    global::send(resp, req)
 }