implement tutorial endpoint

src/main.rs

@@ -24,6 +24,12 @@ async fn user(req: HttpRequest) -> HttpResponse { router::user::user(req) }
 #[get("/api/purchase")]
 async fn purchase(req: HttpRequest) -> HttpResponse { router::purchase::purchase(req) }
 
+#[post("/api/tutorial")]
+async fn tutorial(req: HttpRequest, body: String) -> HttpResponse { router::tutorial::tutorial(req, body) }
+
+#[get("/api/mission")]
+async fn mission(req: HttpRequest) -> HttpResponse { router::mission::mission(req) }
+
 async fn log_unknown_request(req: HttpRequest) -> HttpResponse {
     println!("Unhandled request: {}", req.path());
     HttpResponse::Ok().body("ok")
@@ -40,6 +46,8 @@ async fn main() -> std::io::Result<()> {
         })
         .service(purchase)
         .service(start_start)
+        .service(tutorial)
+        .service(mission)
         .service(start_assethash)
         .service(user)
         .service(dummy_login)

src/router.rs

@@ -4,3 +4,5 @@ pub mod login;
 pub mod userdata;
 pub mod user;
 pub mod purchase;
+pub mod tutorial;
+pub mod mission;

src/router/mission.rs

@@ -0,0 +1,21 @@
+use json;
+use json::object;
+use crate::router::global;
+use actix_web::{HttpResponse, HttpRequest, http::header::HeaderValue};
+use crate::router::userdata;
+
+pub fn mission(req: HttpRequest) -> HttpResponse {
+    let blank_header = HeaderValue::from_static("");
+    let key = req.headers().get("a6573cbe").unwrap_or(&blank_header).to_str().unwrap_or("");
+    let uid = req.headers().get("aoharu-user-id").unwrap_or(&blank_header).to_str().unwrap_or("");
+    let user = userdata::get_acc(key, uid);
+    
+    let resp = object!{
+        "code": 0,
+        "server_time": global::timestamp(),
+        "data": {
+            "mission_list": user["live_mission_list"].clone()
+        }
+    };
+    global::send(resp)
+}

src/router/tutorial.rs

@@ -0,0 +1,25 @@
+use json;
+use json::object;
+use crate::router::global;
+use crate::encryption;
+use actix_web::{HttpResponse, HttpRequest, http::header::HeaderValue};
+use crate::router::userdata;
+
+pub fn tutorial(req: HttpRequest, body: String) -> HttpResponse {
+    let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+    let blank_header = HeaderValue::from_static("");
+    let key = req.headers().get("a6573cbe").unwrap_or(&blank_header).to_str().unwrap_or("");
+    let uid = req.headers().get("aoharu-user-id").unwrap_or(&blank_header).to_str().unwrap_or("");
+    let mut user = userdata::get_acc(key, uid);
+    
+    user["tutorial_step"] = body["step"].clone();
+    
+    userdata::save_acc(key, uid, user);
+    
+    let resp = object!{
+        "code": 0,
+        "server_time": global::timestamp(),
+        "data": []
+    };
+    global::send(resp)
+}

src/router/userdata/mod.rs

@@ -1,7 +1,7 @@
 use rusqlite::{Connection, params};
 use std::sync::{Mutex, MutexGuard};
 use lazy_static::lazy_static;
-use json::{JsonValue, array};
+use json::{JsonValue, array, object};
 //use base64::{Engine as _, engine::general_purpose};
 
 lazy_static! {
@@ -75,8 +75,10 @@ fn create_acc(conn: &Connection, uid: i64) {
         )", key),
         (),
     ).unwrap();
-    let mut data = json::parse(include_str!("new_user.json")).unwrap();
-    data["user"]["id"] = uid.into();
+    let mut data = object!{
+        userdata: json::parse(include_str!("new_user.json")).unwrap()
+    };
+    data["userdata"]["user"]["id"] = uid.into();
     
     init_data(conn, &format!("_{}_", key), data);
 }
@@ -117,7 +119,7 @@ pub fn get_acc(_a6573cbe: &str, uid: &str) -> JsonValue {
                 
                 let rv = json::parse(&result.unwrap()).unwrap();
                 
-                return rv;
+                return rv["userdata"].clone();
             }
             Err(_) => {
                 std::thread::sleep(std::time::Duration::from_millis(15));
@@ -156,7 +158,13 @@ pub fn save_acc(_a6573cbe: &str, uid: &str, data: JsonValue) {
                 if !acc_exists(conn, key) {
                     create_acc(conn, key);
                 }
-                store_data(conn, &format!("_{}_", key), data);
+                let mut stmt = conn.prepare(&format!("SELECT jsondata FROM _{}_", key)).unwrap();
+                let result: Result<String, rusqlite::Error> = stmt.query_row([], |row| row.get(0));
+                
+                let mut rv = json::parse(&result.unwrap()).unwrap();
+                
+                rv["userdata"] = data;
+                store_data(conn, &format!("_{}_", key), rv);
                 break;
             }
             Err(_) => {

src/router/userdata/new_user.json

@@ -10,7 +10,7 @@
         "guest_smile_master_card_id": 0,
         "guest_cool_master_card_id": 0,
         "guest_pure_master_card_id": 0,
-        "friend_request_disabled" :1,
+        "friend_request_disabled": 1,
         "master_title_ids": [0,0],
         "profile_settings": [1,2,3,4,5,6,7],
         "sif_user_id": 0,