Implement daily missions

src/main.rs

@@ -75,6 +75,7 @@ async fn request(req: HttpRequest, body: String) -> HttpResponse {
             "/api/live/retire" => router::live::retire(req, body),
             "/api/live/continue" => router::live::continuee(req, body),
             "/api/mission/clear" => router::mission::clear(req, body),
+            "/api/mission/receive" => router::mission::receive(req, body),
             "/api/home/preset" => router::home::preset(req, body),
             "/api/lottery/get_tutorial" => router::lottery::tutorial(req, body),
             "/api/lottery" => router::lottery::lottery_post(req, body),
@@ -116,7 +117,6 @@ async fn request(req: HttpRequest, body: String) -> HttpResponse {
             "/api/friend/ids" => router::friend::ids(req),
             "/api/live/clearRate" => router::clear_rate::clearrate(req),
             "/api/mission" => router::mission::mission(req),
-            "/api/mission/receive" => router::mission::receive(req, body),
             "/api/home" => router::home::home(req),
             "/api/home/preset" => router::home::preset_get(req),
             "/api/lottery" => router::lottery::lottery(req),

src/router/global.rs

@@ -12,7 +12,7 @@ use crate::encryption;
 use crate::router::{userdata, gree};
 
 pub const ASSET_VERSION:          &str = "cb87bc1468c8631a262ff65b2960470b";
-pub const ASSET_HASH_ANDROID:     &str = "4715e873031ae4abc3c625e2bd8c935b";
+pub const ASSET_HASH_ANDROID:     &str = "8d1a9a5ce285c76b5afa2b5bdf154b9d";
 pub const ASSET_HASH_IOS:         &str = "466d4616d14a8d8a842de06426e084c2";
 
 pub const ASSET_VERSION_JP:       &str = "4c921d2443335e574a82e04ec9ea243c";

src/router/home.rs

@@ -1,8 +1,7 @@
 use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
-use crate::router::userdata;
+use crate::router::{global, userdata, items};
-use crate::router::global;
 use crate::encryption;
 
 pub fn preset(req: HttpRequest, body: String) -> HttpResponse {
@@ -73,8 +72,15 @@ pub fn home(req: HttpRequest) -> HttpResponse {
     let mut user = userdata::get_acc_home(&key);
     
     check_gifts(&mut user);
+    
     userdata::save_acc_home(&key, user.clone());
     
+    let mut user_missions = userdata::get_acc_missions(&key);
+    user["clear_mission_ids"] = items::completed_daily_mission(1253003, &mut user_missions);
+    if !user["clear_mission_ids"].is_empty() {
+        userdata::save_acc_missions(&key, user_missions);
+    }
+    
     let resp = object!{
         "code": 0,
         "server_time": global::timestamp(),

src/router/items.rs

@@ -1,4 +1,4 @@
-use json::{object, JsonValue};
+use json::{array, object, JsonValue};
 use lazy_static::lazy_static;
 use rand::Rng;
 
@@ -271,3 +271,74 @@ pub fn give_exp(amount: i32, user: &mut JsonValue) {
         user["stamina"]["last_updated_time"] = global::timestamp().into();
     }
 }
+
+pub fn update_mission_status(master_mission_id: i64, expire: u64, completed: bool, claimed: bool, advance: bool, missions: &mut JsonValue) -> Option<i64> {
+    for (_i, mission) in missions.members_mut().enumerate() {
+        if mission["master_mission_id"].as_i64().unwrap() == master_mission_id {
+            mission["status"] = if claimed { 3 } else if completed { 2 } else { 1 }.into();
+            if expire != 0 {
+                mission["expire_date_time"] = expire.into();
+            }
+            
+            if mission["expire_date_time"].as_u64().unwrap() < global::timestamp() || expire != 0 {
+                mission["progress"] = 0.into();
+            }
+            if advance {
+                mission["progress"] = (mission["progress"].as_i32().unwrap() + 1).into();
+            }
+            
+            
+            if completed && !claimed {
+                return Some(master_mission_id);
+            }
+            return None;
+        }
+    }
+    None
+}
+
+pub fn update_mission_status_multi(master_mission_id: JsonValue, expire: u64, completed: bool, claimed: bool, advance: bool, missions: &mut JsonValue) -> JsonValue {
+    let mut rv = array![];
+    for (_i, mission) in master_mission_id.members().enumerate() {
+        let val = update_mission_status(mission.as_i64().unwrap(), expire, completed, claimed, advance, missions);
+        if !val.is_none() {
+            rv.push(val.unwrap()).unwrap();
+        }
+    }
+    rv
+}
+
+pub fn completed_daily_mission(id: i64, missions: &mut JsonValue) -> JsonValue {
+    let all_daily_missions = array![1224003, 1253003, 1273009, 1273010, 1273011, 1273012];
+    for (_i, mission) in missions.members().enumerate() {
+        if mission["master_mission_id"].as_i64().unwrap() == id {
+            if mission["expire_date_time"].as_u64().unwrap() >= global::timestamp() && mission["status"].as_i32().unwrap() > 1 {
+                return array![];
+            }
+        }
+    }
+    let mut rv = array![];
+    for (_i, mission) in missions.clone().members().enumerate() {
+        if mission["master_mission_id"].as_i64().unwrap() == 1224003 {
+            let next_reset = global::timestamp_since_midnight() + (24 * 60 * 60);
+            if mission["expire_date_time"].as_u64().unwrap() < global::timestamp() {
+                update_mission_status_multi(all_daily_missions, next_reset, false, false, false, missions);
+            }
+            
+            if mission["progress"].as_i32().unwrap() == 4 {
+                if !update_mission_status(1224003, 0, true, false, true, missions).is_none() {
+                    rv.push(1224003).unwrap();
+                }
+            } else {
+                if !update_mission_status(1224003, 0, false, false, true, missions).is_none() {
+                    rv.push(1224003).unwrap();
+                }
+            }
+            if !update_mission_status(id, next_reset, true, false, true, missions).is_none() {
+                rv.push(id).unwrap();
+            }
+            return rv;
+        }
+    }
+    rv
+}

src/router/live.rs

@@ -396,8 +396,19 @@ fn live_end(req: &HttpRequest, body: &String) -> JsonValue {
     let body = json::parse(&encryption::decrypt_packet(body).unwrap()).unwrap();
     let user2 = userdata::get_acc_home(&key);
     let mut user = userdata::get_acc(&key);
+    let mut user_missions = userdata::get_acc_missions(&key);
     let live = update_live_data(&mut user, &body, true);
     
+    //1273009, 1273010, 1273011, 1273012
+    let mut cleared_missions = array![];
+    if body["master_live_id"].to_string().len() > 1 {
+        let id = body["master_live_id"].to_string().split("").collect::<Vec<_>>()[2].parse::<i64>().unwrap_or(0);
+        if id <= 4 && id >= 1 {
+            cleared_missions = items::completed_daily_mission(1273009 + id - 1, &mut user_missions);
+        }
+    }
+    
+    
     if body["live_score"]["score"].as_i64().unwrap() > 0 {
         live_completed(body["master_live_id"].as_i64().unwrap(), body["level"].as_i32().unwrap(), false, body["live_score"]["score"].as_i64().unwrap(), user["user"]["id"].as_i64().unwrap());
     }
@@ -418,6 +429,7 @@ fn live_end(req: &HttpRequest, body: &String) -> JsonValue {
     items::give_exp(body["use_lp"].as_i32().unwrap(), &mut user);
     
     userdata::save_acc(&key, user.clone());
+    userdata::save_acc_missions(&key, user_missions.clone());
     
     object!{
         "code": 0,
@@ -434,7 +446,7 @@ fn live_end(req: &HttpRequest, body: &String) -> JsonValue {
             "character_list": user["character_list"].clone(),
             "reward_list": reward_list,
             "gift_list": user2["home"]["gift_list"].clone(),
-            "clear_mission_ids": user2["clear_mission_ids"].clone(),
+            "clear_mission_ids": cleared_missions,
             "event_point_reward_list": [],
             "ranking_change": [],
             "event_member": [],
@@ -543,7 +555,7 @@ pub fn skip(req: HttpRequest, body: String) -> HttpResponse {
             "character_list": user["character_list"].clone(),
             "reward_list": reward_list,
             "gift_list": user2["home"]["gift_list"].clone(),
-            "clear_mission_ids": user2["clear_mission_ids"].clone(),
+            "clear_mission_ids": [],
             "event_point_reward_list": [],
             "ranking_change": [],
             "event_member": [],

src/router/login.rs

@@ -84,8 +84,8 @@ fn do_bonus(user_home: &mut JsonValue, bonuses: &mut JsonValue) -> JsonValue {
 
 pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
     let key = global::get_login(req.headers(), &body);
-    let user = userdata::get_acc(&key);
     let mut user_home = userdata::get_acc_home(&key);
+    let mut user_missions = userdata::get_acc_missions(&key);
     
     let mut bonuses = userdata::get_acc_loginbonus(&key);
     if bonuses["bonus_list"].is_empty() {
@@ -93,8 +93,14 @@ pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
     }
     let to_send = do_bonus(&mut user_home, &mut bonuses);
     
+    let mut cleared_missions = array![];
+    if !to_send.is_empty() {
+        cleared_missions = items::completed_daily_mission(1253003, &mut user_missions);
+        userdata::save_acc_missions(&key, user_missions);
+    }
+    
     userdata::save_acc_loginbonus(&key, bonuses.clone());
-    userdata::save_acc_home(&key, user_home);
+    userdata::save_acc_home(&key, user_home.clone());
     
     let resp = object!{
         "code": 0,
@@ -102,7 +108,7 @@ pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
         "data": {
             "login_bonus_list": to_send,
             "start_time": bonuses["start_time"].clone(),
-            "clear_mission_ids": user["clear_mission_ids"].clone()
+            "clear_mission_ids": cleared_missions
         }
     };
     global::send(resp, req)
@@ -110,7 +116,6 @@ pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
 
 pub fn bonus_event(req: HttpRequest, body: String) -> HttpResponse {
     let key = global::get_login(req.headers(), &body);
-    let user = userdata::get_acc(&key);
     let mut user_home = userdata::get_acc_home(&key);
     
     let mut bonuses = userdata::get_acc_eventlogin(&key);
@@ -120,7 +125,7 @@ pub fn bonus_event(req: HttpRequest, body: String) -> HttpResponse {
     let to_send = do_bonus(&mut user_home, &mut bonuses);
     
     userdata::save_acc_eventlogin(&key, bonuses.clone());
-    userdata::save_acc_home(&key, user_home);
+    userdata::save_acc_home(&key, user_home.clone());
     
     let resp = object!{
         "code": 0,
@@ -128,7 +133,7 @@ pub fn bonus_event(req: HttpRequest, body: String) -> HttpResponse {
         "data": {
             "login_bonus_list": to_send,
             "start_time": bonuses["start_time"].clone(),
-            "clear_mission_ids": user["clear_mission_ids"].clone()
+            "clear_mission_ids": []
         }
     };
     global::send(resp, req)

src/router/lottery/mod.rs

@@ -239,7 +239,7 @@ pub fn lottery_post(req: HttpRequest, body: String) -> HttpResponse {
                 "item_list": user["item_list"].clone()
             },
             "gift_list": user2["home"]["gift_list"].clone(),
-            "clear_mission_ids": user2["clear_mission_ids"].clone(),
+            "clear_mission_ids": [],
             "draw_count_list": []
         }
     };

src/router/mission.rs

@@ -1,8 +1,10 @@
-use json::object;
+use json::{array, object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
+use lazy_static::lazy_static;
 
 use crate::router::{global, userdata};
 use crate::encryption;
+use crate::router::items;
 
 pub fn mission(req: HttpRequest) -> HttpResponse {
     let key = global::get_login(req.headers(), "");
@@ -45,18 +47,58 @@ pub fn clear(req: HttpRequest, body: String) -> HttpResponse {
     global::send(resp, req)
 }
 
-pub fn receive(req: HttpRequest, _body: String) -> HttpResponse {
+lazy_static! {
-    //let key = global::get_login(req.headers(), &body);
+    static ref MISSION_LIST: JsonValue = {
-    //let missions = userdata::get_acc_missions(&key);
+        let mut info = object!{};
-    //let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+        let items = json::parse(include_str!("json/mission.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+    static ref MISSION_REWARD: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/mission_reward.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+}
 
-    //todo - give user rewards based off of cleared missions
+pub fn receive(req: HttpRequest, body: String) -> HttpResponse {
+    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);
+    let mut user = userdata::get_acc(&key);
+    let mut rewards = array![];
+    
+    for (_i, mission) in body["master_mission_ids"].members().enumerate() {
+        items::update_mission_status(mission.as_i64().unwrap(), 0, true, true, false, &mut missions);
+        let mission_info = MISSION_LIST[mission.to_string()].clone();
+        let mut gift = MISSION_REWARD[mission_info["masterMissionRewardId"].to_string()].clone();
+        gift["reward_type"] = gift["type"].clone();
+        gift["amount"] = gift["amount"].as_i64().unwrap().into();
+        items::give_gift(&gift, &mut user);
+        rewards.push(gift).unwrap();
+    }
+    
+    userdata::save_acc(&key, user.clone());
+    userdata::save_acc_missions(&key, missions.clone());
     
     let resp = object!{
         "code": 0,
         "server_time": global::timestamp(),
         "data": {
-            "reward_list": []
+            "reward_list": rewards,
+            "updated_value_list": {
+                "gem": user["gem"].clone(),
+                "item_list": user["item_list"].clone(),
+                "point_list": user["point_list"].clone()
+            },
+            "mission_list": missions
+            
         }
     };
     global::send(resp, req)

src/router/user.rs

@@ -98,7 +98,7 @@ pub fn gift(req: HttpRequest, body: String) -> HttpResponse {
         }
     }
     
-    userdata::save_acc_home(&key, user.clone());
+    userdata::save_acc_home(&key, user);
     userdata::save_acc(&key, userr.clone());
     let userr = userdata::get_acc(&key);
     
@@ -112,7 +112,7 @@ pub fn gift(req: HttpRequest, body: String) -> HttpResponse {
                 "item_list": userr["item_list"].clone(),
                 "point_list": userr["point_list"].clone()
             },
-            "clear_mission_ids": user["clear_mission_ids"].clone(),
+            "clear_mission_ids": [],
             "reward_list": rewards
         }
     };
@@ -124,7 +124,6 @@ pub fn user_post(req: HttpRequest, body: String) -> HttpResponse {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
     let mut user = userdata::get_acc(&key);
-    let user_2 = userdata::get_acc_home(&key);
     
     if !body["name"].is_null() {
         user["user"]["name"] = body["name"].clone();
@@ -168,7 +167,7 @@ pub fn user_post(req: HttpRequest, body: String) -> HttpResponse {
         "server_time": global::timestamp(),
         "data": {
             "user": user["user"].clone(),
-            "clear_mission_ids": user_2["clear_mission_ids"].clone()
+            "clear_mission_ids": []
         }
     };
     global::send(resp, req)

src/router/userdata/mod.rs

@@ -73,24 +73,32 @@ fn generate_uid() -> i64 {
     random_number
 }
 
+fn add_user_to_database(uid: i64, user: JsonValue, user_home: JsonValue, user_missions: JsonValue, sif_cards: JsonValue) {
+    let home = json::stringify(user_home.clone());
+    let missions = json::stringify(user_missions.clone());
+    let cards = json::stringify(sif_cards.clone());
+    
+    DATABASE.lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled, event, eventloginbonus, server_data) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)", params!(
+        uid,
+        json::stringify(user.clone()),
+        if user_home.is_empty() {include_str!("new_user_home.json")} else {&home},
+        if user_missions.is_empty() {include_str!("missions.json")} else {&missions},
+        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp()),
+        if sif_cards.is_empty() {"[]"} else {&cards},
+        r#"{"friend_user_id_list":[],"request_user_id_list":[],"pending_user_id_list":[]}"#,
+        user["user"]["friend_request_disabled"].as_i32().unwrap(),
+        include_str!("new_user_event.json"),
+        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp()),
+        format!(r#"{{"server_time_set":{},"server_time":1709272800}}"#, global::timestamp())
+    ));
+}
+
 fn create_acc(uid: i64, login: &str) {
     let mut new_user = NEW_USER.clone();
     new_user["user"]["id"] = uid.into();
     new_user["stamina"]["last_updated_time"] = global::timestamp().into();
     
-    DATABASE.lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled, event, eventloginbonus, server_data) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)", params!(
+    add_user_to_database(uid, new_user, JsonValue::Null, JsonValue::Null, JsonValue::Null);
-        uid,
-        json::stringify(new_user),
-        include_str!("new_user_home.json"),
-        include_str!("chat_missions.json"),
-        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp()),
-        "[]",
-        r#"{"friend_user_id_list":[],"request_user_id_list":[],"pending_user_id_list":[]}"#,
-        0,
-        include_str!("new_user_event.json"),
-        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp()),
-        format!(r#"{{"server_time_set":{},"server_time":1709272800}}"#, global::timestamp())
-    ));
     
     DATABASE.lock_and_exec("DELETE FROM tokens WHERE token=?1", params!(login));
     DATABASE.lock_and_exec("INSERT INTO tokens (user_id, token) VALUES (?1, ?2)", params!(uid, login));
@@ -430,31 +438,12 @@ pub fn webui_login(uid: i64, password: &str) -> Result<String, String> {
 }
 
 pub fn webui_import_user(user: JsonValue) -> Result<JsonValue, String> {
-    let mut user = user;
     let uid = user["userdata"]["user"]["id"].as_i64().unwrap();
     if acc_exists(uid) {
         return Err(String::from("User already exists"));
     }
-    if user["missions"].is_empty() {
-        user["missions"] = json::parse(include_str!("chat_missions.json")).unwrap();
-    }
-    if user["sif_cards"].is_empty() {
-        user["sif_cards"] = array![];
-    }
     
-    DATABASE.lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled, event, eventloginbonus, server_data) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)", params!(
+    add_user_to_database(uid, user["userdata"].clone(), user["home"].clone(), user["missions"].clone(), user["sif_cards"].clone());
-        uid,
-        json::stringify(user["userdata"].clone()),
-        json::stringify(user["home"].clone()),
-        json::stringify(user["missions"].clone()),
-        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp()),
-        json::stringify(user["sif_cards"].clone()),
-        r#"{"friend_user_id_list":[],"request_user_id_list":[],"pending_user_id_list":[]}"#,
-        user["userdata"]["user"]["friend_request_disabled"].as_i32().unwrap(),
-        include_str!("new_user_event.json"),
-        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp()),
-        format!(r#"{{"server_time_set":{},"server_time":1709272800}}"#, global::timestamp())
-    ));
     
     let token = global::create_token();