Properly implement exchange endpoint

src/router/exchange.rs

@@ -1,4 +1,4 @@
-use jzon::{object, array};
+use jzon::{object, array, JsonValue};
 use actix_web::{web, HttpRequest, Responder};
 
 use crate::router::{global, userdata, items, databases};
@@ -9,7 +9,29 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
 }
 
 async fn exchange(req: HttpRequest) -> impl Responder {
-    global::api(&req, Some(object!{"exchange_list":[]}))
+    let key = global::get_login(req.headers(), "");
+    let exchange = userdata::get_acc_exchange(&key);
+    global::api(&req, Some(object!{
+        "exchange_list": exchange
+    }))
+}
+
+fn exchange_updated_value_list(is_card: bool, granted_id: i64, consumed_id: i64, user: &mut JsonValue) -> JsonValue {
+    if consumed_id != 0 && !user["item_list"].members().any(|it| it["master_item_id"].as_i64() == Some(consumed_id)) {
+        items::give_item(consumed_id, 0, user);
+    }
+    let mut item_list = array![];
+    for it in user["item_list"].members() {
+        let mid = it["master_item_id"].as_i64();
+        if mid == Some(granted_id) || mid == Some(consumed_id) {
+            item_list.push(it.clone()).unwrap();
+        }
+    }
+    let mut rv = object!{ item_list: item_list };
+    if is_card {
+        rv["card_list"] = user["card_list"].clone();
+    }
+    rv
 }
 
 async fn exchange_post(req: HttpRequest, body: String) -> impl Responder {
@@ -18,28 +40,53 @@ async fn exchange_post(req: HttpRequest, body: String) -> impl Responder {
     let mut user = userdata::get_acc(&key);
     let mut missions = userdata::get_acc_missions(&key);
     let mut chats = userdata::get_acc_chats(&key);
+    let mut exchanges = userdata::get_acc_exchange(&key);
     let mut cleared_missions = array![];
-    
+
-    let item = &databases::EXCHANGE_LIST[body["master_exchange_item_id"].to_string()];
+    let exchange_id = body["master_exchange_item_id"].as_i64().unwrap();
-    
+    let count = body["count"].as_i64().unwrap();
-    items::use_item(item, body["count"].as_i64().unwrap(), &mut user);
+    let item = databases::EXCHANGE_LIST[exchange_id.to_string()].clone();
-    
+    let consumed_id = item["value"].as_i64().unwrap_or(0);
+
+    items::use_item(&item, count, &mut user);
+
     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();
+    gift["amount"] = (gift["amount"].as_i64().unwrap() * count).into();
+    let granted_id = gift["value"].as_i64().unwrap_or(0);
+    let is_card = gift["type"] == 2;
     items::give_gift(&gift, &mut user, &mut missions, &mut cleared_missions, &mut chats);
-    
+
+    let mut total = count;
+    let mut found = false;
+    for entry in exchanges.members_mut() {
+        if entry["master_exchange_item_id"].as_i64() == Some(exchange_id) {
+            total = entry["count"].as_i64().unwrap() + count;
+            entry["count"] = total.into();
+            found = true;
+            break;
+        }
+    }
+    if !found {
+        exchanges.push(object!{
+            master_exchange_item_id: exchange_id,
+            count: total
+        }).unwrap();
+    }
+
+    let updated_value_list = exchange_updated_value_list(is_card, granted_id, consumed_id, &mut user);
+
     userdata::save_acc(&key, user.clone());
     userdata::save_acc_missions(&key, missions);
     userdata::save_acc_chats(&key, chats);
+    userdata::save_acc_exchange(&key, exchanges);
 
     global::api(&req, Some(object!{
-        "exchange": body,
+        "clear_mission_ids": cleared_missions,
-        "updated_value_list": {
+        "exchange": {
-            "card_list": user["card_list"].clone(),
+            master_exchange_item_id: exchange_id,
-            "item_list": user["item_list"].clone(),
+            count: total
-            "point_list": user["point_list"].clone()
         },
-        "clear_mission_ids": cleared_missions
+        "updated_value_list": updated_value_list
     }))
 }

src/router/items.rs

@@ -238,7 +238,7 @@ pub fn gift_item(item: &JsonValue, reason: &str, user: &mut JsonValue) -> JsonVa
         level: item["level"].clone(),
         amount: item["amount"].clone(),
         created_date_time: global::timestamp(),
-        expire_date_time: global::timestamp() + (5 * (24 * 60 * 60)),
+        expire_date_time: global::timestamp() + (300 * (24 * 60 * 60)),
         received_date_time: 0
     };
     if user["home"]["gift_list"].len() >= GIFT_LIMIT {
@@ -541,9 +541,17 @@ async fn use_item_req(req: HttpRequest, body: String) -> impl Responder {
     }, amount, &mut user);
     
     userdata::save_acc(&key, user.clone());
-    
+
+    let mut used = object!{};
+    for it in user["item_list"].members() {
+        if it["master_item_id"].as_i64() == body["id"].as_i64() {
+            used = it.clone();
+            break;
+        }
+    }
+
     global::api(&req, Some(object!{
-        item_list: user["item_list"].clone(),
+        item_list: [used],
         stamina: user["stamina"].clone()
     }))
 }

