Organize databases

src/router.rs

@@ -24,3 +24,4 @@ pub mod webui;
 pub mod clear_rate;
 pub mod exchange;
 pub mod items;
+pub mod databases;

src/router/card.rs

@@ -1,7 +1,7 @@
 use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 
-use crate::router::{userdata, global, items};
+use crate::router::{userdata, global, items, databases};
 use crate::encryption;
 
 fn do_reinforce(user: &mut JsonValue, body: &JsonValue, exp_id: &str, money_multiplier: i64, evolve: bool) -> JsonValue {
@@ -13,7 +13,7 @@ fn do_reinforce(user: &mut JsonValue, body: &JsonValue, exp_id: &str, money_mult
             
             for (_j, data2) in materials.members().enumerate() {
                 items::use_item(data2["master_item_id"].as_i64().unwrap(), data2["amount"].as_i64().unwrap(), user);
-                let item = items::get_item_info(data2["master_item_id"].as_i64().unwrap());
+                let item = &databases::ITEM_INFO[data2["master_item_id"].to_string()];
                 if evolve {
                     card["evolve"] = array![{type: 2,count: 1}];
                     money = money_multiplier;

src/router/chat.rs

@@ -1,41 +1,14 @@
 use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
-use lazy_static::lazy_static;
 
-use crate::router::{global, items, userdata};
+use crate::router::{global, items, userdata, databases};
 use crate::encryption;
 
-lazy_static! {
-    static ref CHATS: JsonValue = {
-        let mut chats = object!{};
-        let items = json::parse(include_str!("json/chat_room.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            if chats[data["masterChatId"].to_string()].is_null() {
-                chats[data["masterChatId"].to_string()] = object!{};
-            }
-            chats[data["masterChatId"].to_string()][data["roomId"].to_string()] = data.clone();
-        }
-        chats
-    };
-    static ref CHAPTERS: JsonValue = {
-        let mut chats = object!{};
-        let items = json::parse(include_str!("json/chat_chapter.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            if chats[data["masterChatId"].to_string()].is_null() {
-                chats[data["masterChatId"].to_string()] = object!{};
-            }
-            chats[data["masterChatId"].to_string()][data["roomId"].to_string()] = data.clone();
-        }
-        chats
-    };
-}
-
-
 pub fn add_chat(id: i64, num: i64, chats: &mut JsonValue) {
     chats.push(object!{
         chat_id: id,
         room_id: num,
-        chapter_id: CHAPTERS[id.to_string()][num.to_string()]["id"].clone(),
+        chapter_id: databases::CHAPTERS[id.to_string()][num.to_string()]["id"].clone(),
         is_read: 0,
         created_at: global::timestamp()
     }).unwrap();
@@ -47,7 +20,7 @@ pub fn home(req: HttpRequest, body: String) -> HttpResponse {
     
     let mut rooms = array![];
     for (_i, data) in chats.members().enumerate() {
-        rooms.push(CHATS[data["chat_id"].to_string()][data["room_id"].to_string()]["id"].clone()).unwrap();
+        rooms.push(databases::CHATS[data["chat_id"].to_string()][data["room_id"].to_string()]["id"].clone()).unwrap();
     }
     
     let resp = object!{

src/router/clear_rate.rs

@@ -7,10 +7,11 @@ use lazy_static::lazy_static;
 
 use crate::encryption;
 use crate::sql::SQLite;
-use crate::router::global;
+use crate::router::{global, databases};
 
 lazy_static! {
     static ref DATABASE: SQLite = SQLite::new("live_statistics.db", setup_tables);
+    static ref CACHED_DATA: Mutex<Option<JsonValue>> = Mutex::new(None);
 }
 
 pub struct Live {
@@ -127,21 +128,6 @@ pub fn live_completed(id: i64, level: i32, failed: bool, score: i64, uid: i64) {
     };
 }
 
-lazy_static! {
-    static ref CACHED_DATA: Mutex<Option<JsonValue>> = Mutex::new(None);
-    static ref LIVE_LIST: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/live.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data["masterMusicId"].clone();
-        }
-        info
-    };
-}
-pub fn get_live_id(id: i64) -> i64 {
-    LIVE_LIST[id.to_string()].as_i64().unwrap()
-}
-
 fn get_pass_percent(failed: i64, pass: i64) -> String {
     let total = (failed + pass) as f64;
     if failed + pass == 0 {
@@ -168,7 +154,7 @@ fn get_json() -> JsonValue {
             expert: get_pass_percent(info.expert_failed, info.expert_pass),
             master: get_pass_percent(info.master_failed, info.master_pass)
         };
-        ids.push(get_live_id(info.live_id.into())).unwrap();
+        ids.push(databases::LIVE_LIST[info.live_id.to_string()]["masterMusicId"].as_i64().unwrap()).unwrap();
         rates.push(to_push).unwrap();
     }
     object!{

src/router/databases/mod.rs

@@ -0,0 +1,194 @@
+use json::{array, object, JsonValue};
+use lazy_static::lazy_static;
+
+lazy_static! {
+    pub static ref LOGIN_REWARDS: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/login_bonus_reward.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+    pub static ref SHOP_INFO: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/shop_item.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+    pub static ref CHATS: JsonValue = {
+        let mut chats = object!{};
+        let items = json::parse(include_str!("json/chat_room.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            if chats[data["masterChatId"].to_string()].is_null() {
+                chats[data["masterChatId"].to_string()] = object!{};
+            }
+            chats[data["masterChatId"].to_string()][data["roomId"].to_string()] = data.clone();
+        }
+        chats
+    };
+    pub static ref CHAPTERS: JsonValue = {
+        let mut chats = object!{};
+        let items = json::parse(include_str!("json/chat_chapter.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            if chats[data["masterChatId"].to_string()].is_null() {
+                chats[data["masterChatId"].to_string()] = object!{};
+            }
+            chats[data["masterChatId"].to_string()][data["roomId"].to_string()] = data.clone();
+        }
+        chats
+    };
+    pub static ref EXCHANGE_LIST: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/exchange_item.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+    pub static ref EXCHANGE_REWARD: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/exchange_item_reward.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+    pub static ref LIVE_LIST: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/live.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+    pub static ref MISSION_DATA: JsonValue = {
+        json::parse(include_str!("json/live_mission.json")).unwrap()
+    };
+    pub static ref MISSION_COMBO_DATA: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/live_mission_combo.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["masterMusicId"].to_string()] = data.clone();
+        }
+        info
+    };
+    pub static ref MISSION_REWARD_DATA: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/live_mission_reward.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+    pub static ref CARD_LIST: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/card.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+    pub static ref LOTTERY_INFO: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/login_bonus.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            if info[data["id"].to_string()].is_null() {
+                info[data["id"].to_string()] = object!{
+                    info: data.clone(),
+                    days: []
+                };
+            }
+        }
+        let days = json::parse(include_str!("json/login_bonus_reward_setting.json")).unwrap();
+        for (_i, data) in days.members().enumerate() {
+            if info[data["masterLoginBonusId"].to_string()].is_null() {
+                continue;
+            }
+            info[data["masterLoginBonusId"].to_string()]["days"].push(data.clone()).unwrap();
+        }
+        let mut real_info = object!{};
+        for (_i, data) in info.entries().enumerate() {
+            real_info[data.1["info"]["id"].to_string()] = data.1.clone();
+        }
+        real_info
+    };
+    pub static ref CARDS: JsonValue = {
+        let mut cardz = object!{};
+        let items = json::parse(include_str!("json/lottery_item.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            if cardz[data["id"].to_string()].is_null() {
+                cardz[data["id"].to_string()] = object!{};
+            }
+            cardz[data["id"].to_string()][data["number"].to_string()] = data.clone();
+        }
+        cardz
+    };
+    pub static ref POOL: JsonValue = {
+        let mut cardz = object!{};
+        let items = json::parse(include_str!("json/lottery_item.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            if cardz[data["id"].to_string()].is_null() {
+                cardz[data["id"].to_string()] = array![];
+            }
+            cardz[data["id"].to_string()].push(data["number"].clone()).unwrap();
+        }
+        cardz
+    };
+    pub static ref RARITY: JsonValue = {
+        let mut cardz = object!{};
+        let items = json::parse(include_str!("json/lottery_rarity.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            if cardz[data["id"].to_string()].is_null() {
+                cardz[data["id"].to_string()] = array![];
+            }
+            cardz[data["id"].to_string()].push(data.clone()).unwrap();
+        }
+        cardz
+    };
+    pub static ref LOTTERY: JsonValue = {
+        let mut cardz = object!{};
+        let items = json::parse(include_str!("json/lottery.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            cardz[data["id"].to_string()] = data.clone();
+        }
+        cardz
+    };
+    pub static ref PRICE: JsonValue = {
+        let mut cardz = object!{};
+        let items = json::parse(include_str!("json/lottery_price.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            if cardz[data["id"].to_string()].is_null() {
+                cardz[data["id"].to_string()] = object!{};
+            }
+            cardz[data["id"].to_string()][data["number"].to_string()] = data.clone();
+        }
+        cardz
+    };
+    pub static ref MISSION_LIST: JsonValue = {
+        let mut info = object!{};
+        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
+    };
+    pub 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
+    };
+    pub static ref ITEM_INFO: JsonValue = {
+        let mut info = object!{};
+        let items = json::parse(include_str!("json/item.json")).unwrap();
+        for (_i, data) in items.members().enumerate() {
+            info[data["id"].to_string()] = data.clone();
+        }
+        info
+    };
+}

src/router/exchange.rs

@@ -1,29 +1,9 @@
-use json::{JsonValue, object, array};
+use json::{object, array};
 use actix_web::{HttpResponse, HttpRequest};
-use lazy_static::lazy_static;
 
-use crate::router::{global, userdata, items};
+use crate::router::{global, userdata, items, databases};
 use crate::encryption;
 
-lazy_static! {
-    static ref EXCHANGE_LIST: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/exchange_item.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data.clone();
-        }
-        info
-    };
-    static ref EXCHANGE_REWARD: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/exchange_item_reward.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data.clone();
-        }
-        info
-    };
-}
-
 pub fn exchange(req: HttpRequest) -> HttpResponse {
     let resp = object!{
         "code": 0,
@@ -40,7 +20,7 @@ pub fn exchange_post(req: HttpRequest, body: String) -> HttpResponse {
     let mut missions = userdata::get_acc_missions(&key);
     let mut cleared_missions = array![];
     
-    let item = &EXCHANGE_LIST[body["master_exchange_item_id"].to_string()];
+    let item = &databases::EXCHANGE_LIST[body["master_exchange_item_id"].to_string()];
     
     if item["consumeType"].as_i32().unwrap() == 4 {
         items::use_item(item["value"].as_i64().unwrap(), item["amount"].as_i64().unwrap() * body["count"].as_i64().unwrap(), &mut user);
@@ -48,7 +28,7 @@ pub fn exchange_post(req: HttpRequest, body: String) -> HttpResponse {
         println!("Unknown consume type {}", item["consumeType"]);
     }
     
-    let mut gift = EXCHANGE_REWARD[item["masterExchangeItemRewardId"].to_string()].clone();
+    let mut gift = databases::EXCHANGE_REWARD[item["masterExchangeItemRewardId"].to_string()].clone();
     gift["reward_type"] = gift["type"].clone();
     gift["amount"] = (gift["amount"].as_i64().unwrap() * body["count"].as_i64().unwrap()).into();
     items::give_gift(&gift, &mut user, &mut missions, &mut cleared_missions);

src/router/items.rs

@@ -1,25 +1,9 @@
 use json::{array, object, JsonValue};
-use lazy_static::lazy_static;
 use rand::Rng;
 use actix_web::{HttpResponse, HttpRequest};
 use crate::encryption;
 
-use crate::router::{userdata, global};
+use crate::router::{userdata, global, databases};
-
-lazy_static! {
-    static ref ITEM_INFO: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/item.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data.clone();
-        }
-        info
-    };
-}
-
-pub fn get_item_info(id: i64) -> JsonValue {
-    ITEM_INFO[id.to_string()].clone()
-}
 
 pub fn remove_gems(user: &mut JsonValue, amount: i64) {
     let mut amount = amount;
@@ -376,7 +360,7 @@ pub fn advance_variable_mission(min: i64, max: i64, count: i64, missions: &mut J
         if mission_status.is_empty() {
             continue;
         }
-        let mission_info = &crate::router::mission::MISSION_LIST[i.to_string()];
+        let mission_info = &databases::MISSION_LIST[i.to_string()];
         if i == max && mission_info["conditionNumber"].as_i64().unwrap() <= mission_status["progress"].as_i64().unwrap() {
             break;
         }
@@ -449,7 +433,7 @@ pub fn use_item_req(req: HttpRequest, body: String) -> HttpResponse {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
     
-    let item = get_item_info(body["id"].as_i64().unwrap());
+    let item = &databases::ITEM_INFO[body["id"].to_string()];
     let amount = body["amount"].as_i64().unwrap();
     
     if item["effectType"].as_i32().unwrap() == 1 {

src/router/live.rs

@@ -1,9 +1,8 @@
 use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
 use rand::Rng;
-use lazy_static::lazy_static;
 
-use crate::router::{global, userdata, items};
+use crate::router::{global, userdata, items, databases};
 use crate::encryption;
 use crate::router::clear_rate::live_completed;
 
@@ -294,59 +293,12 @@ pub fn update_live_mission_data(user: &mut JsonValue, data: &JsonValue) {
     user["live_mission_list"].push(rv.clone()).unwrap();
 }
 
-lazy_static! {
-    static ref LIVE_LIST: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/live.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data.clone();
-        }
-        info
-    };
-    static ref MISSION_DATA: JsonValue = {
-        json::parse(include_str!("json/live_mission.json")).unwrap()
-    };
-    static ref MISSION_COMBO_DATA: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/live_mission_combo.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["masterMusicId"].to_string()] = data.clone();
-        }
-        info
-    };
-    static ref MISSION_REWARD_DATA: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/live_mission_reward.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data.clone();
-        }
-        info
-    };
-    static ref CARD_LIST: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/card.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data.clone();
-        }
-        info
-    };
-}
-fn get_live_info(id: i64) -> JsonValue {
-    LIVE_LIST[id.to_string()].clone()
-}
-fn get_live_combo_info(id: i64) -> JsonValue {
-    MISSION_COMBO_DATA[id.to_string()].clone()
-}
-fn get_live_mission_info(id: i64) -> JsonValue {
-    MISSION_REWARD_DATA[id.to_string()].clone()
-}
-
 fn get_live_mission_completed_ids(user: &JsonValue, live_id: i64, score: i64, combo: i64, clear_count: i64, level: i64, full_combo: bool, all_perfect: bool) -> Option<JsonValue> {
-    let live_info = get_live_info(live_id);
+    let live_info = &databases::LIVE_LIST[live_id.to_string()];
     let mut out = array![];
-    let combo_info = get_live_combo_info(live_info["masterMusicId"].as_i64()?);
+    let combo_info = &databases::MISSION_COMBO_DATA[live_info["masterMusicId"].to_string()];
     
-    for (_i, data) in MISSION_DATA.members().enumerate() {
+    for (_i, data) in databases::MISSION_DATA.members().enumerate() {
         match data["type"].as_i32()? {
             1 => {
                 if live_info[&format!("score{}", data["value"].to_string())].as_i64()? <= score {
@@ -392,14 +344,14 @@ fn get_live_mission_completed_ids(user: &JsonValue, live_id: i64, score: i64, co
 
 fn give_mission_rewards(user: &mut JsonValue, missions: &JsonValue, user_missions: &mut JsonValue, cleared_missions: &mut JsonValue, multiplier: i64) -> JsonValue {
     let mut rv = array![];
-    for (_i, data) in MISSION_DATA.members().enumerate() {
+    for (_i, data) in databases::MISSION_DATA.members().enumerate() {
         if !missions.contains(data["id"].as_i32().unwrap()) {
             continue;
         }
         if data["masterLiveMissionRewardId"].as_i64().unwrap() == 0 {
             continue;
         }
-        let mut gift = get_live_mission_info(data["masterLiveMissionRewardId"].as_i64().unwrap());
+        let mut gift = databases::MISSION_REWARD_DATA[data["masterLiveMissionRewardId"].to_string()].clone();
         gift["reward_type"] = gift["type"].clone();
         gift["amount"] = (gift["amount"].as_i64().unwrap() * multiplier).into();
         items::give_gift(&gift, user, user_missions, cleared_missions);
@@ -435,7 +387,7 @@ fn get_live_character_list(deck_id: i32, user: &JsonValue, missions: &mut JsonVa
         if !characters_in_deck.contains(data["id"].as_i64().unwrap()) && !characters_in_deck.contains(data["master_card_id"].as_i64().unwrap())  {
             continue;
         }
-        let character = CARD_LIST[data["master_card_id"].to_string()]["masterCharacterId"].as_i64().unwrap();
+        let character = databases::CARD_LIST[data["master_card_id"].to_string()]["masterCharacterId"].as_i64().unwrap();
         let mut mission_id = 1158000 + get_master_id(character);
         let mut full = false;
         let mut status = items::get_mission_status(mission_id, missions);
@@ -606,7 +558,7 @@ pub fn event_end(req: HttpRequest, body: String) -> HttpResponse {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut event = userdata::get_acc_event(&key);
     
-    let live_id = crate::router::clear_rate::get_live_id(body["master_live_id"].as_i64().unwrap());
+    let live_id = databases::LIVE_LIST[body["master_live_id"].to_string()]["masterMusicId"].as_i64().unwrap();
     
     let mut all_clear = 1;
     for (_i, data) in event["event_data"]["star_event"]["star_music_list"].members_mut().enumerate() {

src/router/login.rs

@@ -1,10 +1,7 @@
 use json::{object, array, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
-use lazy_static::lazy_static;
 
-use crate::router::global;
+use crate::router::{global, userdata, items, databases};
-use crate::router::userdata;
-use crate::router::items;
 
 pub fn dummy(req: HttpRequest, body: String) -> HttpResponse {
     let key = global::get_login(req.headers(), &body);
@@ -20,35 +17,8 @@ pub fn dummy(req: HttpRequest, body: String) -> HttpResponse {
     global::send(resp, req)
 }
 
-lazy_static! {
-    static ref LOTTERY_INFO: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/login_bonus.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            if info[data["id"].to_string()].is_null() {
-                info[data["id"].to_string()] = object!{
-                    info: data.clone(),
-                    days: []
-                };
-            }
-        }
-        let days = json::parse(include_str!("json/login_bonus_reward_setting.json")).unwrap();
-        for (_i, data) in days.members().enumerate() {
-            if info[data["masterLoginBonusId"].to_string()].is_null() {
-                continue;
-            }
-            info[data["masterLoginBonusId"].to_string()]["days"].push(data.clone()).unwrap();
-        }
-        let mut real_info = object!{};
-        for (_i, data) in info.entries().enumerate() {
-            real_info[data.1["info"]["id"].to_string()] = data.1.clone();
-        }
-        real_info
-    };
-}
-
 pub fn get_login_bonus_info(id: i64) -> JsonValue {
-    LOTTERY_INFO[id.to_string()].clone()
+    databases::LOTTERY_INFO[id.to_string()].clone()
 }
 
 fn do_bonus(user_home: &mut JsonValue, bonuses: &mut JsonValue) -> JsonValue {
@@ -66,9 +36,9 @@ fn do_bonus(user_home: &mut JsonValue, bonuses: &mut JsonValue) -> JsonValue {
                 to_rm.push(i).unwrap();
                 continue;
             }
-            let item_id = crate::router::user::get_info_from_id(info["days"][current]["masterLoginBonusRewardId"].as_i64().unwrap());
+            let item_id = &databases::LOGIN_REWARDS[info["days"][current]["masterLoginBonusRewardId"].to_string()];
             
-            items::gift_item(&item_id, &format!("Event login bonus day {}!", current+1), user_home);
+            items::gift_item(item_id, &format!("Event login bonus day {}!", current+1), user_home);
             data["day_counts"].push(current + 1).unwrap();
         }
         for (i, data) in to_rm.members().enumerate() {

src/router/lottery.rs

@@ -1,66 +1,10 @@
 use json::{array, object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
-use lazy_static::lazy_static;
 use rand::Rng;
 
-use crate::router::{global, userdata, items};
+use crate::router::{global, userdata, items, databases};
 use crate::encryption;
 
-lazy_static! {
-    static ref CARDS: JsonValue = {
-        let mut cardz = object!{};
-        let items = json::parse(include_str!("lottery_item.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            if cardz[data["id"].to_string()].is_null() {
-                cardz[data["id"].to_string()] = object!{};
-            }
-            cardz[data["id"].to_string()][data["number"].to_string()] = data.clone();
-        }
-        cardz
-    };
-    static ref POOL: JsonValue = {
-        let mut cardz = object!{};
-        let items = json::parse(include_str!("lottery_item.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            if cardz[data["id"].to_string()].is_null() {
-                cardz[data["id"].to_string()] = array![];
-            }
-            cardz[data["id"].to_string()].push(data["number"].clone()).unwrap();
-        }
-        cardz
-    };
-    static ref RARITY: JsonValue = {
-        let mut cardz = object!{};
-        let items = json::parse(include_str!("lottery_rarity.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            if cardz[data["id"].to_string()].is_null() {
-                cardz[data["id"].to_string()] = array![];
-            }
-            cardz[data["id"].to_string()].push(data.clone()).unwrap();
-        }
-        cardz
-    };
-    static ref LOTTERY: JsonValue = {
-        let mut cardz = object!{};
-        let items = json::parse(include_str!("lottery.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            cardz[data["id"].to_string()] = data.clone();
-        }
-        cardz
-    };
-    static ref PRICE: JsonValue = {
-        let mut cardz = object!{};
-        let items = json::parse(include_str!("lottery_price.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            if cardz[data["id"].to_string()].is_null() {
-                cardz[data["id"].to_string()] = object!{};
-            }
-            cardz[data["id"].to_string()][data["number"].to_string()] = data.clone();
-        }
-        cardz
-    };
-}
-
 pub fn tutorial(req: HttpRequest, body: String) -> HttpResponse {
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
@@ -96,10 +40,10 @@ pub fn tutorial(req: HttpRequest, body: String) -> HttpResponse {
 }
 
 fn get_card_master_id(lottery_id: String, lottery_number: String) -> Option<i64> {
-    CARDS[lottery_id][lottery_number]["value"].as_i64()
+    databases::CARDS[lottery_id][lottery_number]["value"].as_i64()
 }
 fn get_card(lottery_id: String, lottery_number: String) -> JsonValue {
-    CARDS[lottery_id][lottery_number].clone()
+    databases::CARDS[lottery_id][lottery_number].clone()
 }
 
 fn get_random_card(item: &JsonValue, rv: &mut JsonValue, rng: &mut rand::rngs::ThreadRng) {
@@ -107,7 +51,7 @@ fn get_random_card(item: &JsonValue, rv: &mut JsonValue, rng: &mut rand::rngs::T
     
     let mut random_id = 0;
     while random_id == 0 {
-        let card = rng.gen_range(1..POOL[lottery_id.to_string()][POOL[lottery_id.to_string()].len() - 1].as_i64().unwrap() + 1);
+        let card = rng.gen_range(1..databases::POOL[lottery_id.to_string()][databases::POOL[lottery_id.to_string()].len() - 1].as_i64().unwrap() + 1);
         if !get_card_master_id(lottery_id.to_string(), card.to_string()).is_none() {
             random_id = card;
             break;
@@ -123,12 +67,12 @@ fn get_random_card(item: &JsonValue, rv: &mut JsonValue, rng: &mut rand::rngs::T
 }
 
 fn get_random_cards(id: i64, mut count: usize) -> JsonValue {
-    let total_ratio: i64 = RARITY[id.to_string()].members().into_iter().map(|item| if item["ensured"].as_i32().unwrap() == 1 { 0 } else { item["ratio"].as_i64().unwrap() }).sum();
+    let total_ratio: i64 = databases::RARITY[id.to_string()].members().into_iter().map(|item| if item["ensured"].as_i32().unwrap() == 1 { 0 } else { item["ratio"].as_i64().unwrap() }).sum();
     let mut rng = rand::thread_rng();
     let mut rv = array![];
     let mut promised = false;
     
-    for (_i, item) in RARITY[id.to_string()].members().enumerate() {
+    for (_i, item) in databases::RARITY[id.to_string()].members().enumerate() {
         if item["ensured"].as_i32().unwrap() == 1 {
             get_random_card(&item, &mut rv, &mut rng);
             promised = true;
@@ -141,7 +85,7 @@ fn get_random_cards(id: i64, mut count: usize) -> JsonValue {
     for _i in 0..count {
         let random_number: i64 = rng.gen_range(1..total_ratio + 1);
         let mut cumulative_ratio = 0;
-        for (_i, item) in RARITY[id.to_string()].members().enumerate() {
+        for (_i, item) in databases::RARITY[id.to_string()].members().enumerate() {
             cumulative_ratio += item["ratio"].as_i64().unwrap();
             if random_number <= cumulative_ratio {
                 get_random_card(&item, &mut rv, &mut rng);
@@ -173,7 +117,7 @@ pub fn lottery_post(req: HttpRequest, body: String) -> HttpResponse {
     let mut cleared_missions = array![];
     
     let lottery_id = body["master_lottery_id"].as_i64().unwrap();
-    let price = PRICE[lottery_id.to_string()][body["master_lottery_price_number"].to_string()].clone();
+    let price = databases::PRICE[lottery_id.to_string()][body["master_lottery_price_number"].to_string()].clone();
     
     if price["consumeType"].as_i32().unwrap() == 1 {
         items::remove_gems(&mut user, price["price"].as_i64().unwrap());
@@ -183,7 +127,7 @@ pub fn lottery_post(req: HttpRequest, body: String) -> HttpResponse {
     
     let cardstogive = get_random_cards(lottery_id, price["count"].as_usize().unwrap());
     
-    let lottery_type = LOTTERY[lottery_id.to_string()]["category"].as_i32().unwrap();
+    let lottery_type = databases::LOTTERY[lottery_id.to_string()]["category"].as_i32().unwrap();
     
     let mut new_cards = array![];
     let mut lottery_list = array![];

src/router/mission.rs

@@ -1,10 +1,8 @@
-use json::{array, object, JsonValue};
+use json::{array, object};
 use actix_web::{HttpResponse, HttpRequest};
-use lazy_static::lazy_static;
 
-use crate::router::{global, userdata};
+use crate::router::{global, userdata, items, databases};
 use crate::encryption;
-use crate::router::items;
 
 pub fn mission(req: HttpRequest) -> HttpResponse {
     let key = global::get_login(req.headers(), "");
@@ -22,17 +20,12 @@ pub fn mission(req: HttpRequest) -> HttpResponse {
 
 pub fn clear(req: HttpRequest, body: String) -> HttpResponse {
     let key = global::get_login(req.headers(), &body);
+    
     let mut missions = userdata::get_acc_missions(&key);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     
     for (_i, id) in body["master_mission_ids"].members().enumerate() {
-        for (i, mission) in missions.members().enumerate() {
+        items::update_mission_status(id.as_i64().unwrap(), 0, true, true, 1, &mut missions);
-            if mission["master_mission_id"].to_string() == id.to_string() {
-                //I think this is all?
-                missions[i]["progress"] = (1).into();
-                break;
-            }
-        }
     }
     
     userdata::save_acc_missions(&key, missions);
@@ -47,25 +40,6 @@ pub fn clear(req: HttpRequest, body: String) -> HttpResponse {
     global::send(resp, req)
 }
 
-lazy_static! {
-    pub static ref MISSION_LIST: JsonValue = {
-        let mut info = object!{};
-        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
-    };
-}
-
 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();
@@ -75,8 +49,8 @@ pub fn receive(req: HttpRequest, body: String) -> HttpResponse {
     let mut rewards = array![];
     
     for (_i, mission) in body["master_mission_ids"].members().enumerate() {
-        let mission_info = MISSION_LIST[mission.to_string()].clone();
+        let mission_info = databases::MISSION_LIST[mission.to_string()].clone();
-        let mut gift = MISSION_REWARD[mission_info["masterMissionRewardId"].to_string()].clone();
+        let mut gift = databases::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, &mut missions, &mut array![]);

src/router/shop.rs

@@ -1,25 +1,9 @@
-use json::{object, JsonValue};
+use json::object;
 use actix_web::{HttpResponse, HttpRequest};
-use lazy_static::lazy_static;
 
-use crate::router::{userdata, global, items};
+use crate::router::{userdata, global, items, databases};
 use crate::encryption;
 
-lazy_static! {
-    static ref SHOP_INFO: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/shop_item.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data.clone();
-        }
-        info
-    };
-}
-
-fn get_item_info(id: i64) -> JsonValue {
-    SHOP_INFO[id.to_string()].clone()
-}
-
 pub fn shop(req: HttpRequest) -> HttpResponse {
     let key = global::get_login(req.headers(), "");
     let user = userdata::get_acc(&key);
@@ -40,7 +24,7 @@ pub fn buy(req: HttpRequest, body: String) -> HttpResponse {
     let mut user = userdata::get_acc(&key);
     let user_home = userdata::get_acc_home(&key);
     
-    let item = get_item_info(body["master_shop_item_id"].as_i64().unwrap());
+    let item = &databases::SHOP_INFO[body["master_shop_item_id"].to_string()];
     
     items::remove_gems(&mut user, item["price"].as_i64().unwrap());
     items::give_shop(item["masterShopRewardId"].as_i64().unwrap(), item["price"].as_i64().unwrap(), &mut user);

src/router/user.rs

@@ -1,6 +1,5 @@
 use json::{array, object, JsonValue};
 use actix_web::{HttpResponse, HttpRequest};
-use lazy_static::lazy_static;
 
 use crate::encryption;
 use crate::router::{userdata, global, items};
@@ -57,21 +56,6 @@ pub fn user(req: HttpRequest) -> HttpResponse {
     global::send(resp, req)
 }
 
-lazy_static! {
-    static ref LOGIN_REWARDS: JsonValue = {
-        let mut info = object!{};
-        let items = json::parse(include_str!("json/login_bonus_reward.json")).unwrap();
-        for (_i, data) in items.members().enumerate() {
-            info[data["id"].to_string()] = data.clone();
-        }
-        info
-    };
-}
-
-pub fn get_info_from_id(id: i64) -> JsonValue {
-    LOGIN_REWARDS[id.to_string()].clone()
-}
-
 pub fn gift(req: HttpRequest, body: String) -> HttpResponse {
     let key = global::get_login(req.headers(), &body);
     let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();