zhushenwudi/ew_author
1
0
Fork 0
mirror of https://git.ethanthesleepy.one/ethanaobrien/ew synced 2026-08-26 15:02:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move response encryption handler to a response handler

Browse Source
This commit is contained in:
Ethan O'Brien
2026-07-24 14:40:12 -05:00
parent 0b0b50de36
commit 6eec06e164
24 changed files with 223 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/router.rs
View File

@@ -36,10 +36,10 @@ use actix_web::{
HttpResponse,
HttpRequest,
FromRequest,
Responder,
body::{BoxBody, MessageBody},
dev::{Payload, ServiceRequest, ServiceResponse},
middleware::{from_fn, Next},
http::header::HeaderMap
};
use futures_util::future::LocalBoxFuture;
use futures_util::FutureExt;
@@ -55,6 +55,26 @@ pub struct Session {
pub body: JsonValue,
}
pub trait ApiBody {
fn into_json(self) -> JsonValue;
}
impl ApiBody for JsonValue {
fn into_json(self) -> JsonValue {
self
}
}
pub struct Api<T = JsonValue>(pub Option<T>);
impl<T: ApiBody> Responder for Api<T> {
type Body = BoxBody;
fn respond_to(self, req: &HttpRequest) -> HttpResponse {
global::api(req, self.0.map(ApiBody::into_json))
}
}
impl FromRequest for Body {
type Error = actix_web::Error;
type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;
@@ -101,7 +121,7 @@ async fn webui_fallback(req: ServiceRequest, next: Next<impl MessageBody + 'stat
if !is_from_game {
let req = req.into_parts().0;
let resp = if crate::get_args().hidden {
not_found(req.headers())
not_found(&req)
} else {
webui::main(req.clone())
};
@@ -128,20 +148,20 @@ fn unhandled(req: &HttpRequest, body: String) -> Option<JsonValue> {
None
}
fn not_found(headers: &HeaderMap) -> HttpResponse {
fn not_found(req: &HttpRequest) -> HttpResponse {
let rv = object!{
"code": 4,
"server_time": global::timestamp(),
"message": ""
};
global::send(rv, 0, headers)
global::send(rv, 0, req)
}
// Fallback for paths no actix route matched. Game endpoints live in each module's routes()
async fn api_req(req: HttpRequest, body: String) -> HttpResponse {
let args = crate::get_args();
if args.hidden && (req.path().starts_with("/api/webui/") || !(req.path().starts_with("/api") || req.path().starts_with("/v1.0"))) {
return not_found(req.headers());
return not_found(&req);
} else if !req.path().starts_with("/api") && !req.path().starts_with("/v1.0") {
return webui::main(req);
}
@@ -153,11 +173,11 @@ pub async fn request(req: HttpRequest, body: String) -> HttpResponse {
let args = crate::get_args();
let headers = req.headers();
if args.hidden && (req.path().starts_with("/api/webui/") || req.path().starts_with("/live_clear_rate.html")) {
return not_found(headers);
return not_found(&req);
}
if headers.get("aoharu-asset-version").is_none() && req.path().starts_with("/api") && !req.path().starts_with("/api/webui") {
if args.hidden {
return not_found(headers);
return not_found(&req);
} else {
return webui::main(req);
}

16
src/router/card.rs
View File

@@ -1,7 +1,7 @@
use jzon::{object, array, JsonValue};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{userdata, global, items, databases, Session};
use crate::router::{userdata, items, databases, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(
@@ -105,7 +105,7 @@ fn do_reinforce(user: &mut JsonValue, body: &JsonValue, exp_id: &str, money_mult
object!{}
}
async fn reinforce(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn reinforce(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
let mut clear_mission_ids = array![];
@@ -113,7 +113,7 @@ async fn reinforce(req: HttpRequest, Session { key, body }: Session) -> impl Res
userdata::save_acc(&key, user.clone());
global::api(&req, Some(object!{
Api(Some(object!{
card: card,
item_list: material_item_list(&user, &body),
point_list: user["point_list"].clone(),
@@ -121,7 +121,7 @@ async fn reinforce(req: HttpRequest, Session { key, body }: Session) -> impl Res
}))
}
async fn skill_reinforce(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn skill_reinforce(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
let mut clear_mission_ids = array![];
@@ -129,7 +129,7 @@ async fn skill_reinforce(req: HttpRequest, Session { key, body }: Session) -> im
userdata::save_acc(&key, user.clone());
global::api(&req, Some(object!{
Api(Some(object!{
card: card,
item_list: material_item_list(&user, &body),
point_list: user["point_list"].clone(),
@@ -137,7 +137,7 @@ async fn skill_reinforce(req: HttpRequest, Session { key, body }: Session) -> im
}))
}
async fn evolve(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn evolve(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
let mut chats = userdata::get_acc_chats(&key);
let mut missions = userdata::get_acc_missions(&key);
@@ -149,7 +149,7 @@ async fn evolve(req: HttpRequest, Session { key, body }: Session) -> impl Respon
userdata::save_acc_chats(&key, chats);
userdata::save_acc_missions(&key, missions);
global::api(&req, Some(object!{
Api(Some(object!{
card: card,
item_list: material_item_list(&user, &body),
point_list: user["point_list"].clone(),

16
src/router/chat.rs
View File

@@ -1,7 +1,7 @@
use jzon::{object, array, JsonValue};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{global, items, userdata, databases, Login, Session};
use crate::router::{global, items, userdata, databases, Login, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(
@@ -37,7 +37,7 @@ pub fn add_chat_from_chapter_id(chapter_id: i64, chats: &mut JsonValue) -> bool
add_chat(chapter["masterChatId"].as_i64().unwrap(), chapter["roomId"].as_i64().unwrap(), chats)
}
async fn home(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn home(Login(key): Login) -> impl Responder {
let chats = userdata::get_acc_chats(&key);
let mut rooms = array![];
@@ -45,7 +45,7 @@ async fn home(req: HttpRequest, Login(key): Login) -> impl Responder {
rooms.push(databases::CHATS[data["chat_id"].to_string()][data["room_id"].to_string()]["id"].clone()).unwrap();
}
global::api(&req, Some(object!{
Api(Some(object!{
"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],
@@ -53,11 +53,11 @@ async fn home(req: HttpRequest, Login(key): Login) -> impl Responder {
}))
}
async fn start(req: HttpRequest) -> impl Responder {
global::api(&req, Some(object!{"select_talk_id_list":[],"get_item_list":[],"is_read":0}))
async fn start() -> impl Responder {
Api(Some(object!{"select_talk_id_list":[],"get_item_list":[],"is_read":0}))
}
async fn end(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn end(Session { key, body }: Session) -> impl Responder {
let mut missions = userdata::get_acc_missions(&key);
let mut chats = userdata::get_acc_chats(&key);
@@ -73,5 +73,5 @@ async fn end(req: HttpRequest, Session { key, body }: Session) -> impl Responder
}
}
global::api(&req, Some(array![]))
Api(Some(array![]))
}

8
src/router/clear_rate.rs
View File

@@ -5,7 +5,7 @@ use std::sync::Mutex;
use lazy_static::lazy_static;
use crate::sql::SQLite;
use crate::router::{databases, global, userdata, Session};
use crate::router::{databases, global, userdata, Session, Api};
use crate::include_file;
use crate::router::tools::guest;
@@ -251,10 +251,10 @@ pub async fn clearrate(req: HttpRequest) -> impl Responder {
data["all_user_clear_rate"] = new_rates;
data["master_music_ids"] = new_ids;
}
global::api(&req, Some(data))
Api(Some(data))
}
pub async fn ranking(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
pub async fn ranking(Session { key, body }: Session) -> impl Responder {
let self_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
let live = body["master_live_id"].as_i64().unwrap();
@@ -282,7 +282,7 @@ pub async fn ranking(req: HttpRequest, Session { key, body }: Session) -> impl R
}).unwrap();
}
global::api(&req, Some(object!{
Api(Some(object!{
"ranking_list": rank
}))
}

8
src/router/custom_song.rs
View File

@@ -11,7 +11,7 @@ use std::collections::HashMap;
use std::fs;
use std::sync::Mutex;
use crate::router::{global, userdata, webui, Login};
use crate::router::{global, userdata, webui, Login, Api};
use crate::database::custom_song as database;
use crate::runtime::get_data_path;
use crate::lock_onto_mutex;
@@ -91,13 +91,13 @@ pub fn client_supports_custom_songs(req: &HttpRequest) -> bool {
// The catalog is filtered per requesting user: private songs only show for
// their owner, shared songs for the owner plus their shared-user list
async fn list(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn list(Login(key): Login) -> impl Responder {
if disabled() {
// As if the endpoint doesn't exist - the client treats this as feature-off
return global::api(&req, None);
return Api(None);
}
let uid = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
global::api(&req, Some(object!{
Api(Some(object!{
"revision": database::get_revision(),
"songs": database::get_songs_for_user(uid)
}))

8
src/router/debug.rs
View File

@@ -1,15 +1,15 @@
use jzon::object;
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{global, Body};
use crate::router::{Body, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/debug/error", web::post().to(error));
}
async fn error(req: HttpRequest, Body(body): Body) -> impl Responder {
async fn error(Body(body): Body) -> impl Responder {
println!("client error: {}", body["code"]);
global::api(&req, Some(object!{}))
Api(Some(object!{}))
}

26
src/router/event.rs
View File

@@ -3,7 +3,7 @@ use actix_web::{web, HttpRequest, Responder};
use rand::RngExt;
use crate::include_file;
use crate::router::{userdata, global, databases, Body, Session};
use crate::router::{userdata, global, databases, Body, Session, Api};
// I believe(?) this is all?
const STAR_EVENT_IDS: [u32; 3] = [127, 135, 139];
@@ -113,7 +113,7 @@ fn init_star_event(event: &mut JsonValue) {
switch_music(event, 5);
}
async fn event(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn event(Session { key, body }: Session) -> impl Responder {
let master_event_id = body["master_event_id"].as_u32().unwrap();
let mut event = get_event_data(&key, master_event_id);
@@ -153,10 +153,10 @@ async fn event(req: HttpRequest, Session { key, body }: Session) -> impl Respond
}
}
global::api(&req, Some(event))
Api(Some(event))
}
async fn star_event(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn star_event(Session { key, body }: Session) -> impl Responder {
let user = userdata::get_acc(&key);
let master_event_id = body["master_event_id"].as_u32().unwrap();
@@ -170,14 +170,14 @@ async fn star_event(req: HttpRequest, Session { key, body }: Session) -> impl Re
save_event_data(&key, master_event_id, event.clone());
global::api(&req, Some(object!{
Api(Some(object!{
star_event: star_event,
gift_list: [],
reward_list: []
}))
}
async fn change_target_music(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn change_target_music(Session { key, body }: Session) -> impl Responder {
let master_event_id = body["master_event_id"].as_u32().unwrap();
let mut event = get_event_data(&key, master_event_id);
@@ -188,10 +188,10 @@ async fn change_target_music(req: HttpRequest, Session { key, body }: Session) -
save_event_data(&key, master_event_id, event.clone());
global::api(&req, Some(event["star_event"].clone()))
Api(Some(event["star_event"].clone()))
}
async fn set_member(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn set_member(Session { key, body }: Session) -> impl Responder {
let master_event_id = body["master_event_id"].as_u32().unwrap();
let mut event = get_event_data(&key, master_event_id);
@@ -204,7 +204,7 @@ async fn set_member(req: HttpRequest, Session { key, body }: Session) -> impl Re
save_event_data(&key, master_event_id, event.clone());
global::api(&req, Some(object!{
Api(Some(object!{
event_member: event["member_ranking"].clone()
}))
}
@@ -222,7 +222,7 @@ fn get_rank(event: u32, user_id: u64) -> u32 {
0
}
async fn ranking(req: HttpRequest, Body(body): Body) -> impl Responder {
async fn ranking(Body(body): Body) -> impl Responder {
let master_event_id = body["master_event_id"].as_u32().unwrap();
let scores = crate::router::event_ranking::get_scores_json().await[master_event_id as usize].clone();
let mut rv = array![];
@@ -238,7 +238,7 @@ async fn ranking(req: HttpRequest, Body(body): Body) -> impl Responder {
}
}
global::api(&req, Some(object!{
Api(Some(object!{
ranking_detail_list: rv
}))
}
@@ -357,9 +357,9 @@ fn event_live(req: &HttpRequest, key: &str, body: &JsonValue, skipped: bool) ->
}
async fn event_end(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
global::api(&req, event_live(&req, &key, &body, false))
Api(event_live(&req, &key, &body, false))
}
async fn event_skip(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
global::api(&req, event_live(&req, &key, &body, true))
Api(event_live(&req, &key, &body, true))
}

12
src/router/exchange.rs
View File

@@ -1,15 +1,15 @@
use jzon::{object, array, JsonValue};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{global, userdata, items, databases, Login, Session};
use crate::router::{userdata, items, databases, Login, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(web::resource("/exchange").route(web::get().to(exchange)).route(web::post().to(exchange_post)));
}
async fn exchange(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn exchange(Login(key): Login) -> impl Responder {
let exchange = userdata::get_acc_exchange(&key);
global::api(&req, Some(object!{
Api(Some(object!{
"exchange_list": exchange
}))
}
@@ -32,7 +32,7 @@ fn exchange_updated_value_list(is_card: bool, granted_id: i64, consumed_id: i64,
rv
}
async fn exchange_post(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn exchange_post(Session { key, body }: Session) -> 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);
@@ -77,7 +77,7 @@ async fn exchange_post(req: HttpRequest, Session { key, body }: Session) -> impl
userdata::save_acc_chats(&key, chats);
userdata::save_acc_exchange(&key, exchanges);
global::api(&req, Some(object!{
Api(Some(object!{
"clear_mission_ids": cleared_missions,
"exchange": {
master_exchange_item_id: exchange_id,

36
src/router/friend.rs
View File

@@ -1,7 +1,7 @@
use jzon::{array, object};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{global, userdata, Login, Session};
use crate::router::{global, userdata, Login, Session, Api};
use crate::router::tools::guest;
pub const FRIEND_LIMIT: usize = 40;
@@ -20,7 +20,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
);
}
async fn friend(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn friend(Session { key, body }: Session) -> impl Responder {
let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
let friends = userdata::get_acc_friends(&key);
@@ -42,18 +42,18 @@ async fn friend(req: HttpRequest, Session { key, body }: Session) -> impl Respon
rv.push(user).unwrap();
}
global::api(&req, Some(object!{
Api(Some(object!{
"friend_list": rv
}))
}
async fn ids(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn ids(Login(key): Login) -> impl Responder {
let friends = userdata::get_acc_friends(&key);
global::api(&req, Some(friends))
Api(Some(friends))
}
async fn recommend(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn recommend(Login(key): Login) -> impl Responder {
let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
let friends = userdata::get_acc_friends(&key);
@@ -73,25 +73,25 @@ async fn recommend(req: HttpRequest, Login(key): Login) -> impl Responder {
rv.push(user).unwrap();
}
global::api(&req, Some(object!{
Api(Some(object!{
friend_list: rv
}))
}
async fn search(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn search(Session { key, body }: Session) -> impl Responder {
let friends = userdata::get_acc_friends(&key);
let uid = body["user_id"].as_i64().unwrap();
let user = guest::get_user(uid, &friends, guest::UserView::Detail);
global::api(&req, Some(if user.is_empty() {
Api(Some(if user.is_empty() {
array![]
} else {
user
}))
}
async fn request(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn request(Session { key, body }: Session) -> impl Responder {
let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
let mut friends = userdata::get_acc_friends(&key);
@@ -104,10 +104,10 @@ async fn request(req: HttpRequest, Session { key, body }: Session) -> impl Respo
userdata::friend_request(uid, user_id);
}
global::api(&req, Some(array![]))
Api(Some(array![]))
}
async fn approve(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn approve(Session { key, body }: Session) -> impl Responder {
let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
let mut friends = userdata::get_acc_friends(&key);
@@ -123,10 +123,10 @@ async fn approve(req: HttpRequest, Session { key, body }: Session) -> impl Respo
userdata::save_acc_friends(&key, friends);
}
global::api(&req, Some(array![]))
Api(Some(array![]))
}
async fn cancel(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn cancel(Session { key, body }: Session) -> impl Responder {
let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
let mut friends = userdata::get_acc_friends(&key);
@@ -138,10 +138,10 @@ async fn cancel(req: HttpRequest, Session { key, body }: Session) -> impl Respon
userdata::friend_request_approve(uid, user_id, false, "pending_user_id_list");
userdata::save_acc_friends(&key, friends);
global::api(&req, Some(array![]))
Api(Some(array![]))
}
async fn delete(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn delete(Session { key, body }: Session) -> impl Responder {
let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
let mut friends = userdata::get_acc_friends(&key);
@@ -153,5 +153,5 @@ async fn delete(req: HttpRequest, Session { key, body }: Session) -> impl Respon
userdata::friend_remove(uid, user_id);
userdata::save_acc_friends(&key, friends);
global::api(&req, Some(array![]))
Api(Some(array![]))
}

10
src/router/global.rs
View File

@@ -324,14 +324,14 @@ pub fn set_time(current_time: u64, uid: i64, max: bool) -> u64 {
return server_time + time_since_set;
}
pub fn send(mut data: JsonValue, uid: i64, headers: &HeaderMap) -> HttpResponse {
pub fn send(mut data: JsonValue, uid: i64, req: &HttpRequest) -> HttpResponse {
//println!("{}", jzon::stringify(data.clone()));
data["server_time"] = set_time(data["server_time"].as_u64().unwrap_or(0), uid, true).into();
if !data["data"]["item_list"].is_empty() || !data["data"]["updated_value_list"]["item_list"].is_empty() {
items::check_for_region(&mut data, headers);
items::check_for_region(&mut data, req.headers());
}
let encrypted = encryption::encrypt_packet(&jzon::stringify(data)).unwrap();
let resp = encrypted.into_bytes();
@@ -354,7 +354,7 @@ pub fn api(req: &HttpRequest, data: Option<JsonValue>) -> HttpResponse {
"message": ""
}
};
send(rv, uid, req.headers())
send(rv, uid, req)
}
pub fn api_error(req: &HttpRequest, code: i32) -> HttpResponse {
@@ -363,7 +363,7 @@ pub fn api_error(req: &HttpRequest, code: i32) -> HttpResponse {
"code": code,
"server_time": timestamp(),
"message": ""
}, uid, req.headers())
}, uid, req)
}
pub fn start_login_bonus(id: i64, bonus: &mut JsonValue) -> bool {

20
src/router/home.rs
View File

@@ -1,8 +1,8 @@
use jzon::{object, array, JsonValue};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use lazy_static::lazy_static;
use crate::router::{global, userdata, items, Login, Session};
use crate::router::{global, userdata, items, Login, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(
@@ -13,7 +13,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
);
}
async fn preset(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn preset(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc_home(&key);
for data in user["home"]["preset_setting"].members_mut() {
@@ -23,7 +23,7 @@ async fn preset(req: HttpRequest, Session { key, body }: Session) -> impl Respon
}
userdata::save_acc_home(&key, user);
global::api(&req, Some(array![]))
Api(Some(array![]))
}
fn check_gifts(user: &mut JsonValue) {
@@ -38,19 +38,19 @@ fn check_gifts(user: &mut JsonValue) {
}
}
pub async fn gift_get(req: HttpRequest, Login(key): Login) -> impl Responder {
pub async fn gift_get(Login(key): Login) -> impl Responder {
let mut user = userdata::get_acc_home(&key);
check_gifts(&mut user);
global::api(&req, Some(object!{
Api(Some(object!{
"gift_list": user["home"]["gift_list"].clone()
}))
}
async fn preset_get(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn preset_get(Login(key): Login) -> impl Responder {
let user = userdata::get_acc(&key);
global::api(&req, Some(object!{
Api(Some(object!{
"master_preset_background_ids": [1,2,3,4,5],
"master_preset_foreground_ids": [1,2,3],
"card_list": user["card_list"].clone()
@@ -83,7 +83,7 @@ lazy_static! {
};
}
async fn home(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn home(Login(key): Login) -> impl Responder {
let mut user = userdata::get_acc_home(&key);
check_gifts(&mut user);
@@ -127,5 +127,5 @@ async fn home(req: HttpRequest, Login(key): Login) -> impl Responder {
//todo
user["home"]["beginner_mission_complete"] = 1.into();
global::api(&req, Some(user))
Api(Some(user))
}

8
src/router/items.rs
View File

@@ -1,8 +1,8 @@
use jzon::{array, object, JsonValue};
use rand::RngExt;
use actix_web::{web, HttpRequest, Responder, http::header::{HeaderMap, HeaderValue}};
use actix_web::{web, Responder, http::header::{HeaderMap, HeaderValue}};
use crate::router::{userdata, global, databases, Session};
use crate::router::{userdata, global, databases, Session, Api};
pub fn remove_gems(user: &mut JsonValue, amount: i64) {
let mut amount = amount;
@@ -556,7 +556,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/item/use", web::post().to(use_item_req));
}
async fn use_item_req(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn use_item_req(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
let item = &databases::ITEM_INFO[body["id"].to_string()];
@@ -583,7 +583,7 @@ async fn use_item_req(req: HttpRequest, Session { key, body }: Session) -> impl
}
}
global::api(&req, Some(object!{
Api(Some(object!{
item_list: [used],
stamina: user["stamina"].clone()
}))

34
src/router/live.rs
View File

@@ -3,7 +3,7 @@ use actix_web::{web, HttpRequest, Responder};
use rand::RngExt;
use lazy_static::lazy_static;
use crate::router::{databases, global, items, userdata, Login, Session};
use crate::router::{databases, global, items, userdata, Login, Session, Api};
use crate::router::clear_rate::live_completed;
use crate::router::tools::guest;
@@ -24,19 +24,19 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
}
async fn retire(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn retire(Session { key, body }: Session) -> impl Responder {
live_retire(&key, &body);
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);
}
global::api(&req, Some(object!{
Api(Some(object!{
"stamina": {},
"item_list": [],
"event_point_list": []
}))
}
async fn reward(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn reward(Session { key, body }: Session) -> impl Responder {
let user = userdata::get_acc(&key);
let live_id = body["master_live_id"].as_i64().unwrap();
let cleared = get_clear_count(live_id, &user) > 0;
@@ -65,7 +65,7 @@ async fn reward(req: HttpRequest, Session { key, body }: Session) -> impl Respon
}
}
global::api(&req, Some(object!{
Api(Some(object!{
"ensured_list": ensured_list,
"random_list": random_list
}))
@@ -80,7 +80,7 @@ fn random_number(lowest: usize, highest: usize) -> usize {
rand::rng().random_range(lowest..highest + 1)
}
async fn guest(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn guest(Login(key): Login) -> impl Responder {
let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
let friends = userdata::get_acc_friends(&key);
let user = userdata::get_acc(&key);
@@ -203,14 +203,14 @@ async fn guest(req: HttpRequest, Login(key): Login) -> impl Responder {
}
}
global::api(&req, Some(object!{
Api(Some(object!{
"guest_list": guest_list
}))
}
async fn mission(req: HttpRequest) -> impl Responder {
async fn mission() -> impl Responder {
//todo
global::api(&req, Some(object!{
Api(Some(object!{
"score_ranking": "",
"combo_ranking": "",
"clear_count_ranking": ""
@@ -278,24 +278,24 @@ fn start_live(login_token: &str, body: &JsonValue) {
userdata::save_server_data(login_token, server_data);
}
async fn start(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn start(Session { key, body }: Session) -> impl Responder {
start_live(&key, &body);
global::api(&req, Some(array![]))
Api(Some(array![]))
}
pub async fn event_start(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
pub async fn event_start(Session { key, body }: Session) -> impl Responder {
start_live(&key, &body);
global::api(&req, Some(array![]))
Api(Some(array![]))
}
async fn continuee(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn continuee(Login(key): Login) -> impl Responder {
let mut user = userdata::get_acc(&key);
items::remove_gems(&mut user, 100);
userdata::save_acc(&key, user.clone());
global::api(&req, Some(object!{
Api(Some(object!{
gem: user["gem"].clone()
}))
}
@@ -742,11 +742,11 @@ pub fn live_end(req: &HttpRequest, key: &str, body: &JsonValue, skipped: bool) -
}
async fn end(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
global::api(&req, Some(live_end(&req, &key, &body, false)))
Api(Some(live_end(&req, &key, &body, false)))
}
async fn skip(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
global::api(&req, Some(live_end(&req, &key, &body, true)))
Api(Some(live_end(&req, &key, &body, true)))
}
#[cfg(test)]

8
src/router/location.rs
View File

@@ -1,14 +1,14 @@
use jzon::object;
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::global;
use crate::router::Api;
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/location", web::get().to(location));
}
async fn location(req: HttpRequest) -> impl Responder {
global::api(&req, Some(object!{
async fn location() -> impl Responder {
Api(Some(object!{
"master_location_ids": []
}))
}

16
src/router/login.rs
View File

@@ -1,7 +1,7 @@
use jzon::{object, array, JsonValue};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{global, userdata, items, databases, Login};
use crate::router::{global, userdata, items, databases, Login, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/dummy/login", web::post().to(dummy));
@@ -9,10 +9,10 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/login_bonus/event", web::post().to(bonus_event));
}
async fn dummy(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn dummy(Login(key): Login) -> impl Responder {
let user = userdata::get_acc(&key);
global::api(&req, Some(object!{
Api(Some(object!{
"user_id": user["user"]["id"].clone()
}))
}
@@ -52,7 +52,7 @@ fn do_bonus(user_home: &mut JsonValue, bonuses: &mut JsonValue) -> JsonValue {
to_send
}
async fn bonus(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn bonus(Login(key): Login) -> impl Responder {
let mut user_home = userdata::get_acc_home(&key);
let mut user_missions = userdata::get_acc_missions(&key);
@@ -71,14 +71,14 @@ async fn bonus(req: HttpRequest, Login(key): Login) -> impl Responder {
userdata::save_acc_loginbonus(&key, bonuses.clone());
userdata::save_acc_home(&key, user_home.clone());
global::api(&req, Some(object!{
Api(Some(object!{
"login_bonus_list": to_send,
"start_time": bonuses["start_time"].clone(),
"clear_mission_ids": cleared_missions
}))
}
async fn bonus_event(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn bonus_event(Login(key): Login) -> impl Responder {
let mut user_home = userdata::get_acc_home(&key);
let mut bonuses = userdata::get_acc_eventlogin(&key);
@@ -90,7 +90,7 @@ async fn bonus_event(req: HttpRequest, Login(key): Login) -> impl Responder {
userdata::save_acc_eventlogin(&key, bonuses.clone());
userdata::save_acc_home(&key, user_home.clone());
global::api(&req, Some(object!{
Api(Some(object!{
"login_bonus_list": to_send,
"start_time": bonuses["start_time"].clone(),
"clear_mission_ids": []

16
src/router/lottery.rs
View File

@@ -1,8 +1,8 @@
use jzon::{array, object, JsonValue};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use rand::RngExt;
use crate::router::{global, userdata, items, databases, Body, Login, Session};
use crate::router::{global, userdata, items, databases, Body, Login, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(
@@ -12,7 +12,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
);
}
async fn tutorial(req: HttpRequest, Body(body): Body) -> impl Responder {
async fn tutorial(Body(body): Body) -> impl Responder {
let id = body["master_character_id"].to_string();
let user = &id[id.len() - 2..].parse::<i32>().unwrap();
@@ -26,7 +26,7 @@ async fn tutorial(req: HttpRequest, Body(body): Body) -> impl Responder {
}
lotteryid += user;
global::api(&req, Some(object!{
Api(Some(object!{
"lottery_list": [
{
"master_lottery_id": lotteryid,
@@ -187,14 +187,14 @@ fn get_lottery_list(user: &JsonValue) -> JsonValue {
rv
}
async fn lottery(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn lottery(Login(key): Login) -> impl Responder {
let user = userdata::get_acc(&key);
global::api(&req, Some(object!{
Api(Some(object!{
"lottery_list": get_lottery_list(&user)
}))
}
async fn lottery_post(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn lottery_post(Session { key, body }: Session) -> impl Responder {
//println!("lottery: {}", body);
let mut user = userdata::get_acc(&key);
let user2 = userdata::get_acc(&key);
@@ -290,7 +290,7 @@ async fn lottery_post(req: HttpRequest, Session { key, body }: Session) -> impl
userdata::save_acc_chats(&key, chats);
userdata::save_acc_missions(&key, missions);
global::api(&req, Some(object!{
Api(Some(object!{
"lottery_item_list": lottery_list,
"updated_value_list": {
"card_list": new_cards,

14
src/router/mission.rs
View File

@@ -1,7 +1,7 @@
use jzon::{array, object, JsonValue};
use actix_web::{web, HttpRequest, Responder};
use crate::router::{global, userdata, items, databases, Login, Session};
use crate::router::{global, userdata, items, databases, Login, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(
@@ -14,12 +14,12 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
const VARIABLE_MISSIONS: [[i64; 2]; 5] = [[1153001, 1153019], [1105001, 1105017], [1101001, 1101030], [1121001, 1121019], [1112001, 1112033]];
async fn mission(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn mission(Login(key): Login) -> impl Responder {
let user = userdata::get_acc(&key);
let step = user["tutorial_step"].as_i64().unwrap_or(0);
if (1..130).contains(&step) {
return global::api(&req, Some(object!{
return Api(Some(object!{
"mission_list": array![]
}));
}
@@ -29,12 +29,12 @@ async fn mission(req: HttpRequest, Login(key): Login) -> impl Responder {
userdata::save_acc_missions(&key, missions.clone());
}
global::api(&req, Some(object!{
Api(Some(object!{
"mission_list": missions
}))
}
async fn clear(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn clear(Session { key, body }: Session) -> impl Responder {
let mut missions = userdata::get_acc_missions(&key);
let mut cleared = array![];
@@ -49,7 +49,7 @@ async fn clear(req: HttpRequest, Session { key, body }: Session) -> impl Respond
userdata::save_acc_missions(&key, missions);
global::api(&req, Some(object!{
Api(Some(object!{
"clear_mission_ids": cleared
}))
}
@@ -175,7 +175,7 @@ async fn receive(req: HttpRequest, Session { key, body }: Session) -> impl Respo
updated_value_list["point_list"] = point_list;
}
global::api(&req, Some(object!{
Api(Some(object!{
"reward_list": rewards,
"gift_list": array![],
"updated_value_list": updated_value_list,

12
src/router/notice.rs
View File

@@ -1,19 +1,19 @@
use jzon::{object, array};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::global;
use crate::router::Api;
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(web::resource("/notice/reward").route(web::get().to(reward)).route(web::post().to(reward_post)));
}
//todo
async fn reward(req: HttpRequest) -> impl Responder {
global::api(&req, Some(object!{
async fn reward() -> impl Responder {
Api(Some(object!{
"reward_list": []
}))
}
async fn reward_post(req: HttpRequest) -> impl Responder {
global::api(&req, Some(array![]))
async fn reward_post() -> impl Responder {
Api(Some(array![]))
}

8
src/router/purchase.rs
View File

@@ -1,14 +1,14 @@
use jzon::object;
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::global;
use crate::router::Api;
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/purchase", web::get().to(purchase));
}
async fn purchase(req: HttpRequest) -> impl Responder {
global::api(&req, Some(object!{
async fn purchase() -> impl Responder {
Api(Some(object!{
"product_list": [//Client will error if this is an empty array
{
"product_id": "com.bushiroad.global.lovelive.sif2.google.promo.4199",

14
src/router/serial_code.rs
View File

@@ -1,7 +1,7 @@
use jzon::{array, object};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{global, userdata, items, Session};
use crate::router::{userdata, items, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(
@@ -11,13 +11,13 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
);
}
async fn events(req: HttpRequest) -> impl Responder {
global::api(&req, Some(object!{
async fn events() -> impl Responder {
Api(Some(object!{
"serial_code_list": []
}))
}
async fn serial_code(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn serial_code(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc_home(&key);
let mut itemz = array![];
@@ -183,7 +183,7 @@ async fn serial_code(req: HttpRequest, Session { key, body }: Session) -> impl R
itemz.push(items::gift_item_basic(30010001, 500, 3, "Okay...............", &mut user)).unwrap();
itemz.push(items::gift_item_basic(15540001, 500, 3, "Okay...............", &mut user)).unwrap();
} else {
return global::api(&req, Some(object!{
return Api(Some(object!{
"result_code": 3
}));
}
@@ -192,7 +192,7 @@ async fn serial_code(req: HttpRequest, Session { key, body }: Session) -> impl R
userdata::save_acc_home(&key, user.clone());
}
global::api(&req, Some(object!{
Api(Some(object!{
"serial_code_event": {"id":1,"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,

12
src/router/shop.rs
View File

@@ -1,7 +1,7 @@
use jzon::{object};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{userdata, global, items, databases, Login, Session};
use crate::router::{userdata, items, databases, Login, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.service(
@@ -11,15 +11,15 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
);
}
async fn shop(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn shop(Login(key): Login) -> impl Responder {
let user = userdata::get_acc(&key);
global::api(&req, Some(object!{
Api(Some(object!{
"shop_list": user["shop_list"].clone()
}))
}
async fn buy(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn buy(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
let shop_item_id = body["master_shop_item_id"].as_i64().unwrap();
@@ -39,7 +39,7 @@ async fn buy(req: HttpRequest, Session { key, body }: Session) -> impl Responder
}
}
global::api(&req, Some(object!{
Api(Some(object!{
"gem": user["gem"].clone(),
"shop_list": [bought],
"gift_list": [],

8
src/router/story.rs
View File

@@ -1,13 +1,13 @@
use jzon::{object};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{global, userdata, databases, Session};
use crate::router::{userdata, databases, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/story/read", web::post().to(read));
}
async fn read(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn read(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
let part = body["master_story_part_id"].as_i64().unwrap();
let master_id = databases::STORY[part.to_string()]["masterStoryId"].as_i64().unwrap();
@@ -30,7 +30,7 @@ async fn read(req: HttpRequest, Session { key, body }: Session) -> impl Responde
userdata::save_acc(&key, user.clone());
global::api(&req, Some(object!{
Api(Some(object!{
"gift_list":[],
"updated_value_list":{
"story_list": user["story_list"].clone()

8
src/router/tutorial.rs
View File

@@ -1,13 +1,13 @@
use jzon::{array};
use actix_web::{web, HttpRequest, Responder};
use actix_web::{web, Responder};
use crate::router::{userdata, global, Session};
use crate::router::{userdata, global, Session, Api};
pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/tutorial", web::post().to(tutorial));
}
async fn tutorial(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn tutorial(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
if user["tutorial_step"].as_i32().unwrap() < 130 {
@@ -17,5 +17,5 @@ async fn tutorial(req: HttpRequest, Session { key, body }: Session) -> impl Resp
userdata::save_acc(&key, user);
}
global::api(&req, Some(array![]))
Api(Some(array![]))
}

74
src/router/user.rs
View File

@@ -2,7 +2,7 @@ use jzon::{array, object, JsonValue};
use actix_web::{web, HttpRequest, Responder};
use sha1::{Digest, Sha1};
use crate::router::{global, items, userdata, Body, Login, Session};
use crate::router::{global, items, userdata, Body, Login, Session, Api};
use crate::include_file;
use crate::router::tools::guest;
@@ -25,7 +25,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
cfg.route("/album/sif", web::get().to(sif));
}
async fn deck(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn deck(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
for (i, data) in user["deck_list"].clone().members().enumerate() {
@@ -46,7 +46,7 @@ async fn deck(req: HttpRequest, Session { key, body }: Session) -> impl Responde
}
userdata::save_acc(&key, user.clone());
global::api(&req, Some(object!{
Api(Some(object!{
"deck": {
"slot": body["slot"].clone(),
"leader_role": 0,
@@ -67,10 +67,10 @@ async fn user(req: HttpRequest, Login(key): Login) -> impl Responder {
}
}
global::api(&req, Some(user))
Api(Some(user))
}
pub async fn gift(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
pub async fn gift(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc_home(&key);
let mut userr = userdata::get_acc(&key);
@@ -113,7 +113,7 @@ pub async fn gift(req: HttpRequest, Session { key, body }: Session) -> impl Resp
userdata::save_acc(&key, userr.clone());
let userr = userdata::get_acc(&key);
global::api(&req, Some(object!{
Api(Some(object!{
"failed_gift_ids": failed,
"updated_value_list": {
"gem": userr["gem"].clone(),
@@ -126,7 +126,7 @@ pub async fn gift(req: HttpRequest, Session { key, body }: Session) -> impl Resp
}))
}
async fn user_post(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn user_post(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
@@ -167,13 +167,13 @@ async fn user_post(req: HttpRequest, Session { key, body }: Session) -> impl Res
userdata::save_acc(&key, user.clone());
global::api(&req, Some(object!{
Api(Some(object!{
"user": user["user"].clone(),
"clear_mission_ids": []
}))
}
pub async fn announcement(req: HttpRequest, Login(key): Login) -> impl Responder {
pub async fn announcement(Login(key): Login) -> impl Responder {
let mut user = userdata::get_acc_home(&key);
@@ -181,67 +181,67 @@ pub async fn announcement(req: HttpRequest, Login(key): Login) -> impl Responder
userdata::save_acc_home(&key, user);
global::api(&req, Some(object!{
Api(Some(object!{
new_announcement_flag: 0
}))
}
async fn get_migration_code(req: HttpRequest, Body(body): Body) -> impl Responder {
async fn get_migration_code(Body(body): Body) -> impl Responder {
let Some(user_id) = body["user_id"].as_i64() else { return global::api(&req, None); };
let Some(user_id) = body["user_id"].as_i64() else { return Api(None); };
let code = userdata::user::migration::get_acc_token(user_id);
global::api(&req, Some(object!{
Api(Some(object!{
"migrationCode": code
}))
}
async fn register_password(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn register_password(Session { key, body }: Session) -> impl Responder {
let user = userdata::get_acc(&key);
userdata::user::migration::save_acc_transfer(user["user"]["id"].as_i64().unwrap(), &body["pass"].to_string());
global::api(&req, Some(array![]))
Api(Some(array![]))
}
async fn verify_migration_code(req: HttpRequest, Body(body): Body) -> impl Responder {
async fn verify_migration_code(Body(body): Body) -> impl Responder {
let user = userdata::user::migration::get_acc_transfer(&body["migrationCode"].to_string(), &body["pass"].to_string());
if !user["success"].as_bool().unwrap() || user["user_id"] == 0 {
return global::api(&req, None);
return Api(None);
}
let data_user = userdata::get_acc(&user["login_token"].to_string());
global::api(&req, Some(object!{
Api(Some(object!{
"user_id": user["user_id"].clone(),
"uuid": user["login_token"].to_string(),
"charge": data_user["gem"]["charge"].clone(),
"free": data_user["gem"]["free"].clone()
}))
}
async fn request_migration_code(req: HttpRequest, Body(body): Body) -> impl Responder {
async fn request_migration_code(Body(body): Body) -> impl Responder {
let user = userdata::user::migration::get_acc_transfer(&body["migrationCode"].to_string(), &body["pass"].to_string());
if !user["success"].as_bool().unwrap() || user["user_id"] == 0 {
return global::api(&req, None);
return Api(None);
}
global::api(&req, Some(object!{
Api(Some(object!{
"twxuid": user["login_token"].to_string()
}))
}
async fn migration(req: HttpRequest, Body(body): Body) -> impl Responder {
async fn migration(Body(body): Body) -> impl Responder {
let user = userdata::get_name_and_rank(body["user_id"].to_string().parse::<i64>().unwrap());
global::api(&req, Some(user))
Api(Some(user))
}
async fn detail(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn detail(Session { key, body }: Session) -> impl Responder {
let friends = userdata::get_acc_friends(&key);
let mut user_detail_list = array![];
@@ -250,12 +250,12 @@ async fn detail(req: HttpRequest, Session { key, body }: Session) -> impl Respon
let user = guest::get_user(uid, &friends, guest::UserView::Detail);
user_detail_list.push(user).unwrap();
}
global::api(&req, Some(object!{
Api(Some(object!{
user_detail_list: user_detail_list
}))
}
async fn sif(req: HttpRequest, Login(key): Login) -> impl Responder {
async fn sif(Login(key): Login) -> impl Responder {
let mut user = userdata::get_acc(&key);
let mut cards = userdata::get_acc_sif(&key);
@@ -268,13 +268,13 @@ async fn sif(req: HttpRequest, Login(key): Login) -> impl Responder {
userdata::save_acc(&key, user);
}
global::api(&req, Some(object!{
Api(Some(object!{
cards: cards
}))
}
async fn sifas_migrate(req: HttpRequest) -> impl Responder {
global::api(&req, Some(object!{
async fn sifas_migrate() -> impl Responder {
Api(Some(object!{
"ss_migrate_status": 1,
"user": null,
"gift_list": null,
@@ -324,13 +324,13 @@ fn clean_sif_data(current: &JsonValue) -> JsonValue {
rv
}
async fn sif_migrate(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn sif_migrate(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
let id = generate_passcode_sha1(body["sif_user_id"].to_string(), body["password"].to_string());
let user_info = npps4_req(id).await;
if user_info.is_none() {
return global::api(&req, Some(object!{
return Api(Some(object!{
sif_migrate_status: 38
}));
}
@@ -345,7 +345,7 @@ async fn sif_migrate(req: HttpRequest, Session { key, body }: Session) -> impl R
userdata::save_acc_sif(&key, clean_sif_data(&user_info["units"]));
userdata::save_acc(&key, user.clone());
global::api(&req, Some(object!{
Api(Some(object!{
"sif_migrate_status": 0,
"user": user["user"].clone(),
"master_title_ids": user["master_title_ids"].clone()
@@ -353,15 +353,15 @@ async fn sif_migrate(req: HttpRequest, Session { key, body }: Session) -> impl R
}
async fn getregisteredplatformlist(req: HttpRequest) -> impl Responder {
global::api(&req, Some(object!{
async fn getregisteredplatformlist() -> impl Responder {
Api(Some(object!{
"google": 0,
"apple": 0,
"twitter": 0
}))
}
async fn initialize(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
async fn initialize(Session { key, body }: Session) -> impl Responder {
let mut user = userdata::get_acc(&key);
let mut user2 = userdata::get_acc_home(&key);
@@ -399,7 +399,7 @@ async fn initialize(req: HttpRequest, Session { key, body }: Session) -> impl Re
cardstoreward = array![40010001, 40020001, 40030001, 40040001, 40050001, 40060001, 40070001, 40080001, 40090001]; //liella
masterid += 9 + 9 + 12; //nijigasaki
} else {
return global::api(&req, None);
return Api(None);
}
masterid += userr;
@@ -440,5 +440,5 @@ async fn initialize(req: HttpRequest, Session { key, body }: Session) -> impl Re
userdata::save_acc_home(&key, user2);
userdata::save_acc_missions(&key, missions);
global::api(&req, Some(user["user"].clone()))
Api(Some(user["user"].clone()))
}