src/router/shop.rs

@@ -25,20 +25,28 @@ async fn buy(req: HttpRequest, body: String) -> impl Responder {
     let key = global::get_login(req.headers(), &body);
     let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
     let mut user = userdata::get_acc(&key);
-    let user_home = userdata::get_acc_home(&key);
+
-    
+    let shop_item_id = body["master_shop_item_id"].as_i64().unwrap();
-    let item = &databases::SHOP_INFO[body["master_shop_item_id"].to_string()];
+    let item = &databases::SHOP_INFO[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);
+    items::give_shop(shop_item_id, 1, &mut user);
     items::lp_modification(&mut user, item["price"].as_u64().unwrap() / 2, false);
-    
+
     userdata::save_acc(&key, user.clone());
-    
+
+    let mut bought = object!{};
+    for entry in user["shop_list"].members() {
+        if entry["master_shop_item_id"].as_i64() == Some(shop_item_id) {
+            bought = entry.clone();
+            break;
+        }
+    }
+
     global::api(&req, Some(object!{
         "gem": user["gem"].clone(),
-        "shop_list": user["shop_list"].clone(),
+        "shop_list": [bought],
-        "gift_list": user_home["home"]["gift_list"].clone(),
+        "gift_list": [],
         "updated_value_list": {
             "stamina": user["stamina"].clone()
         }

src/router/userdata/mod.rs

@@ -61,6 +61,10 @@ CREATE TABLE IF NOT EXISTS chats (
     user_id          BIGINT NOT NULL PRIMARY KEY,
     chats            TEXT NOT NULL
 );
+CREATE TABLE IF NOT EXISTS exchange (
+    user_id          BIGINT NOT NULL PRIMARY KEY,
+    exchange         TEXT NOT NULL
+);
 CREATE TABLE IF NOT EXISTS event (
     user_id          BIGINT NOT NULL PRIMARY KEY,
     event            TEXT NOT NULL
@@ -78,6 +82,7 @@ CREATE TABLE IF NOT EXISTS webui (
     token        TEXT NOT NULL,
     last_login   BIGINT NOT NULL
 );
+INSERT OR IGNORE INTO exchange (user_id, exchange) SELECT user_id, '[]' FROM userdata;
     ").unwrap();
 }
 
@@ -156,6 +161,10 @@ fn add_user_to_database(uid: i64, user: JsonValue, user_home: JsonValue, user_mi
         uid,
         "[]"
     ));
+    DATABASE.lock_and_exec("INSERT INTO exchange (user_id, exchange) VALUES (?1, ?2)", params!(
+        uid,
+        "[]"
+    ));
 }
 
 fn create_acc(uid: i64, login: &str) {
@@ -303,6 +312,9 @@ pub fn get_server_data(auth_key: &str) -> JsonValue {
 pub fn get_acc_chats(auth_key: &str) -> JsonValue {
     get_data(auth_key, "chats")
 }
+pub fn get_acc_exchange(auth_key: &str) -> JsonValue {
+    get_data(auth_key, "exchange")
+}
 pub fn get_acc_event(auth_key: &str) -> JsonValue {
     let event = get_data(auth_key, "event");
     if event.is_empty() {
@@ -348,6 +360,9 @@ pub fn save_server_data(auth_key: &str, data: JsonValue) {
 pub fn save_acc_chats(auth_key: &str, data: JsonValue) {
     save_data(auth_key, "chats", data);
 }
+pub fn save_acc_exchange(auth_key: &str, data: JsonValue) {
+    save_data(auth_key, "exchange", data);
+}
 pub fn save_acc_sif(auth_key: &str, data: JsonValue) {
     save_data(auth_key, "sifcards", data);
 }
@@ -625,6 +640,7 @@ pub fn purge_accounts() -> usize {
         DATABASE.lock_and_exec("DELETE FROM sifcards WHERE user_id=?1", params!(user_id));
         DATABASE.lock_and_exec("DELETE FROM friends WHERE user_id=?1", params!(user_id));
         DATABASE.lock_and_exec("DELETE FROM chats WHERE user_id=?1", params!(user_id));
+        DATABASE.lock_and_exec("DELETE FROM exchange WHERE user_id=?1", params!(user_id));
         DATABASE.lock_and_exec("DELETE FROM event WHERE user_id=?1", params!(user_id));
         DATABASE.lock_and_exec("DELETE FROM eventloginbonus WHERE user_id=?1", params!(user_id));
         DATABASE.lock_and_exec("DELETE FROM server_data WHERE user_id=?1", params!(user_id));