1334 lines
44 KiB
Go
1334 lines
44 KiB
Go
package handler
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"honoka-chan/config"
|
|
"honoka-chan/database"
|
|
"honoka-chan/encrypt"
|
|
"honoka-chan/model"
|
|
"honoka-chan/utils"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/tidwall/gjson"
|
|
"github.com/tidwall/sjson"
|
|
)
|
|
|
|
func AsLogin(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
|
|
var mask string
|
|
req := gjson.Parse(reqBody)
|
|
req.ForEach(func(key, value gjson.Result) bool {
|
|
if value.Get("mask").String() != "" {
|
|
mask = value.Get("mask").String()
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
// fmt.Println("Request data:", req.String())
|
|
// fmt.Println("Mask:", mask)
|
|
|
|
mask64, err := base64.StdEncoding.DecodeString(mask)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
randomBytes := encrypt.RSA_DecryptOAEP(mask64)
|
|
// fmt.Println("Random Bytes:", randomBytes)
|
|
|
|
newKey := utils.SliceXor(randomBytes, []byte(sessionKey))
|
|
newKey64 := base64.StdEncoding.EncodeToString(newKey)
|
|
|
|
loginBody := GetUserData("login.json")
|
|
loginBody, _ = sjson.Set(loginBody, "session_key", newKey64)
|
|
loginBody, _ = sjson.Set(loginBody, "user_model.user_status", GetUserStatus())
|
|
|
|
/* ======== UserData ======== */
|
|
liveDeckData := gjson.Parse(GetUserData("liveDeck.json"))
|
|
loginBody, _ = sjson.Set(loginBody, "user_model.user_live_deck_by_id", liveDeckData.Get("user_live_deck_by_id").Value())
|
|
|
|
var liveParty []any
|
|
decoder := json.NewDecoder(strings.NewReader(liveDeckData.Get("user_live_party_by_id").String()))
|
|
decoder.UseNumber()
|
|
err = decoder.Decode(&liveParty)
|
|
CheckErr(err)
|
|
// fmt.Println(liveParty)
|
|
loginBody, _ = sjson.Set(loginBody, "user_model.user_live_party_by_id", liveParty)
|
|
|
|
memberData := gjson.Parse(GetUserData("memberSettings.json"))
|
|
loginBody, _ = sjson.Set(loginBody, "user_model.user_member_by_member_id", memberData.Get("user_member_by_member_id").Value())
|
|
|
|
lessonData := gjson.Parse(GetUserData("lessonDeck.json"))
|
|
loginBody, _ = sjson.Set(loginBody, "user_model.user_lesson_deck_by_id", lessonData.Get("user_lesson_deck_by_id").Value())
|
|
|
|
cardData := gjson.Parse(GetUserData("userCard.json"))
|
|
loginBody, _ = sjson.Set(loginBody, "user_model.user_card_by_card_id", cardData.Get("user_card_by_card_id").Value())
|
|
/* ======== UserData ======== */
|
|
|
|
resp := SignResp(ctx.GetString("ep"), loginBody, config.StartUpKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchBootstrap(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("fetchBootstrap.json"),
|
|
"user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchBillingHistory(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("fetchBillingHistory.json"),
|
|
"user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchNotice(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("fetchNotice.json"),
|
|
"user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsGetPackUrl(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
// fmt.Println(reqBody)
|
|
|
|
var packNames []string
|
|
gjson.Parse(reqBody).ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() {
|
|
if err := json.Unmarshal([]byte(value.Get("pack_names").String()), &packNames); err != nil {
|
|
panic(err)
|
|
}
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
var packUrls []string
|
|
for _, pack := range packNames {
|
|
packUrls = append(packUrls, AsCdnServer+"/"+config.MasterVersion+"/"+pack)
|
|
}
|
|
|
|
packBody, _ := sjson.Set("{}", "url_list", packUrls)
|
|
resp := SignResp(ctx.GetString("ep"), packBody, sessionKey)
|
|
// fmt.Println("Response:", resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsUpdateCardNewFlag(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("updateCardNewFlag.json"),
|
|
"user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsGetClearedPlatformAchievement(ctx *gin.Context) {
|
|
signBody := GetUserData("getClearedPlatformAchievement.json")
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchLiveMusicSelect(ctx *gin.Context) {
|
|
now := time.Now()
|
|
year, month, day := now.Year(), now.Month(), now.Day()
|
|
tomorrow := time.Date(year, month, day+1, 0, 0, 0, 0, now.Location()).Unix()
|
|
weekday := int(now.Weekday())
|
|
if weekday == 0 {
|
|
weekday = 7
|
|
}
|
|
|
|
liveDailyList := []model.LiveDaily{}
|
|
err := MainEng.Table("m_live_daily").Where("weekday = ?", weekday).Cols("id,live_id").Find(&liveDailyList)
|
|
CheckErr(err)
|
|
for k := range liveDailyList {
|
|
liveDailyList[k].EndAt = int(tomorrow)
|
|
liveDailyList[k].RemainingPlayCount = 5
|
|
liveDailyList[k].RemainingRecoveryCount = 9
|
|
}
|
|
|
|
signBody := GetUserData("fetchLiveMusicSelect.json")
|
|
signBody, _ = sjson.Set(signBody, "weekday_state.weekday", weekday)
|
|
signBody, _ = sjson.Set(signBody, "weekday_state.next_weekday_at", tomorrow)
|
|
signBody, _ = sjson.Set(signBody, "live_daily_list", liveDailyList)
|
|
signBody, _ = sjson.Set(signBody, "user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsLiveMvStart(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("liveMvStart.json"),
|
|
"user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsLiveMvSaveDeck(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
// fmt.Println(reqBody)
|
|
|
|
reqData := gjson.Parse(reqBody).Array()[0]
|
|
// fmt.Println(reqData)
|
|
|
|
saveReq := model.LiveSaveDeckReq{}
|
|
err := json.Unmarshal([]byte(reqData.String()), &saveReq)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
// fmt.Println(saveReq)
|
|
|
|
userLiveMvDeckInfo := model.UserLiveMvDeckInfo{
|
|
LiveMasterID: saveReq.LiveMasterID,
|
|
}
|
|
|
|
memberIds := map[int]int{}
|
|
for k, v := range saveReq.MemberMasterIDByPos {
|
|
if k%2 == 0 {
|
|
memberId := saveReq.MemberMasterIDByPos[k+1]
|
|
memberIds[v] = memberId
|
|
|
|
switch v {
|
|
case 1:
|
|
userLiveMvDeckInfo.MemberMasterID1 = memberId
|
|
case 2:
|
|
userLiveMvDeckInfo.MemberMasterID2 = memberId
|
|
case 3:
|
|
userLiveMvDeckInfo.MemberMasterID3 = memberId
|
|
case 4:
|
|
userLiveMvDeckInfo.MemberMasterID4 = memberId
|
|
case 5:
|
|
userLiveMvDeckInfo.MemberMasterID5 = memberId
|
|
case 6:
|
|
userLiveMvDeckInfo.MemberMasterID6 = memberId
|
|
case 7:
|
|
userLiveMvDeckInfo.MemberMasterID7 = memberId
|
|
case 8:
|
|
userLiveMvDeckInfo.MemberMasterID8 = memberId
|
|
case 9:
|
|
userLiveMvDeckInfo.MemberMasterID9 = memberId
|
|
case 10:
|
|
userLiveMvDeckInfo.MemberMasterID10 = memberId
|
|
case 11:
|
|
userLiveMvDeckInfo.MemberMasterID11 = memberId
|
|
case 12:
|
|
userLiveMvDeckInfo.MemberMasterID12 = memberId
|
|
}
|
|
}
|
|
}
|
|
// fmt.Println(memberIds)
|
|
|
|
suitIds := map[int]int{}
|
|
for k, v := range saveReq.SuitMasterIDByPos {
|
|
if k%2 == 0 {
|
|
suitId := saveReq.SuitMasterIDByPos[k+1]
|
|
suitIds[v] = suitId
|
|
|
|
switch v {
|
|
case 1:
|
|
userLiveMvDeckInfo.SuitMasterID1 = suitId
|
|
case 2:
|
|
userLiveMvDeckInfo.SuitMasterID2 = suitId
|
|
case 3:
|
|
userLiveMvDeckInfo.SuitMasterID3 = suitId
|
|
case 4:
|
|
userLiveMvDeckInfo.SuitMasterID4 = suitId
|
|
case 5:
|
|
userLiveMvDeckInfo.SuitMasterID5 = suitId
|
|
case 6:
|
|
userLiveMvDeckInfo.SuitMasterID6 = suitId
|
|
case 7:
|
|
userLiveMvDeckInfo.SuitMasterID7 = suitId
|
|
case 8:
|
|
userLiveMvDeckInfo.SuitMasterID8 = suitId
|
|
case 9:
|
|
userLiveMvDeckInfo.SuitMasterID9 = suitId
|
|
case 10:
|
|
userLiveMvDeckInfo.SuitMasterID10 = suitId
|
|
case 11:
|
|
userLiveMvDeckInfo.SuitMasterID11 = suitId
|
|
case 12:
|
|
userLiveMvDeckInfo.SuitMasterID12 = suitId
|
|
}
|
|
}
|
|
}
|
|
// fmt.Println(suitIds)
|
|
|
|
var userLiveMvDeckCustomByID []any
|
|
userLiveMvDeckCustomByID = append(userLiveMvDeckCustomByID, saveReq.LiveMasterID)
|
|
userLiveMvDeckCustomByID = append(userLiveMvDeckCustomByID, userLiveMvDeckInfo)
|
|
// fmt.Println(userLiveMvDeckCustomByID)
|
|
|
|
signBody := GetUserData("liveMvSaveDeck.json")
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_live_mv_deck_custom_by_id", userLiveMvDeckCustomByID)
|
|
|
|
resp := SignResp(ctx.GetString("ep"), string(signBody), sessionKey)
|
|
// fmt.Println(resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchCommunicationMemberDetail(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
var memberId int64
|
|
gjson.Parse(reqBody).ForEach(func(key, value gjson.Result) bool {
|
|
if value.Get("member_id").String() != "" {
|
|
memberId = value.Get("member_id").Int()
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
lovePanelCellIds := []int{}
|
|
err := MainEng.Table("m_member_love_panel_cell").
|
|
Join("LEFT", "m_member_love_panel", "m_member_love_panel_cell.member_love_panel_master_id = m_member_love_panel.id").
|
|
Cols("m_member_love_panel_cell.id").Where("m_member_love_panel.member_master_id = ?", memberId).
|
|
OrderBy("m_member_love_panel_cell.id ASC").Find(&lovePanelCellIds)
|
|
CheckErr(err)
|
|
|
|
now := time.Now()
|
|
year, month, day := now.Year(), now.Month(), now.Day()
|
|
tomorrow := time.Date(year, month, day+1, 0, 0, 0, 0, now.Location()).Unix()
|
|
weekday := int(now.Weekday())
|
|
if weekday == 0 {
|
|
weekday = 7
|
|
}
|
|
|
|
signBody := GetUserData("fetchCommunicationMemberDetail.json")
|
|
signBody, _ = sjson.Set(signBody, "member_love_panels.0.member_id", memberId)
|
|
signBody, _ = sjson.Set(signBody, "member_love_panels.0.member_love_panel_cell_ids", lovePanelCellIds)
|
|
signBody, _ = sjson.Set(signBody, "weekday_state.weekday", weekday)
|
|
signBody, _ = sjson.Set(signBody, "weekday_state.next_weekday_at", tomorrow)
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsTapLovePoint(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("tapLovePoint.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsUpdateUserCommunicationMemberDetailBadge(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
var memberMasterId int64
|
|
gjson.Parse(reqBody).ForEach(func(key, value gjson.Result) bool {
|
|
if value.Get("member_master_id").String() != "" {
|
|
memberMasterId = value.Get("member_master_id").Int()
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
userDetail := []any{}
|
|
userDetail = append(userDetail, memberMasterId)
|
|
userDetail = append(userDetail, model.UserCommunicationMemberDetailBadgeByID{
|
|
MemberMasterID: int(memberMasterId),
|
|
})
|
|
|
|
signBody := GetUserData("updateUserCommunicationMemberDetailBadge.json")
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_communication_member_detail_badge_by_id", userDetail)
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsUpdateUserLiveDifficultyNewFlag(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("updateUserLiveDifficultyNewFlag.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFinishUserStorySide(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("finishUserStorySide.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFinishUserStoryMember(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("finishUserStoryMember.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSetTheme(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
// fmt.Println(reqBody)
|
|
|
|
var memberMasterId, suitMasterId, backgroundMasterId int64
|
|
gjson.Parse(reqBody).ForEach(func(key, value gjson.Result) bool {
|
|
if value.Get("member_master_id").String() != "" {
|
|
memberMasterId = value.Get("member_master_id").Int()
|
|
suitMasterId = value.Get("suit_master_id").Int()
|
|
backgroundMasterId = value.Get("custom_background_master_id").Int()
|
|
|
|
gjson.Parse(GetUserData("memberSettings.json")).Get("user_member_by_member_id").
|
|
ForEach(func(kk, vv gjson.Result) bool {
|
|
if vv.IsObject() {
|
|
if vv.Get("member_master_id").Int() == memberMasterId {
|
|
SetUserData("memberSettings.json", "user_member_by_member_id."+
|
|
kk.String()+".custom_background_master_id", backgroundMasterId)
|
|
SetUserData("memberSettings.json", "user_member_by_member_id."+
|
|
kk.String()+".suit_master_id", suitMasterId)
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
userMemberRes := []any{}
|
|
userMemberRes = append(userMemberRes, memberMasterId)
|
|
userMemberRes = append(userMemberRes, model.UserMemberInfo{
|
|
MemberMasterID: int(memberMasterId),
|
|
CustomBackgroundMasterID: int(backgroundMasterId),
|
|
SuitMasterID: int(suitMasterId),
|
|
LovePoint: 10271130,
|
|
LovePointLimit: 10271130,
|
|
LoveLevel: 450,
|
|
ViewStatus: 1,
|
|
IsNew: false,
|
|
})
|
|
|
|
userSuitRes := []any{}
|
|
userSuitRes = append(userSuitRes, suitMasterId)
|
|
userSuitRes = append(userSuitRes, model.AsSuitInfo{
|
|
SuitMasterID: int(suitMasterId),
|
|
IsNew: false,
|
|
})
|
|
|
|
signBody := GetUserData("setTheme.json")
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_member_by_member_id", userMemberRes)
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_suit_by_suit_id", userSuitRes)
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchProfile(ctx *gin.Context) {
|
|
userInfo := gjson.Parse(GetUserData("userStatus.json"))
|
|
signBody := GetUserData("fetchProfile.json")
|
|
signBody, _ = sjson.Set(signBody, "profile_info.basic_info.name.dot_under_text",
|
|
userInfo.Get("name.dot_under_text").String())
|
|
signBody, _ = sjson.Set(signBody, "profile_info.basic_info.introduction_message.dot_under_text",
|
|
userInfo.Get("message.dot_under_text").String())
|
|
signBody, _ = sjson.Set(signBody, "profile_info.basic_info.emblem_id",
|
|
userInfo.Get("emblem_id").Int())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSetProfile(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
// fmt.Println(reqBody)
|
|
|
|
req := gjson.Parse(reqBody).Array()[0]
|
|
if req.Get("name").String() != "" {
|
|
SetUserData("userStatus.json", "name.dot_under_text",
|
|
gjson.Parse(reqBody).Array()[0].Get("name").String())
|
|
} else if req.Get("nickname").String() != "" {
|
|
SetUserData("userStatus.json", "nickname.dot_under_text",
|
|
gjson.Parse(reqBody).Array()[0].Get("nickname").String())
|
|
} else if req.Get("message").String() != "" {
|
|
SetUserData("userStatus.json", "message.dot_under_text",
|
|
gjson.Parse(reqBody).Array()[0].Get("message").String())
|
|
}
|
|
|
|
signBody, _ := sjson.Set(GetUserData("setProfile.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchEmblem(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("fetchEmblem.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsActivateEmblem(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
|
|
var emblemId int64
|
|
gjson.Parse(reqBody).ForEach(func(key, value gjson.Result) bool {
|
|
if value.Get("emblem_master_id").String() != "" {
|
|
emblemId = value.Get("emblem_master_id").Int()
|
|
|
|
SetUserData("userStatus.json", "emblem_id", emblemId)
|
|
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
signBody := GetUserData("activateEmblem.json")
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status.emblem_id", emblemId)
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSaveUserNaviVoice(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("saveUserNaviVoice.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSaveDeckAll(ctx *gin.Context) {
|
|
reqBody := gjson.Parse(ctx.GetString("reqBody")).Array()[0]
|
|
// fmt.Println(reqBody.String())
|
|
|
|
req := model.AsSaveDeckReq{}
|
|
decoder := json.NewDecoder(strings.NewReader(reqBody.String()))
|
|
decoder.UseNumber()
|
|
err := decoder.Decode(&req)
|
|
CheckErr(err)
|
|
// fmt.Println("Raw:", req.SquadDict)
|
|
|
|
liveDeckInfo := GetUserData("liveDeck.json")
|
|
keyDeckName := fmt.Sprintf("user_live_deck_by_id.%d.name.dot_under_text", req.DeckID*2-1)
|
|
// fmt.Println(keyDeckName)
|
|
deckName := gjson.Parse(liveDeckInfo).Get(keyDeckName).String()
|
|
// fmt.Println("deckName:", deckName)
|
|
|
|
if req.CardWithSuit[1] == 0 {
|
|
req.CardWithSuit[1] = req.CardWithSuit[0]
|
|
}
|
|
if req.CardWithSuit[3] == 0 {
|
|
req.CardWithSuit[3] = req.CardWithSuit[2]
|
|
}
|
|
if req.CardWithSuit[5] == 0 {
|
|
req.CardWithSuit[5] = req.CardWithSuit[4]
|
|
}
|
|
if req.CardWithSuit[7] == 0 {
|
|
req.CardWithSuit[7] = req.CardWithSuit[6]
|
|
}
|
|
if req.CardWithSuit[9] == 0 {
|
|
req.CardWithSuit[9] = req.CardWithSuit[8]
|
|
}
|
|
if req.CardWithSuit[11] == 0 {
|
|
req.CardWithSuit[11] = req.CardWithSuit[10]
|
|
}
|
|
if req.CardWithSuit[13] == 0 {
|
|
req.CardWithSuit[13] = req.CardWithSuit[12]
|
|
}
|
|
if req.CardWithSuit[15] == 0 {
|
|
req.CardWithSuit[15] = req.CardWithSuit[14]
|
|
}
|
|
if req.CardWithSuit[17] == 0 {
|
|
req.CardWithSuit[17] = req.CardWithSuit[16]
|
|
}
|
|
|
|
deckInfo := model.AsDeckInfo{
|
|
UserLiveDeckID: req.DeckID,
|
|
Name: model.AsDeckName{
|
|
DotUnderText: deckName,
|
|
},
|
|
CardMasterID1: req.CardWithSuit[0],
|
|
CardMasterID2: req.CardWithSuit[2],
|
|
CardMasterID3: req.CardWithSuit[4],
|
|
CardMasterID4: req.CardWithSuit[6],
|
|
CardMasterID5: req.CardWithSuit[8],
|
|
CardMasterID6: req.CardWithSuit[10],
|
|
CardMasterID7: req.CardWithSuit[12],
|
|
CardMasterID8: req.CardWithSuit[14],
|
|
CardMasterID9: req.CardWithSuit[16],
|
|
SuitMasterID1: req.CardWithSuit[1],
|
|
SuitMasterID2: req.CardWithSuit[3],
|
|
SuitMasterID3: req.CardWithSuit[5],
|
|
SuitMasterID4: req.CardWithSuit[7],
|
|
SuitMasterID5: req.CardWithSuit[9],
|
|
SuitMasterID6: req.CardWithSuit[11],
|
|
SuitMasterID7: req.CardWithSuit[13],
|
|
SuitMasterID8: req.CardWithSuit[15],
|
|
SuitMasterID9: req.CardWithSuit[17],
|
|
}
|
|
// fmt.Println(deckInfo)
|
|
|
|
keyLiveDeck := fmt.Sprintf("user_live_deck_by_id.%d", req.DeckID*2-1)
|
|
SetUserData("liveDeck.json", keyLiveDeck, deckInfo)
|
|
|
|
deckInfoRes := []model.AsResp{}
|
|
deckInfoRes = append(deckInfoRes, req.DeckID)
|
|
deckInfoRes = append(deckInfoRes, deckInfo)
|
|
|
|
partyInfoRes := []model.AsResp{}
|
|
for k, v := range req.SquadDict {
|
|
if k%2 == 0 {
|
|
partyId, err := v.(json.Number).Int64()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
// fmt.Println("Party ID:", partyId)
|
|
|
|
rDictInfo, err := json.Marshal(req.SquadDict[k+1])
|
|
CheckErr(err)
|
|
|
|
dictInfo := model.AsDeckSquadDict{}
|
|
decoder := json.NewDecoder(bytes.NewReader(rDictInfo))
|
|
decoder.UseNumber()
|
|
err = decoder.Decode(&dictInfo)
|
|
CheckErr(err)
|
|
// fmt.Println("Party Info:", dictInfo)
|
|
|
|
roleIds := []int{}
|
|
err = MainEng.Table("m_card").
|
|
Where("id IN (?,?,?)", dictInfo.CardMasterIds[0], dictInfo.CardMasterIds[1], dictInfo.CardMasterIds[2]).
|
|
Cols("role").Find(&roleIds)
|
|
CheckErr(err)
|
|
// fmt.Println("roleIds:", roleIds)
|
|
|
|
partyIcon, partyName := GetPartyInfoByRoleIds(roleIds)
|
|
realPartyName := GetRealPartyName(partyName)
|
|
partyInfo := model.AsPartyInfo{
|
|
PartyID: int(partyId),
|
|
UserLiveDeckID: req.DeckID,
|
|
Name: model.AsPartyName{
|
|
DotUnderText: realPartyName,
|
|
},
|
|
IconMasterID: partyIcon,
|
|
CardMasterID1: dictInfo.CardMasterIds[0],
|
|
CardMasterID2: dictInfo.CardMasterIds[1],
|
|
CardMasterID3: dictInfo.CardMasterIds[2],
|
|
UserAccessoryID1: dictInfo.UserAccessoryIds[0],
|
|
UserAccessoryID2: dictInfo.UserAccessoryIds[1],
|
|
UserAccessoryID3: dictInfo.UserAccessoryIds[2],
|
|
}
|
|
// fmt.Println(partyInfo)
|
|
|
|
gjson.Parse(liveDeckInfo).Get("user_live_party_by_id").ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() && value.Get("party_id").Int() == partyId {
|
|
SetUserData("liveDeck.json", "user_live_party_by_id."+key.String(), partyInfo)
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
partyInfoRes = append(partyInfoRes, partyId)
|
|
partyInfoRes = append(partyInfoRes, partyInfo)
|
|
}
|
|
}
|
|
|
|
respBody := GetUserData("saveDeckAll.json")
|
|
respBody, _ = sjson.Set(respBody, "user_model.user_status", GetUserStatus())
|
|
respBody, _ = sjson.Set(respBody, "user_model.user_live_deck_by_id", deckInfoRes)
|
|
respBody, _ = sjson.Set(respBody, "user_model.user_live_party_by_id", partyInfoRes)
|
|
resp := SignResp(ctx.GetString("ep"), respBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchLivePartners(ctx *gin.Context) {
|
|
signBody := GetUserData("fetchLivePartners.json")
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchLiveDeckSelect(ctx *gin.Context) {
|
|
signBody := GetUserData("fetchLiveDeckSelect.json")
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsLiveStart(ctx *gin.Context) {
|
|
reqBody := gjson.Parse(ctx.GetString("reqBody")).Array()[0]
|
|
// fmt.Println(reqBody.String())
|
|
|
|
liveStartReq := model.AsLiveStartReq{}
|
|
if err := json.Unmarshal([]byte(reqBody.String()), &liveStartReq); err != nil {
|
|
panic(err)
|
|
}
|
|
// fmt.Println(liveStartReq)
|
|
|
|
var cardInfo string
|
|
partnerResp := gjson.Parse(GetUserData("fetchLivePartners.json")).Get("partner_select_state.live_partners")
|
|
partnerResp.ForEach(func(k, v gjson.Result) bool {
|
|
userId := v.Get("user_id").Int()
|
|
if userId == int64(liveStartReq.PartnerUserID) {
|
|
v.Get("card_by_category").ForEach(func(kk, vv gjson.Result) bool {
|
|
if vv.IsObject() {
|
|
cardId := vv.Get("card_master_id").Int()
|
|
if cardId == int64(liveStartReq.PartnerCardMasterID) {
|
|
cardInfo = vv.String()
|
|
// fmt.Println(cardInfo)
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
// 保存请求包因为 /live/finish 接口的响应包里有部分字段不在该接口的请求包里
|
|
liveId := time.Now().UnixNano()
|
|
liveIdStr := strconv.Itoa(int(liveId))
|
|
err := database.LevelDb.Put([]byte("live_"+liveIdStr), []byte(reqBody.String()))
|
|
CheckErr(err)
|
|
|
|
liveDifficultyId := strconv.Itoa(liveStartReq.LiveDifficultyID)
|
|
liveNotes := utils.ReadAllText("assets/as/notes/" + liveDifficultyId + ".json")
|
|
if liveNotes == "" {
|
|
panic("歌曲情报信息不存在！")
|
|
}
|
|
|
|
var liveNotesRes model.AsLiveStageInfo
|
|
if err := json.Unmarshal([]byte(liveNotes), &liveNotesRes); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if liveStartReq.IsAutoPlay {
|
|
for k := range liveNotesRes.LiveNotes {
|
|
liveNotesRes.LiveNotes[k].AutoJudgeType = 30
|
|
}
|
|
}
|
|
|
|
var partnerInfo any
|
|
if cardInfo != "" {
|
|
var info map[string]any
|
|
if err = json.Unmarshal([]byte(cardInfo), &info); err != nil {
|
|
panic(err)
|
|
}
|
|
partnerInfo = info
|
|
} else {
|
|
partnerInfo = nil
|
|
}
|
|
|
|
liveStartResp := GetUserData("liveStart.json")
|
|
liveStartResp, _ = sjson.Set(liveStartResp, "live.live_id", liveId)
|
|
liveStartResp, _ = sjson.Set(liveStartResp, "live.deck_id", liveStartReq.DeckID)
|
|
liveStartResp, _ = sjson.Set(liveStartResp, "live.live_stage", liveNotesRes)
|
|
liveStartResp, _ = sjson.Set(liveStartResp, "live.live_partner_card", partnerInfo)
|
|
liveStartResp, _ = sjson.Set(liveStartResp, "user_model_diff.user_status", GetUserStatus())
|
|
liveStartResp, _ = sjson.Set(liveStartResp, "user_model_diff.user_status.latest_live_deck_id", liveStartReq.DeckID)
|
|
liveStartResp, _ = sjson.Set(liveStartResp, "user_model_diff.user_status.last_live_difficulty_id", liveStartReq.LiveDifficultyID)
|
|
resp := SignResp(ctx.GetString("ep"), liveStartResp, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsLiveFinish(ctx *gin.Context) {
|
|
reqBody := gjson.Parse(ctx.GetString("reqBody")).Array()[0]
|
|
// fmt.Println(reqBody.String())
|
|
|
|
var cardMasterId, maxVolt, skillCount, appealCount int64
|
|
liveFinishReq := gjson.Parse(reqBody.String())
|
|
liveFinishReq.Get("live_score.card_stat_dict").ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() {
|
|
volt := value.Get("got_voltage").Int()
|
|
if volt > maxVolt {
|
|
maxVolt = volt
|
|
|
|
cardMasterId = value.Get("card_master_id").Int()
|
|
skillCount = value.Get("skill_triggered_count").Int()
|
|
appealCount = value.Get("appeal_count").Int()
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
|
|
mvpInfo := model.AsMvpInfo{
|
|
CardMasterID: cardMasterId,
|
|
GetVoltage: maxVolt,
|
|
SkillTriggeredCount: skillCount,
|
|
AppealCount: appealCount,
|
|
}
|
|
|
|
liveId := liveFinishReq.Get("live_id").String()
|
|
res, err := database.LevelDb.Get([]byte("live_" + liveId))
|
|
CheckErr(err)
|
|
|
|
liveStartReq := model.AsLiveStartReq{}
|
|
if err := json.Unmarshal(res, &liveStartReq); err != nil {
|
|
panic(err)
|
|
}
|
|
// fmt.Println("liveStartReq:", liveStartReq)
|
|
|
|
var partnerInfo any
|
|
if liveStartReq.PartnerUserID != 0 {
|
|
info := model.AsLivePartnerInfo{
|
|
LastPlayedAt: time.Now().Unix(),
|
|
RecommendCardMasterID: liveStartReq.PartnerCardMasterID,
|
|
RecommendCardLevel: 1,
|
|
IsRecommendCardImageAwaken: true,
|
|
IsRecommendCardAllTrainingActivated: true,
|
|
IsNew: false,
|
|
FriendApprovedAt: nil,
|
|
RequestStatus: 3,
|
|
IsRequestPending: false,
|
|
}
|
|
partnerResp := gjson.Parse(GetUserData("fetchLivePartners.json")).Get("partner_select_state.live_partners")
|
|
partnerResp.ForEach(func(k, v gjson.Result) bool {
|
|
userId := v.Get("user_id").Int()
|
|
if userId == int64(liveStartReq.PartnerUserID) {
|
|
info.UserID = int(userId)
|
|
info.Name.DotUnderText = v.Get("name.dot_under_text").String()
|
|
info.Rank = int(v.Get("rank").Int())
|
|
info.EmblemID = int(v.Get("emblem_id").Int())
|
|
info.IntroductionMessage.DotUnderText = v.Get("introduction_message.dot_under_text").String()
|
|
}
|
|
return true
|
|
})
|
|
partnerInfo = info
|
|
} else {
|
|
partnerInfo = nil
|
|
}
|
|
|
|
liveResult := model.AsLiveResultAchievementStatus{
|
|
ClearCount: 1,
|
|
GotVoltage: liveFinishReq.Get("live_score.current_score").Int(),
|
|
RemainingStamina: liveFinishReq.Get("live_score.remaining_stamina").Int(),
|
|
}
|
|
|
|
liveFinishResp := GetUserData("liveFinish.json")
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.live_difficulty_master_id", liveStartReq.LiveDifficultyID)
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.live_deck_id", liveStartReq.DeckID)
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.mvp", mvpInfo)
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.partner", partnerInfo)
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.live_result_achievement_status", liveResult)
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.voltage", liveFinishReq.Get("live_score.current_score").Int())
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.last_best_voltage", liveFinishReq.Get("live_score.current_score").Int())
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.before_user_exp", GetUserStatus()["exp"].(float64))
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "live_result.gain_user_exp", 0)
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "user_model_diff.user_status", GetUserStatus())
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "user_model_diff.user_status.latest_live_deck_id", liveStartReq.DeckID)
|
|
liveFinishResp, _ = sjson.Set(liveFinishResp, "user_model_diff.user_status.last_live_difficulty_id", liveStartReq.LiveDifficultyID)
|
|
resp := SignResp(ctx.GetString("ep"), liveFinishResp, sessionKey)
|
|
// fmt.Println(resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsGetOtherUserCard(ctx *gin.Context) {
|
|
reqBody := gjson.Parse(ctx.GetString("reqBody")).Array()[0]
|
|
// fmt.Println(reqBody.String())
|
|
|
|
userCardReq := model.AsUserCardReq{}
|
|
if err := json.Unmarshal([]byte(reqBody.String()), &userCardReq); err != nil {
|
|
panic(err)
|
|
}
|
|
// fmt.Println(liveStartReq)
|
|
|
|
var cardInfo string
|
|
partnerResp := gjson.Parse(GetUserData("fetchLivePartners.json")).Get("partner_select_state.live_partners")
|
|
partnerResp.ForEach(func(k, v gjson.Result) bool {
|
|
userId := v.Get("user_id").Int()
|
|
if userId == userCardReq.UserID {
|
|
v.Get("card_by_category").ForEach(func(kk, vv gjson.Result) bool {
|
|
if vv.IsObject() {
|
|
cardId := vv.Get("card_master_id").Int()
|
|
if cardId == userCardReq.CardMasterID {
|
|
cardInfo = vv.String()
|
|
// fmt.Println(cardInfo)
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
var userCardInfo map[string]any
|
|
if err := json.Unmarshal([]byte(cardInfo), &userCardInfo); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
userCardResp := GetUserData("getOtherUserCard.json")
|
|
userCardResp, _ = sjson.Set(userCardResp, "other_user_card", userCardInfo)
|
|
resp := SignResp(ctx.GetString("ep"), userCardResp, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchNoticeDetail(ctx *gin.Context) {
|
|
reqBody := gjson.Parse(ctx.GetString("reqBody")).Array()[0]
|
|
// fmt.Println(reqBody.String())
|
|
|
|
noticeId := reqBody.Get("notice_id").String()
|
|
|
|
resp := SignResp(ctx.GetString("ep"), utils.ReadAllText("assets/as/notices/"+noticeId+".json"), sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsChangeIsAwakeningImage(ctx *gin.Context) {
|
|
reqBody := gjson.Parse(ctx.GetString("reqBody")).Array()[0]
|
|
// fmt.Println(reqBody.String())
|
|
|
|
req := model.AsCardAwakeningReq{}
|
|
if err := json.Unmarshal([]byte(reqBody.String()), &req); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
loginData := GetUserData("userCard.json")
|
|
cardInfo := model.AsCardInfo{}
|
|
gjson.Parse(loginData).Get("user_card_by_card_id").
|
|
ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() {
|
|
if err := json.Unmarshal([]byte(value.String()), &cardInfo); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if cardInfo.CardMasterID == req.CardMasterID {
|
|
cardInfo.IsAwakeningImage = req.IsAwakeningImage
|
|
|
|
k := "user_card_by_card_id." + key.String() + ".is_awakening_image"
|
|
SetUserData("userCard.json", k, req.IsAwakeningImage)
|
|
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
|
|
userCardInfo := []any{}
|
|
userCardInfo = append(userCardInfo, cardInfo.CardMasterID)
|
|
userCardInfo = append(userCardInfo, cardInfo)
|
|
|
|
cardResp := GetUserData("changeIsAwakeningImage.json")
|
|
cardResp, _ = sjson.Set(cardResp, "user_model_diff.user_status", GetUserStatus())
|
|
cardResp, _ = sjson.Set(cardResp, "user_model_diff.user_card_by_card_id", userCardInfo)
|
|
resp := SignResp(ctx.GetString("ep"), cardResp, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFinishStory(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("finishStory.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFinishStoryMain(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("finishUserStoryMain.json"),
|
|
"user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFinishStoryLinkage(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("finishStoryLinkage.json"),
|
|
"user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchTrainingTree(ctx *gin.Context) {
|
|
signBody := GetUserData("fetchTrainingTree.json")
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsUpdatePushNotificationSettings(ctx *gin.Context) {
|
|
resp := SignResp(ctx.GetString("ep"), "{}", sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsExecuteLesson(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
// fmt.Println(reqBody)
|
|
|
|
req := gjson.Parse(reqBody).Array()[0]
|
|
deckId := req.Get("selected_deck_id").Int()
|
|
|
|
var deckInfo string
|
|
var actionList []model.AsLessonMenuAction
|
|
gjson.Parse(GetUserData("lessonDeck.json")).Get("user_lesson_deck_by_id").ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() && value.Get("user_lesson_deck_id").Int() == deckId {
|
|
deckInfo = value.String()
|
|
// fmt.Println("Deck Info:", deckInfo)
|
|
|
|
gjson.Parse(deckInfo).ForEach(func(kk, vv gjson.Result) bool {
|
|
// fmt.Printf("kk: %s, vv: %s\n", kk.String(), vv.String())
|
|
if strings.Contains(kk.String(), "card_master_id") {
|
|
actionList = append(actionList, model.AsLessonMenuAction{
|
|
CardMasterID: vv.Int(),
|
|
Position: 0,
|
|
IsAddedPassiveSkill: true,
|
|
IsAddedSpecialPassiveSkill: true,
|
|
IsRankupedPassiveSkill: true,
|
|
IsRankupedSpecialPassiveSkill: true,
|
|
IsPromotedSkill: true,
|
|
MaxRarity: 4,
|
|
UpCount: 1,
|
|
})
|
|
}
|
|
return true
|
|
})
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
// fmt.Println(actionList)
|
|
|
|
SetUserData("executeLesson.json", "lesson_menu_actions.1", actionList)
|
|
SetUserData("executeLesson.json", "lesson_menu_actions.3", actionList)
|
|
SetUserData("executeLesson.json", "lesson_menu_actions.5", actionList)
|
|
signBody := SetUserData("executeLesson.json", "lesson_menu_actions.7", actionList)
|
|
SetUserData("userStatus.json", "main_lesson_deck_id", deckId)
|
|
signBody, _ = sjson.Set(signBody, "user_model_diff.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
// fmt.Println(resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsResultLesson(ctx *gin.Context) {
|
|
userData := GetUserStatus()
|
|
signBody, _ := sjson.Set(GetUserData("resultLesson.json"),
|
|
"user_model_diff.user_status", userData)
|
|
signBody, _ = sjson.Set(signBody, "selected_deck_id", userData["main_lesson_deck_id"])
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
// fmt.Println(resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSkillEditResult(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
// fmt.Println(reqBody)
|
|
|
|
req := gjson.Parse(reqBody).Array()[0]
|
|
|
|
var cardList []any
|
|
index := 1
|
|
cardData := GetUserData("userCard.json")
|
|
cardInfo := gjson.Parse(cardData).Get("user_card_by_card_id")
|
|
cardInfo.ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() {
|
|
if index > 9 {
|
|
return false
|
|
}
|
|
// fmt.Println("cardInfo:", value.String())
|
|
|
|
skillList := req.Get("selected_skill_ids")
|
|
skillList.ForEach(func(kk, vv gjson.Result) bool {
|
|
if kk.Int()%2 == 0 && vv.Int() == value.Get("card_master_id").Int() {
|
|
skill := skillList.Get(fmt.Sprintf("%d", kk.Int()+1))
|
|
skill.ForEach(func(kkk, vvv gjson.Result) bool {
|
|
skillIdKey := fmt.Sprintf("user_card_by_card_id.%s.additional_passive_skill_%d_id", key.String(), kkk.Int()+1)
|
|
cardData = SetUserData("userCard.json", skillIdKey, vvv.Int())
|
|
return true
|
|
})
|
|
|
|
card := gjson.Parse(cardData).Get("user_card_by_card_id." + key.String())
|
|
cardList = append(cardList, card.Get("card_master_id").Int())
|
|
cardList = append(cardList, card.Value())
|
|
|
|
index++
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
return true
|
|
})
|
|
|
|
signBody := GetUserData("skillEditResult.json")
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_card_by_card_id", cardList)
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
// fmt.Println(resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSaveDeckLesson(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
// fmt.Println(reqBody)
|
|
|
|
req := gjson.Parse(reqBody).Array()[0]
|
|
deckId := req.Get("deck_id").Int()
|
|
lessonDeck := GetUserData("lessonDeck.json")
|
|
|
|
var deckInfo string
|
|
var deckIndex string
|
|
gjson.Parse(lessonDeck).Get("user_lesson_deck_by_id").ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() && value.Get("user_lesson_deck_id").Int() == deckId {
|
|
deckInfo = value.String()
|
|
deckIndex = key.String()
|
|
// fmt.Println("Lesson Deck:", deckInfo)
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
cardList := req.Get("card_master_ids")
|
|
cardList.ForEach(func(key, value gjson.Result) bool {
|
|
if key.Int()%2 == 0 {
|
|
position := value.String()
|
|
// fmt.Println("Position:", position)
|
|
|
|
cardMasterId := cardList.Get(fmt.Sprintf("%d", key.Int()+1)).Int()
|
|
// fmt.Println("Card:", cardMasterId)
|
|
|
|
deckInfo, _ = sjson.Set(deckInfo, "card_master_id_"+position, cardMasterId)
|
|
// fmt.Println("New Lesson Deck:", deckInfo)
|
|
|
|
SetUserData("lessonDeck.json", "user_lesson_deck_by_id."+deckIndex, gjson.Parse(deckInfo).Value())
|
|
// lessonDeck, _ = sjson.Set(lessonDeck, "user_lesson_deck_by_id."+deckIndex, gjson.Parse(deckInfo).Value())
|
|
}
|
|
return true
|
|
})
|
|
|
|
signBody := GetUserData("saveDeckLesson.json")
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_lesson_deck_by_id.0", deckId)
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_lesson_deck_by_id.1", gjson.Parse(deckInfo).Value())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
// fmt.Println(resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSaveSuit(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
fmt.Println(reqBody)
|
|
|
|
req := gjson.Parse(reqBody).Array()[0]
|
|
deckId := req.Get("deck_id").Int()
|
|
cardId := req.Get("card_index").Int()
|
|
suitId := req.Get("suit_master_id").Int()
|
|
|
|
deckIndex := deckId*2 - 1
|
|
keyLiveDeck := fmt.Sprintf("user_live_deck_by_id.%d", deckIndex)
|
|
// fmt.Println("keyLiveDeck:", keyLiveDeck)
|
|
liveDeck := gjson.Parse(GetUserData("liveDeck.json")).Get(keyLiveDeck).String()
|
|
// fmt.Println(liveDeck)
|
|
keyLiveDeckInfo := fmt.Sprintf("suit_master_id_%d", cardId)
|
|
liveDeck, _ = sjson.Set(liveDeck, keyLiveDeckInfo, suitId)
|
|
// fmt.Println(liveDeck)
|
|
|
|
var deckInfo model.AsDeckInfo
|
|
if err := json.Unmarshal([]byte(liveDeck), &deckInfo); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
SetUserData("liveDeck.json", keyLiveDeck, deckInfo)
|
|
|
|
signBody, _ := sjson.Set(GetUserData("saveSuit.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_live_deck_by_id.0", deckId)
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_live_deck_by_id.1", deckInfo)
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
// fmt.Println(resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSaveDeck(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
// fmt.Println(reqBody)
|
|
|
|
req := gjson.Parse(reqBody).Array()[0]
|
|
deckId := req.Get("deck_id")
|
|
// fmt.Println("deckId:", deckId)
|
|
|
|
position := req.Get("card_master_ids.0")
|
|
cardMasterId := req.Get("card_master_ids.1")
|
|
// fmt.Println("cardMasterId:", cardMasterId)
|
|
|
|
var deckInfo, partyInfo string
|
|
var oldCardMasterId int64
|
|
var partyId int64
|
|
var savePartyInfo model.AsPartyInfo
|
|
deckList := GetUserData("liveDeck.json")
|
|
gjson.Parse(deckList).Get("user_live_deck_by_id").ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() && value.Get("user_live_deck_id").String() == deckId.String() {
|
|
deckInfo = value.String()
|
|
// fmt.Println("deckInfo:", deckInfo)
|
|
|
|
oldCardMasterId = gjson.Parse(deckInfo).Get("card_master_id_" + position.String()).Int()
|
|
deckInfo, _ = sjson.Set(deckInfo, "card_master_id_"+position.String(), cardMasterId.Int())
|
|
deckInfo, _ = sjson.Set(deckInfo, "suit_master_id_"+position.String(), cardMasterId.Int())
|
|
// fmt.Println("New deckInfo:", deckInfo)
|
|
|
|
SetUserData("liveDeck.json", "user_live_deck_by_id."+key.String(), gjson.Parse(deckInfo).Value())
|
|
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
gjson.Parse(deckList).Get("user_live_party_by_id").ForEach(func(key, value gjson.Result) bool {
|
|
if value.IsObject() && (value.Get("party_id").String() == deckId.String()+"01" ||
|
|
value.Get("party_id").String() == deckId.String()+"02" ||
|
|
value.Get("party_id").String() == deckId.String()+"03") {
|
|
value.ForEach(func(kk, vv gjson.Result) bool {
|
|
if vv.Int() == oldCardMasterId {
|
|
partyInfo = value.String()
|
|
// fmt.Println("partyInfo:", partyInfo)
|
|
|
|
partyInfo, _ = sjson.Set(partyInfo, kk.String(), cardMasterId.Int())
|
|
// fmt.Println("New partyInfo:", partyInfo)
|
|
|
|
newPartyInfo := gjson.Parse(partyInfo)
|
|
partyId = newPartyInfo.Get("party_id").Int()
|
|
|
|
roleIds := []int{}
|
|
err := MainEng.Table("m_card").
|
|
Where("id IN (?,?,?)", newPartyInfo.Get("card_master_id_1").Int(),
|
|
newPartyInfo.Get("card_master_id_2").Int(),
|
|
newPartyInfo.Get("card_master_id_3").Int()).
|
|
Cols("role").Find(&roleIds)
|
|
CheckErr(err)
|
|
// fmt.Println("roleIds:", roleIds)
|
|
|
|
partyIcon, partyName := GetPartyInfoByRoleIds(roleIds)
|
|
realPartyName := GetRealPartyName(partyName)
|
|
partyInfo, _ = sjson.Set(partyInfo, "name.dot_under_text", realPartyName)
|
|
partyInfo, _ = sjson.Set(partyInfo, "icon_master_id", partyIcon)
|
|
// fmt.Println("New partyInfo 2:", partyInfo)
|
|
|
|
decoder := json.NewDecoder(strings.NewReader(partyInfo))
|
|
decoder.UseNumber()
|
|
err = decoder.Decode(&savePartyInfo)
|
|
CheckErr(err)
|
|
SetUserData("liveDeck.json", "user_live_party_by_id."+key.String(), savePartyInfo)
|
|
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
return true
|
|
})
|
|
|
|
signBody := GetUserData("SaveDeck.json")
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_status", GetUserStatus())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_live_deck_by_id.0", deckId.Int())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_live_deck_by_id.1", gjson.Parse(deckInfo).Value())
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_live_party_by_id.0", partyId)
|
|
signBody, _ = sjson.Set(signBody, "user_model.user_live_party_by_id.1", savePartyInfo)
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
// fmt.Println(resp)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsSetFavoriteMember(ctx *gin.Context) {
|
|
reqBody := ctx.GetString("reqBody")
|
|
|
|
SetUserData("userStatus.json", "favorite_member_id",
|
|
gjson.Parse(reqBody).Array()[0].Get("member_master_id").Int())
|
|
signBody, _ := sjson.Set(GetUserData("setFavoriteMember.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchMission(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("fetchMission.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsClearMissionBadge(ctx *gin.Context) {
|
|
signBody, _ := sjson.Set(GetUserData("clearMissionBadge.json"),
|
|
"user_model.user_status", GetUserStatus())
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|
|
|
|
func AsFetchPresent(ctx *gin.Context) {
|
|
signBody := GetUserData("fetchPresent.json")
|
|
resp := SignResp(ctx.GetString("ep"), signBody, sessionKey)
|
|
|
|
ctx.Header("Content-Type", "application/json")
|
|
ctx.String(http.StatusOK, resp)
|
|
}
|