add user routes

.gitignore

@@ -0,0 +1,4 @@
+resp/
+.env
+db.json
+.idea

main.go

@@ -3,8 +3,6 @@
 package main
 
 import (
-	"bdgrp_go/master"
-	"fmt"
 	"log"
 	"os"
 	"regexp"
@@ -17,8 +15,6 @@ import (
 
 	"bdgrp_go/db"
 	"bdgrp_go/routes"
-	"os/signal"
-	"syscall"
 )
 
 const PORT = ":8482"
@@ -65,23 +61,5 @@ func main() {
 	log.Printf("Running on %s", PORT)
 	color.HEX("#00AABB").Printf("Server: %s\n", server)
 
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-
-	go func() {
-		for {
-			<-quit
-			fmt.Print("\nProceed to exit? (y/n): ")
-			var input string
-			fmt.Scanln(&input)
-			if input == "y" {
-				db.Save()
-				app.Shutdown()
-				return
-			}
-		}
-	}()
-
-	go master.ReloadMaster()
 	app.Listen(PORT)
 }

master/master.go

@@ -18,8 +18,8 @@ var (
 
 func GetMaster() map[string]any {
 	mu.RLock()
+	defer mu.RUnlock()
 	if cache != nil {
-		mu.RUnlock()
 		return cache
 	}
 	mu.RUnlock()

pbutil/pbutil.go

@@ -45,7 +45,7 @@ func Encode(message string, data map[string]any) ([]byte, error) {
 
 	msg := mt.New().Interface()
 	// map → json → proto
-	jsonBytes, _ := json.MarshalIndent(data, "", "  ")
+	jsonBytes, _ := json.Marshal(data)
 	if err := protojson.Unmarshal(jsonBytes, msg); err != nil {
 		return nil, err
 	}

routes/api/suite/master.go

@@ -48,11 +48,8 @@ func master(c *fiber.Ctx) error {
 		}
 	} else {
 		os.WriteFile(cachePath, data, 0644)
-		go mastermanager.ReloadMaster()
+		mastermanager.ReloadMaster()
 	}
 
-	c.Set("Content-Length", fmt.Sprintf("%d", len(data)))
-	c.Set("Content-Type", "application/octet-stream")
-	c.Set("X-Encoding", "bzip2")
 	return c.Send(data)
 }

routes/api/suite/user/param_userid.go

@@ -1,969 +0,0 @@
-package user
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"encoding/json"
-	"fmt"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-var decoMotionMap = buildDecoMotionMap()
-
-func buildDecoMotionMap() map[string][]int {
-	m := map[string][]int{}
-	for i := 1; i <= 35; i++ {
-		base := 217 + (i-1)*5
-		m[fmt.Sprintf("%d", i)] = []int{base, base + 1, base + 2}
-	}
-	m["601"] = []int{392, 393, 394}
-	for i := 36; i <= 40; i++ {
-		base := 462 + (i-36)*5
-		m[fmt.Sprintf("%d", i)] = []int{base, base + 1, base + 2}
-	}
-	return m
-}
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, get)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func storyList(userid string, storyMap map[string]any) map[string]any {
-	entries := storyMap["entries"].(map[string]any)
-	var result []any
-	for _, v := range entries {
-		story := v.(map[string]any)
-		result = append(result, map[string]any{
-			"userId":      userid,
-			"bandStoryId": story["bandStoryId"],
-			"bandId":      story["bandId"],
-			"status":      "already_read",
-			"seq":         story["seq"],
-		})
-	}
-	return map[string]any{"entries": result}
-}
-
-func get(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	server := os.Getenv("SERVER")
-	user := db.FindUser(userid)
-	if user == nil {
-		return c.Status(404).SendStatus(404)
-	}
-	m := master.GetMaster()
-
-	// pastEvents
-	pastPath := filepath.Join("pastEvents", server+".json")
-	pastData, _ := os.ReadFile(pastPath)
-	var past map[string]any
-	json.Unmarshal(pastData, &past)
-
-	// mission.json
-	missionData, _ := os.ReadFile("mission.json")
-	var missionsBase map[string]any
-	json.Unmarshal(missionData, &missionsBase)
-	missions := deepCopy(missionsBase)
-	for _, v := range missions {
-		group := v.(map[string]any)
-		if entries, ok := group["entries"].([]any); ok {
-			for _, e := range entries {
-				entry := e.(map[string]any)
-				entry["userId"] = userid
-			}
-		}
-	}
-
-	deckName := map[string]string{
-		"TW": "樂團1", "JP": "バンド1", "GL": "Band 1", "CN": "乐队1",
-	}[server]
-
-	changed := false
-	if user["situationIllust"] == nil {
-		user["situationIllust"] = map[string]any{}
-		changed = true
-	}
-	if user["decks"] == nil {
-		user["decks"] = []any{map[string]any{
-			"deckId": 1, "deckName": deckName,
-			"leader": 947, "member1": 1765, "member2": 1730, "member3": 2193, "member4": 2018,
-			"deckType": "normal",
-		}}
-		changed = true
-	}
-	if user["musicScore"] == nil {
-		user["musicScore"] = map[string]any{}
-		changed = true
-	}
-	if user["wearingCostume"] == nil {
-		costumeDefaults := map[int]map[string]any{
-			36:  {"dressId": 12854, "hairstyleId": 502, "costumeId": 1786},
-			37:  {"dressId": 12855, "hairstyleId": 503, "costumeId": 1787},
-			38:  {"dressId": 12856, "hairstyleId": 504, "costumeId": 1788},
-			39:  {"dressId": 12857, "hairstyleId": 505, "costumeId": 1789},
-			40:  {"dressId": 12858, "hairstyleId": 506, "costumeId": 1790},
-			601: {"dressId": 36, "hairstyleId": 36, "costumeId": 1643},
-		}
-		wc := map[string]any{}
-		charIds := append(rangeInts(1, 40), 601)
-		for _, charId := range charIds {
-			key := fmt.Sprintf("%d", charId)
-			if def, ok := costumeDefaults[charId]; ok {
-				wc[key] = def
-			} else {
-				wc[key] = map[string]any{
-					"dressId": charId, "hairstyleId": charId, "costumeId": 1332 + charId,
-				}
-			}
-		}
-		user["wearingCostume"] = wc
-		changed = true
-	}
-	if user["decos"] == nil {
-		user["decos"] = map[string]any{}
-		changed = true
-	}
-	if user["areaItems"] == nil {
-		user["areaItems"] = map[string]any{}
-		changed = true
-	}
-	if changed {
-		db.Save()
-	}
-
-	charIds := append(rangeInts(1, 40), 601)
-	userCharacterMap := map[string]any{}
-	wc := user["wearingCostume"].(map[string]any)
-	for _, id := range charIds {
-		key := fmt.Sprintf("%d", id)
-		costume := wc[key].(map[string]any)
-		userCharacterMap[key] = map[string]any{
-			"userId": userid, "characterId": id,
-			"costumeId": costume["costumeId"],
-		}
-	}
-
-	userSituations := utils.BuildUserSituations(userid, m, user)
-	situationMap := map[string]any{}
-	for _, sit := range userSituations {
-		s := sit.(map[string]any)
-		situationMap[fmt.Sprintf("%v", s["situationId"])] = s
-	}
-
-	decks := user["decks"].([]any)
-	mainDeckIdx := 1
-	if md, ok := user["mainDeck"].(float64); ok {
-		mainDeckIdx = int(md)
-	}
-	mainDeck := decks[mainDeckIdx-1].(map[string]any)
-
-	situationIdFields := []string{"leader", "member1", "member2", "member3", "member4"}
-	charSituationMap := m["masterCharacterSituationMap"].(map[string]any)["entries"].(map[string]any)
-	seen := map[int]bool{}
-	var deckMembers []int
-	for _, field := range situationIdFields {
-		if sid, ok := mainDeck[field]; ok && sid != nil {
-			sidStr := fmt.Sprintf("%v", sid)
-			if entry, ok := charSituationMap[sidStr].(map[string]any); ok {
-				if charId, ok := entry["characterId"].(float64); ok {
-					cid := int(charId)
-					if !seen[cid] {
-						seen[cid] = true
-						deckMembers = append(deckMembers, cid)
-					}
-				}
-			}
-		}
-	}
-
-	commonsLive2d := map[string]map[int][]int{}
-	if cl2dMap, ok := m["masterCommonsLive2dMap"].(map[string]any); ok {
-		for _, v := range cl2dMap["entries"].(map[string]any) {
-			entry := v.(map[string]any)
-			cat := fmt.Sprintf("%v", entry["live2dCategory"])
-			cid := int(entry["characterId"].(float64))
-			lid := int(entry["live2dId"].(float64))
-			if commonsLive2d[cat] == nil {
-				commonsLive2d[cat] = map[int][]int{}
-			}
-			commonsLive2d[cat][cid] = append(commonsLive2d[cat][cid], lid)
-		}
-	}
-	aggregated := map[string][]int{}
-	for cat, charMap := range commonsLive2d {
-		for charId, ids := range charMap {
-			if slices.Contains(deckMembers, charId) {
-				aggregated[cat] = append(aggregated[cat], ids...)
-			}
-		}
-	}
-	userCommonsLive2dEntries := map[string]any{}
-	for cat, idArray := range aggregated {
-		entries := make([]any, len(idArray))
-		for i, lid := range idArray {
-			entries[i] = map[string]any{"live2dId": lid, "live2dCategory": cat}
-		}
-		userCommonsLive2dEntries[cat] = map[string]any{"entries": entries}
-	}
-
-	userProfileDegree := utils.BuildUserProfileDegree(userid, user)
-	decoDegree := map[string]any{}
-	for k, v := range userProfileDegree {
-		entry := v.(map[string]any)
-		decoDegree[k] = map[string]any{
-			"decoFrameId":       entry["userId"],
-			"profileDegreeType": entry["profileDegreeType"],
-			"degreeId":          entry["degreeId"],
-		}
-	}
-
-	charProfileL2d := map[string][]int{}
-	if cpMap, ok := m["masterCharacterProfileLive2dMap"].(map[string]any); ok {
-		for _, v := range cpMap["entries"].(map[string]any) {
-			entry := v.(map[string]any)
-			cid := fmt.Sprintf("%v", entry["characterId"])
-			lid := int(entry["characterProfileLive2dId"].(float64))
-			charProfileL2d[cid] = append(charProfileL2d[cid], lid)
-		}
-	}
-	charProfileL2dEntries := map[string]any{}
-	for cid, ids := range charProfileL2d {
-		entries := make([]any, len(ids))
-		for i, id := range ids {
-			entries[i] = map[string]any{"characterId": cid, "live2dId": id}
-		}
-		charProfileL2dEntries[cid] = map[string]any{"entries": entries}
-	}
-
-	purchaseIds := []string{}
-	if pm, ok := m["masterPurchaseMap"].(map[string]any); ok {
-		for id := range pm["entries"].(map[string]any) {
-			purchaseIds = append(purchaseIds, id)
-		}
-	}
-
-	userEpisodeMap := map[string]any{}
-	for _, v := range charSituationMap {
-		card := v.(map[string]any)
-		rel := fmt.Sprintf("%v", card["releasedAt"])
-		if rel == "4128645600000" || rel == "4131237600000" {
-			continue
-		}
-		eps, ok := card["episodes"].(map[string]any)
-		if !ok {
-			continue
-		}
-		entries, ok := eps["entries"].([]any)
-		if !ok {
-			continue
-		}
-		for _, e := range entries {
-			ep := e.(map[string]any)
-			epId := fmt.Sprintf("%v", ep["episodeId"])
-			userEpisodeMap[epId] = map[string]any{
-				"userId": userid, "episodeId": ep["episodeId"], "episodeStatus": "already_read",
-			}
-		}
-	}
-
-	validSpawnPoints := map[string]bool{}
-	if spMap, ok := m["masterAreaItemSpawnMap"].(map[string]any); ok {
-		for k := range spMap["entries"].(map[string]any) {
-			validSpawnPoints[k] = true
-		}
-	}
-
-	now := time.Now().UnixMilli()
-	var seasonId any
-	if sbMap, ok := m["masterSeasonBasicMap"].(map[string]any); ok {
-		for _, v := range sbMap["entries"].(map[string]any) {
-			s := v.(map[string]any)
-			startAt, _ := strconv.ParseInt(s["startAt"].(string), 10, 64)
-			endAt, _ := strconv.ParseInt(s["endAt"].(string), 10, 64)
-			if startAt <= now && now < endAt {
-				seasonId = s["seasonId"]
-				break
-			}
-		}
-	}
-
-	eventStoryEntries := map[string]any{}
-	if escMap, ok := m["masterEventStoryMemorialConfigMap"].(map[string]any); ok {
-		pastStoryEntries := map[string]any{}
-		if pse, ok := past["pastEventStoryMap"].(map[string]any); ok {
-			if entries, ok := pse["entries"].(map[string]any); ok {
-				pastStoryEntries = entries
-			}
-		}
-		for eventId := range escMap["entries"].(map[string]any) {
-			length := 0
-			if pe, ok := pastStoryEntries[eventId].(map[string]any); ok {
-				if en, ok := pe["entries"].([]any); ok {
-					length = len(en)
-				}
-			}
-			storyEntries := make([]any, length)
-			for i := range storyEntries {
-				storyEntries[i] = map[string]any{
-					"userId": userid, "eventId": eventId, "seq": i, "status": "already_read",
-				}
-			}
-			eventStoryEntries[eventId] = map[string]any{
-				"eventId":            eventId,
-				"userEventStoryList": map[string]any{"entries": storyEntries},
-				"isExistUnReadStory": false,
-				"isLocked":           false,
-			}
-		}
-	}
-
-	areaStatusEntries := map[string]any{}
-	if areaMap, ok := m["masterAreaMap"].(map[string]any); ok {
-		for areaId, v := range areaMap["entries"].(map[string]any) {
-			area := v.(map[string]any)
-			if area["areaType"] == "common" {
-				areaStatusEntries[areaId] = map[string]any{"userId": userid, "areaId": areaId}
-			}
-		}
-	}
-
-	areaItemEntries := map[string]any{}
-	if aiMap, ok := m["masterAreaItemMap"].(map[string]any); ok {
-		for id, v := range aiMap["entries"].(map[string]any) {
-			areaItem := v.(map[string]any)
-			sp := fmt.Sprintf("%v", areaItem["spawnPoint"])
-			if validSpawnPoints[sp] {
-				areaItemEntries[id] = map[string]any{
-					"userId": userid, "areaItemId": areaItem["areaItemId"],
-					"areaItemCategory": areaItem["categoryId"], "level": 8,
-				}
-			}
-		}
-	}
-
-	musicScore, _ := user["musicScore"].(map[string]any)
-	if musicScore == nil {
-		musicScore = map[string]any{}
-	}
-	musicScoreEntries := map[string]any{}
-	for musicId, v := range musicScore {
-		sd := v.(map[string]any)
-		entries, _ := sd["entries"].([]any)
-		mapped := make([]any, len(entries))
-		for i, e := range entries {
-			score := e.(map[string]any)
-			mapped[i] = map[string]any{
-				"userId":          fmt.Sprintf("%v", user["userId"]),
-				"musicId":         musicId,
-				"musicDifficulty": score["musicDifficulty"],
-				"soloHighScore":   score["soloHighScore"],
-				"maxCombo":        score["maxCombo"],
-				"soloScoreRank":   score["soloScoreRank"],
-				"clearStatus":     score["clearStatus"],
-			}
-		}
-		musicScoreEntries[musicId] = map[string]any{"entries": mapped}
-	}
-
-	decoEffectEntries := map[string]any{}
-	if deMap, ok := m["masterDecoEffectList"].(map[string]any); ok {
-		if entries, ok := deMap["entries"].([]any); ok {
-			for _, v := range entries {
-				e := v.(map[string]any)
-				startAt, _ := strconv.ParseInt(e["startAt"].(string), 10, 64)
-				endAt, _ := strconv.ParseInt(e["endAt"].(string), 10, 64)
-				if startAt <= now && now >= endAt {
-					id := fmt.Sprintf("%v", e["decoEffectId"])
-					decoEffectEntries[id] = map[string]any{"userId": userid, "decoEffectId": e["decoEffectId"]}
-				}
-			}
-		}
-	}
-
-	digestSeen := map[any]bool{}
-	var digestEntries []any
-	if dsList, ok := m["masterDigestStoryDetailList"].(map[string]any); ok {
-		if entries, ok := dsList["entries"].([]any); ok {
-			for _, v := range entries {
-				story := v.(map[string]any)
-				id := story["digestStoryId"]
-				if !digestSeen[id] {
-					digestSeen[id] = true
-					digestEntries = append(digestEntries, map[string]any{
-						"userId": userid, "digestStoryId": id, "status": "already_read",
-					})
-				}
-			}
-		}
-	}
-
-	decoFrameEntries := map[string]any{}
-	if dfMap, ok := m["masterDecoFrameMap"].(map[string]any); ok {
-		for _, v := range dfMap["entries"].(map[string]any) {
-			f := v.(map[string]any)
-			id := fmt.Sprintf("%v", f["decoFrameId"])
-			decoFrameEntries[id] = map[string]any{"userId": userid, "decoFrameId": f["decoFrameId"], "level": 5}
-		}
-	}
-
-	decoPinsEntries := map[string]any{}
-	if dpMap, ok := m["masterDecoPinsMap"].(map[string]any); ok {
-		for _, v := range dpMap["entries"].(map[string]any) {
-			p := v.(map[string]any)
-			id := fmt.Sprintf("%v", p["decoPinsId"])
-			decoPinsEntries[id] = map[string]any{"userId": userid, "decoPinsId": p["decoPinsId"], "quantity": 5}
-		}
-	}
-
-	_ = rand.Intn
-
-	userId := fmt.Sprintf("%v", user["userId"])
-
-	data := map[string]any{
-		"user": map[string]any{
-			"userRegistration": map[string]any{
-				"userId": userId, "hash": user["hash"], "userName": user["userName"],
-				"clientVersion": user["clientVersion"], "platform": user["platform"],
-				"deviceModel": user["deviceModel"], "operatingSystem": user["operatingSystem"],
-				"birthMonth": user["birthMonth"], "tutorialStatus": user["tutorialStatus"],
-				"introduction": user["introduction"], "tutorialEndedAt": fmt.Sprintf("%v", user["tutorialEndedAt"]),
-			},
-			"userGamedata": map[string]any{
-				"userId": userId,
-				"rank":   user["rank"],
-				"exp":    user["exp"],
-				"coin":   fmt.Sprintf("%v", user["coin"]), "mainDeck": user["mainDeck"],
-				"paidStar": user["paidStar"], "freeStar": user["freeStar"], "seal": user["seal"],
-				"degree":                    user["degree"].([]any)[0],
-				"publishTotalDeckPowerFlg":  user["publishTotalDeckPowerFlg"],
-				"publishBandRankFlg":        user["publishBandRankFlg"],
-				"publishMusicClearedFlg":    user["publishMusicClearedFlg"],
-				"publishMusicFullComboFlg":  user["publishMusicFullComboFlg"],
-				"publishHighScoreRatingFlg": user["publishHighScoreRatingFlg"],
-				"pooledExp":                 fmt.Sprintf("%v", user["pooledExp"]),
-				"totalExp":                  fmt.Sprintf("%v", user["totalExp"]),
-				"nextExp":                   user["nextExp"], "publishUpdatedAtFlg": user["publishUpdatedAtFlg"],
-				"userPaidStarRecallResponse":           nil,
-				"startDashLoginBonusReceiveFlg":        user["startDashLoginBonusReceiveFlg"],
-				"publishMusicAllPerfectFlg":            user["publishMusicAllPerfectFlg"],
-				"publishDeckRankFlg":                   user["publishDeckRankFlg"],
-				"publishStageAchievementConditionsFlg": user["publishStageAchievementConditionsFlg"],
-				"publishStageFriendRankingFlg":         user["publishStageFriendRankingFlg"],
-				"publishCharacterRankFlg":              user["publishCharacterRankFlg"],
-				"loginDays":                            user["loginDays"],
-			},
-		},
-		"userCharacterMap": map[string]any{"entries": userCharacterMap},
-		"userSituationMap": map[string]any{"entries": situationMap},
-		"userMainStoryList": func() map[string]any {
-			var entries []any
-			if msMap, ok := m["masterMainStoryMap"].(map[string]any); ok {
-				list := msMap["entries"].(map[string]any)
-				for _, l := range list {
-					story := l.(map[string]any)
-					entries = append(entries, map[string]any{
-						"userId": userid, "storyId": story["mainStoryId"], "status": "already_read",
-					})
-				}
-			}
-			return map[string]any{"entries": entries}
-		}(),
-		"userPracticeTicketList": nil,
-		"userBondsList": map[string]any{
-			"entries": func() []any {
-				result := make([]any, 9)
-				for i := range result {
-					result[i] = map[string]any{
-						"userId": userid, "bondsId": i + 1, "level": 1, "bonds": 5 * (i + 2),
-					}
-				}
-				return result
-			}(),
-		},
-		"userBandRankMap": map[string]any{
-			"entries": func() map[string]any {
-				result := map[string]any{}
-				for _, bandId := range []int{1, 2, 3, 4, 5, 18, 21, 45} {
-					result[fmt.Sprintf("%d", bandId)] = map[string]any{
-						"userId": userid, "bandId": bandId, "bandRank": 50,
-						"exp": 0, "totalExp": 0, "nextExp": 0,
-					}
-				}
-				return result
-			}(),
-		},
-		"userPoppinPartyStoryList":     storyList(userid, m["masterPoppinPartyStoryMap"].(map[string]any)),
-		"userAfterglowStoryList":       storyList(userid, m["masterAfterglowStoryMap"].(map[string]any)),
-		"userPastelPalettesStoryList":  storyList(userid, m["masterPastelPalettesStoryMap"].(map[string]any)),
-		"userHelloHappyWorldStoryList": storyList(userid, m["masterHelloHappyWorldStoryMap"].(map[string]any)),
-		"userRoseliaStoryList":         storyList(userid, m["masterRoseliaStoryMap"].(map[string]any)),
-		"userItemList": func() map[string]any {
-			var entries []any
-			if itemMap, ok := m["masterItemMap"].(map[string]any); ok {
-				for _, v := range itemMap["entries"].(map[string]any) {
-					item := v.(map[string]any)
-					entries = append(entries, map[string]any{
-						"userId": userid, "itemId": item["itemId"], "quantity": 6767,
-					})
-				}
-			}
-			return map[string]any{"entries": entries}
-		}(),
-		"userCommonsLive2dMap":   map[string]any{"entries": userCommonsLive2dEntries},
-		"userEpisodeMap":         map[string]any{"entries": userEpisodeMap},
-		"userAppendParameterMap": nil,
-		"userMusicInventoryList": func() map[string]any {
-			var entries []any
-			if ml, ok := m["masterMusicList"].(map[string]any); ok {
-				if songs, ok := ml["entries"].([]any); ok {
-					mvMap := map[string]any{}
-					if mvl, ok := m["masterMusicVideoListMap"].(map[string]any); ok {
-						mvMap = mvl["entries"].(map[string]any)
-					}
-					for _, v := range songs {
-						song := v.(map[string]any)
-						musicId := song["musicId"]
-						_, hasMv := mvMap[fmt.Sprintf("%v", musicId)]
-						entries = append(entries, map[string]any{
-							"userId": userid, "musicId": musicId, "seq": 1,
-							"hasMv": hasMv, "createdAt": fmt.Sprintf("%d", now),
-						})
-					}
-				}
-			}
-			return map[string]any{"entries": entries}
-		}(),
-		"userCostumeMap": func() map[string]any {
-			result := map[string]any{}
-			if cm, ok := m["masterCostumeMap"].(map[string]any); ok {
-				for _, v := range cm["entries"].(map[string]any) {
-					costume := v.(map[string]any)
-					id := fmt.Sprintf("%v", costume["costumeId"])
-					result[id] = map[string]any{
-						"userId": userid, "costumeId": costume["costumeId"], "characterId": costume["characterId"],
-					}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userAfterLiveTalkListMap": nil,
-		"userAreaItemMap": map[string]any{
-			"entries":             areaItemEntries,
-			"newlyOpenedContents": map[string]any{"entries": []any{}},
-		},
-		"userResourceCount": nil,
-		"userLiveBoost": map[string]any{
-			"userId": userid, "liveBoost": 67,
-			"serverDate": fmt.Sprintf("%d", now), "liveBoostBonusType": "default",
-		},
-		"userExchangesList": map[string]any{
-			"entries": []any{map[string]any{"userId": userid, "exchangesId": 1563, "resetAt": "1779155725000"}},
-		},
-		"userGachaTicketList": nil,
-		"userGachaStatusMap":  nil,
-		"userAreaStatusMap":   map[string]any{"entries": areaStatusEntries},
-		"userLoginBonusMap":   map[string]any{"entries": map[string]any{}},
-		"userHomeBannerList":  nil,
-		"userStampMap": func() map[string]any {
-			result := map[string]any{}
-			if sm, ok := m["masterStampMap"].(map[string]any); ok {
-				for stampId, v := range sm["entries"].(map[string]any) {
-					stamp := v.(map[string]any)
-					_, withVoice := stamp["withVoice"]
-					result[stampId] = map[string]any{
-						"userId": userid, "stampId": stamp["stampId"],
-						"seq": 1, "isUnlockVoice": withVoice,
-					}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userDegreeMap": func() map[string]any {
-			result := map[string]any{}
-			if dm, ok := m["masterDegreeMap"].(map[string]any); ok {
-				for degreeId := range dm["entries"].(map[string]any) {
-					result[degreeId] = map[string]any{"userId": userid, "degreeId": degreeId}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userBadPenalty":                nil,
-		"userCharacterProfileLive2dMap": map[string]any{"entries": charProfileL2dEntries},
-		"userEventExchangesList":        map[string]any{"entries": []any{}},
-		"userEventItemList": func() map[string]any {
-			var entries []any
-			if eim, ok := m["masterEventItemMap"].(map[string]any); ok {
-				for _, v := range eim["entries"].(map[string]any) {
-					item := v.(map[string]any)
-					entries = append(entries, map[string]any{
-						"userId": userid, "eventItemId": item["eventItemId"], "quantity": 1,
-					})
-				}
-			}
-			return map[string]any{"entries": entries}
-		}(),
-		"userPurchaseMap": func() map[string]any {
-			result := map[string]any{}
-			for _, id := range purchaseIds {
-				result[id] = map[string]any{"userId": userid, "purchaseId": id, "count": 0}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userMissionMap": map[string]any{"entries": missions},
-		"userGenericStoryMap": func() map[string]any {
-			result := map[string]any{}
-			if gsm, ok := m["masterGenericStoryMap"].(map[string]any); ok {
-				for id, v := range gsm["entries"].(map[string]any) {
-					story := v.(map[string]any)
-					result[id] = map[string]any{
-						"userId": userid, "genericStoryId": story["genericStoryId"], "status": "already_read",
-					}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userLiveBoostRecoveryItemList":      nil,
-		"userHighScoreRating":                nil,
-		"userHighScoreMusicRatingMap":        nil,
-		"userSeason":                         map[string]any{"seasonId": seasonId},
-		"userQualifyTournamentMusicScoreMap": nil,
-		"userEventStoryMemorialMap":          map[string]any{"entries": eventStoryEntries},
-		"userReleasedBondsIdList": func() map[string]any {
-			var entries []any
-			if bm, ok := m["masterBondsMap"].(map[string]any); ok {
-				for k := range bm["entries"].(map[string]any) {
-					entries = append(entries, k)
-				}
-			}
-			return map[string]any{"entries": entries}
-		}(),
-		"userMiracleTicketMap":             map[string]any{"entries": map[string]any{}},
-		"userMiracleTicketExchangesMap":    map[string]any{"entries": map[string]any{}},
-		"userMultiDisconnectionBadPenalty": nil,
-		"userSpecialLotteryDrawResultMap":  nil,
-		"userMusicScoreMap":                map[string]any{"entries": musicScoreEntries},
-		"userMusicAchievementMap":          nil,
-		"userBirthdayStoryMap": func() map[string]any {
-			result := map[string]any{}
-			if bpm, ok := m["masterBirthdayPageMap"].(map[string]any); ok {
-				for _, v := range bpm["entries"].(map[string]any) {
-					item := v.(map[string]any)
-					if item["birthdayStoryId"] == nil {
-						continue
-					}
-					id := fmt.Sprintf("%v", item["birthdayStoryId"])
-					result[id] = map[string]any{
-						"userId": userid, "birthdayStoryId": item["birthdayStoryId"], "status": "already_read",
-					}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userGenericAnimationMap": func() map[string]any {
-			result := map[string]any{}
-			if gam, ok := m["masterGenericAnimationMap"].(map[string]any); ok {
-				for id := range gam["entries"].(map[string]any) {
-					result[id] = map[string]any{"userId": userid, "genericAnimationId": id, "status": "already_read"}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userMusicShopMap": func() map[string]any {
-			var entries []any
-			if ml, ok := m["masterMusicList"].(map[string]any); ok {
-				if songs, ok := ml["entries"].([]any); ok {
-					for i, v := range songs {
-						song := v.(map[string]any)
-						entries = append(entries, map[string]any{
-							"userId": userid, "musicShopId": i + 1, "shopId": 7,
-							"shopCategory": "common", "musicId": song["musicId"],
-							"status": "sold_out", "seq": i + 1, "isInitialDistribution": false,
-						})
-					}
-				}
-			}
-			return map[string]any{"entries": map[string]any{"7": map[string]any{"entries": entries}}}
-		}(),
-		"userTitleList":                      nil,
-		"userPurchaseVoidBadPenaltyStandard": nil,
-		"userSelectNewYearCardMap":           nil,
-		"userGachaCountCeilingMap":           nil,
-		"userBackstageTalkSetReadHistoryMap": nil,
-		"userNewMusicIntroductionMap": func() map[string]any {
-			result := map[string]any{}
-			if nm, ok := m["masterNewMusicIntroductionMap"].(map[string]any); ok {
-				if entries, ok := nm["entries"].(map[string]any); ok {
-					for _, v := range entries {
-						item := v.(map[string]any)
-						id := fmt.Sprintf("%v", item["newMusicIntroductionId"])
-						result[id] = map[string]any{
-							"userId": userid, "newMusicIntroductionId": item["newMusicIntroductionId"], "status": "already_read",
-						}
-					}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userNewSituationIntroductionMap": func() map[string]any {
-			result := map[string]any{}
-			if nsi, ok := m["masterNewSituationIntroductionList"].(map[string]any); ok {
-				if entries, ok := nsi["entries"].([]any); ok {
-					for _, v := range entries {
-						if item, ok := v.(map[string]any); ok {
-							id := fmt.Sprintf("%v", item["newSituationIntroductionId"])
-							result[id] = map[string]any{
-								"userId": userid, "newSituationIntroductionId": item["newSituationIntroductionId"], "status": "already_read",
-							}
-						}
-					}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userFriendRelationDetail": map[string]any{
-			"applicationMap": nil, "approvalMap": nil, "friendMap": nil,
-			"friendLimit": 50, "approvalLimit": 50, "applicationLimit": 50,
-		},
-		"userNotHaveViewExchangesMiracleTicketIdList": map[string]any{"entries": []any{}},
-		"userProfileSituation":                        nil,
-		"userProfileDegreeMap":                        map[string]any{"entries": userProfileDegree},
-		"userDecoFrameInventoryMap":                   map[string]any{"entries": decoFrameEntries},
-		"userDecoPinsInventoryMap":                    map[string]any{"entries": decoPinsEntries},
-		"userDecoEffectInventoryMap":                  map[string]any{"entries": decoEffectEntries},
-		"userDecoEquipment":                           utils.BuildDecoEquipment(userid, user, m),
-		"userMusicVideoListMap": func() map[string]any {
-			result := map[string]any{}
-			if mvlm, ok := m["masterMusicVideoListMap"].(map[string]any); ok {
-				for musicId := range mvlm["entries"].(map[string]any) {
-					result[musicId] = map[string]any{
-						"entries": []any{map[string]any{"userId": userid, "musicId": musicId, "seq": 1}},
-					}
-				}
-			}
-			return map[string]any{"userMusicVideoInventoryListMap": map[string]any{"entries": result}}
-		}(),
-		"userPurchaseMenuLastVisitMap":         map[string]any{"entries": map[string]any{}},
-		"userSkinLaneMap":                      nil,
-		"currentUserEventMusicScoresMap":       nil,
-		"currentUserEventMusicAchievementsMap": nil,
-		"currentUserEventBoxGachaMap":          nil,
-		"userMonthlyPurchaseMap":               nil,
-		"userSubscriptionList":                 nil,
-		"userCommentBannerList":                nil,
-		"userEventBoxGachaSpinSettings":        nil,
-		"userMorfonicaStoryList":               storyList(userid, m["masterMorfonicaStoryMap"].(map[string]any)),
-		"userMatchingBonusList":                nil,
-		"userRaiseASuilenStoryList":            storyList(userid, m["masterRaiseASuilenStoryMap"].(map[string]any)),
-		"userCollaboOriginalMusicScoreMap":     nil,
-		"userDailyLive": map[string]any{
-			"lastClearedAt": 0, "liveStartedAt": 0, "getDailyLiveRewardId": 6,
-		},
-		"userDailyLiveTotalRewardHistory":        nil,
-		"userComebackStatus":                     nil,
-		"userGraphicalInformationList":           nil,
-		"userMultiLiveCountRewardList":           nil,
-		"userDigestStoryList":                    map[string]any{"entries": digestEntries},
-		"userLiveBoostUseBonusLimitList":         nil,
-		"userReceivablePresentLocationList":      nil,
-		"userPanelMissionList":                   nil,
-		"userBirthdayIntroductionMap":            nil,
-		"userFestivalTeamMap":                    nil,
-		"userLimitedItemList":                    nil,
-		"userLimitedExchangesList":               map[string]any{"entries": []any{}},
-		"userDeckList":                           map[string]any{"entries": decks},
-		"userAddMusicDifficultyIntroductionList": nil,
-		"userGalleryList":                        nil,
-		"userBandDeckRatingMap":                  nil,
-		"updatedBandDeckRankList":                nil,
-		"userStageChallengeStageNoMap":           nil,
-		"userStageChallengeMap":                  nil,
-		"userStageChallengeScoreMap":             nil,
-		"userStarSeal":                           map[string]any{"amount": user["seal"]},
-		"userLiveBoostUseFull":                   map[string]any{"dailyUseFullCount": 67, "resetTime": 0},
-		"userAutoLive":                           map[string]any{"resetTime": 0},
-		"userMonthlyMission":                     nil,
-		"userMonthlyMissionRewardList":           nil,
-		"userCharacterRankMap":                   utils.BuildCharacterRankMap(),
-		"userCharacterPotentialLevelMap": func() map[string]any {
-			result := map[string]any{}
-			for i := 1; i <= 40; i++ {
-				result[fmt.Sprintf("%d", i)] = map[string]any{
-					"performanceLevel": 1, "techniqueLevel": 1, "visualLevel": 1,
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userMusicVideo3dListMap": func() map[string]any {
-			result := map[string]any{}
-			if mv3m, ok := m["masterMusicVideo3dMap"].(map[string]any); ok {
-				for _, v := range mv3m["entries"].(map[string]any) {
-					mv := v.(map[string]any)
-					musicId := fmt.Sprintf("%v", mv["musicId"])
-					result[musicId] = map[string]any{
-						"entries": []any{map[string]any{
-							"musicVideo3dId": mv["musicVideo3dId"], "musicId": mv["musicId"], "seq": mv["seq"],
-						}},
-					}
-				}
-			}
-			return map[string]any{"userMusicVideo3dInventoryListMap": map[string]any{"entries": result}}
-		}(),
-		"userCostume3dDressInventoryMap": func() map[string]any {
-			result := map[string]any{}
-			if cdm, ok := m["masterCostume3dDressMap"].(map[string]any); ok {
-				for id := range cdm["entries"].(map[string]any) {
-					idInt, _ := strconv.Atoi(id)
-					result[id] = map[string]any{"costume3dDressId": idInt, "status": "obtained"}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userCostume3dHairstyleInventoryMap": func() map[string]any {
-			result := map[string]any{}
-			if chm, ok := m["masterCostume3dHairstyleMap"].(map[string]any); ok {
-				for id := range chm["entries"].(map[string]any) {
-					idInt, _ := strconv.Atoi(id)
-					result[id] = map[string]any{"costume3dHairstyleId": idInt, "status": "obtained"}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userWearingCostume3dMap": func() map[string]any {
-			result := map[string]any{}
-			for charId, v := range wc {
-				costume := v.(map[string]any)
-				result[charId] = map[string]any{
-					"characterId":          charId,
-					"costume3dDressId":     costume["dressId"],
-					"costume3dHairstyleId": costume["hairstyleId"],
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userMusicClearInfoMap":          utils.ComputeMusicClearInfo(musicScore),
-		"userMusicClearCountInfoMap":     utils.ComputeMusicClearCountInfo(musicScore),
-		"userCharacterSituationCountMap": nil,
-		"userDecoCharacterBackgroundInventoryMap": func() map[string]any {
-			result := map[string]any{}
-			if dcbm, ok := m["masterDecoCharacterBackgroundMap"].(map[string]any); ok {
-				for backgroundId := range dcbm["entries"].(map[string]any) {
-					result[backgroundId] = map[string]any{"userId": userid, "backgroundId": backgroundId}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userDecoCharacter3dMotionInventoryListMap": func() map[string]any {
-			result := map[string]any{}
-			for charId, motionIds := range decoMotionMap {
-				entries := make([]any, len(motionIds))
-				for i, motionId := range motionIds {
-					entries[i] = map[string]any{"userId": userid, "motionId": motionId}
-				}
-				result[charId] = map[string]any{"entries": entries}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userMusicVideo3dCustomDeckMap":          nil,
-		"userCostume3dMakingItemInventoryMap":    nil,
-		"userMusicVideo3dOriginalDeckCostumeMap": nil,
-		"userLimitBreakItemList":                 nil,
-		"userDecoAppealInventoryMap":             nil,
-		"userInvitationInfo":                     nil,
-		"userCharacterUseStyleMap": func() map[string]any {
-			useCharacterId := 15
-			status := "normal"
-			if user["msk"] != nil {
-				msk := user["msk"].(map[string]any)
-				useCharacterId = int(func() float64 {
-					switch v := msk["useCharacterId"].(type) {
-					case float64:
-						return v
-					case int:
-						return float64(v)
-					}
-					return 0
-				}())
-				status = msk["status"].(string)
-			}
-			return map[string]any{
-				"entries": map[string]any{
-					"15": map[string]any{
-						"characterId":    15,
-						"useCharacterId": useCharacterId,
-						"status":         status,
-					},
-				},
-			}
-		}(),
-		"userPurchaseStarList":     nil,
-		"userInviteMissionListMap": nil,
-		"userGachaBonusMap":        nil,
-		"userStampVoiceMap": func() map[string]any {
-			result := map[string]any{}
-			if sm, ok := m["masterStampMap"].(map[string]any); ok {
-				for stampId, v := range sm["entries"].(map[string]any) {
-					stamp := v.(map[string]any)
-					if _, ok := stamp["withVoice"]; ok {
-						result[stampId] = map[string]any{"userId": userid, "stampId": stampId}
-					}
-				}
-			}
-			return map[string]any{"entries": result}
-		}(),
-		"userEventRankedCountAppeal":       nil,
-		"userEventMusicRankedCountAppeal":  nil,
-		"userMyGoStoryList":                storyList(userid, m["masterMyGoStoryMap"].(map[string]any)),
-		"userTerms":                        map[string]any{"userId": userid},
-		"userCharacterMissionBonusMap":     nil,
-		"userPhotoStudioMap":               nil,
-		"userGachaSelfPickupSituationList": nil,
-		"userPhotoBackInventoryMap":        nil,
-		"userLimitedSkinInventoryMap":      nil,
-		"userMusicClearCountDetailMap":     nil,
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserGetResponse", data)
-	if err != nil {
-		fmt.Println(err)
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-		return c.Status(500).SendString(err.Error())
-	}
-
-	c.Set("Content-Type", "application/octet-stream")
-	return c.Send(encrypted)
-}
-
-// helpers
-func rangeInts(from, to int) []int {
-	result := make([]int, to-from+1)
-	for i := range result {
-		result[i] = from + i
-	}
-	return result
-}
-
-func deepCopy(src map[string]any) map[string]any {
-	b, _ := json.Marshal(src)
-	var dst map[string]any
-	json.Unmarshal(b, &dst)
-	return dst
-}

routes/api/suite/user/param_userid/area.go

@@ -1,121 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-	"math/rand"
-	"strconv"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, get)
-		app.Put(path, put)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func get(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-	m := master.GetMaster()
-
-	areaMap := m["masterAreaMap"].(map[string]any)["entries"].(map[string]any)
-	actionSetMap := m["masterActionSetMap"].(map[string]any)["entries"].(map[string]any)
-	seasonMap := m["masterSeasonBasicMap"].(map[string]any)["entries"].(map[string]any)
-
-	// userAreaMap
-	resultEntries := map[string]any{}
-	for areaId, v := range areaMap {
-		area := v.(map[string]any)
-		if area["areaType"] != "common" {
-			continue
-		}
-
-		// filter actionSets by areaId
-		var available []any
-		for _, a := range actionSetMap {
-			action := a.(map[string]any)
-			if fmt.Sprintf("%v", action["areaId"]) == areaId {
-				available = append(available, action["actionSetId"])
-			}
-		}
-
-		// shuffle + slice
-		rand.Shuffle(len(available), func(i, j int) {
-			available[i], available[j] = available[j], available[i]
-		})
-		count := min(rand.Intn(3)+1, len(available))
-
-		actionSets := make([]any, 0)
-		for _, id := range available[:count] {
-			actionSets = append(actionSets, map[string]any{
-				"actionSetId": id,
-				"status":      "already_read",
-			})
-		}
-
-		// areaItems
-		areaItems := []any{}
-		if user["areaItems"] != nil {
-			items := user["areaItems"].(map[string]any)
-			if v, ok := items[areaId]; ok {
-				areaItems = v.([]any)
-			}
-		}
-
-		resultEntries[areaId] = map[string]any{
-			"areaId":      areaId,
-			"actionSets":  actionSets,
-			"areaItemIds": areaItems,
-		}
-	}
-
-	// current season
-	now := time.Now().UnixMilli()
-	var seasonId any
-	for _, v := range seasonMap {
-		s := v.(map[string]any)
-		startAt, _ := strconv.ParseInt(s["startAt"].(string), 10, 64)
-		endAt, _ := strconv.ParseInt(s["endAt"].(string), 10, 64)
-		if startAt <= now && now < endAt {
-			seasonId = s["seasonId"]
-			break
-		}
-	}
-
-	data := map[string]any{
-		"userAreaMap": map[string]any{
-			"entries": resultEntries,
-		},
-		"backstage": nil,
-		"userSeason": map[string]any{
-			"seasonId": seasonId,
-		},
-		"userLotterySelectedBackstageTalkSetMap": nil,
-	}
-
-	encoded, err := pbutil.Encode("UserAreaCharacterResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}
-
-func put(c *fiber.Ctx) error {
-	return c.SendStatus(200)
-}

routes/api/suite/user/param_userid/area/item/recommended.go

@@ -1,121 +0,0 @@
-package item
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-	"math/rand"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, recommendedAreaItem)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func recommendedAreaItem(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("PutAreaItemRequestBody", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	m := master.GetMaster()
-	areaItemMap := m["masterAreaItemMap"].(map[string]any)["entries"].(map[string]any)
-
-	items := map[string]any{}
-	if idList, ok := decoded["areaItemIdList"].([]any); ok {
-		for _, id := range idList {
-			idStr := fmt.Sprintf("%v", id)
-			if entry, ok := areaItemMap[idStr].(map[string]any); ok {
-				areaId := fmt.Sprintf("%v", entry["areaId"])
-				if items[areaId] == nil {
-					items[areaId] = []any{}
-				}
-				items[areaId] = append(items[areaId].([]any), id)
-			}
-		}
-	}
-	user["areaItems"] = items
-	db.Save()
-
-	areaMap := m["masterAreaMap"].(map[string]any)["entries"].(map[string]any)
-	actionSetMap := m["masterActionSetMap"].(map[string]any)["entries"].(map[string]any)
-
-	var areaList []any
-	for areaId, v := range areaMap {
-		area, ok := v.(map[string]any)
-		if !ok || area["areaType"] != "common" {
-			continue
-		}
-
-		var available []any
-		for _, av := range actionSetMap {
-			a, ok := av.(map[string]any)
-			if !ok {
-				continue
-			}
-			if fmt.Sprintf("%v", a["areaId"]) == areaId {
-				available = append(available, a["actionSetId"])
-			}
-		}
-
-		rand.Shuffle(len(available), func(i, j int) {
-			available[i], available[j] = available[j], available[i]
-		})
-		count := rand.Intn(3) + 1
-		if count > len(available) {
-			count = len(available)
-		}
-
-		var actionSets []any
-		for _, id := range available[:count] {
-			actionSets = append(actionSets, map[string]any{
-				"actionSetId": id,
-				"status":      "already_read",
-			})
-		}
-
-		areaItemIds := []any{}
-		if ids, ok := items[areaId]; ok {
-			areaItemIds = ids.([]any)
-		}
-
-		areaList = append(areaList, map[string]any{
-			"areaId":      area["areaId"],
-			"actionSets":  actionSets,
-			"areaItemIds": areaItemIds,
-		})
-	}
-
-	data := map[string]any{
-		"updateResources": map[string]any{},
-		"userAreaList":    map[string]any{"entries": areaList},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserChangeAreaItemResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/area/param_areaid/actionset/param_actionsetid.go

@@ -1,20 +0,0 @@
-package actionset
-
-import (
-	"bdgrp_go/routes"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, actionSet)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func actionSet(c *fiber.Ctx) error {
-	return c.SendStatus(200)
-}

routes/api/suite/user/param_userid/character/change/use/style/status.go

@@ -1,69 +0,0 @@
-package style
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func handle(c *fiber.Ctx) error {
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserCharacterChangeUseStyleStatusRequest", decrypted)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	user := db.FindUser(c.Params("userid"))
-	if user["msk"] == nil {
-		user["msk"] = map[string]any{}
-	}
-
-	msk := user["msk"].(map[string]any)
-	useCharacterId := 15
-	if decoded["status"] == "another" {
-		useCharacterId = 601
-	}
-
-	msk["useCharacterId"] = useCharacterId
-	msk["status"] = decoded["status"]
-
-	db.Save()
-
-	data := map[string]any{
-		"userCharacterUseStyleMap": map[string]any{
-			"entries": map[string]any{
-				"15": map[string]any{
-					"characterId":    15,
-					"useCharacterId": useCharacterId,
-					"status":         msk["status"],
-				},
-			},
-		},
-	}
-	encoded, err := pbutil.Encode("SuiteUserGetResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/character/param_characterid/costume/param_costumeid.go

@@ -1,67 +0,0 @@
-package costume
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-	"strconv"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, changeCostume)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func changeCostume(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	costumeid := c.Params("costumeid")
-	characterid := c.Params("characterid")
-
-	user := db.FindUser(userid)
-
-	wearingCostume := user["wearingCostume"].(map[string]any)
-	costume := wearingCostume[characterid].(map[string]any)
-	cid, _ := strconv.Atoi(costumeid)
-	costume["costumeId"] = cid
-	db.Save()
-
-	charMap := map[string]any{}
-	for charId, v := range wearingCostume {
-		c2 := v.(map[string]any)
-		charMap[charId] = map[string]any{
-			"userId":      userid,
-			"characterId": charId,
-			"costumeId":   c2["costumeId"],
-		}
-	}
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userCharacterMap": map[string]any{"entries": charMap},
-		},
-		"userCharacter": map[string]any{
-			"userId":      userid,
-			"characterId": characterid,
-			"costumeId":   costumeid,
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserCharacter", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/character/param_characterid/costume3d.go

@@ -1,74 +0,0 @@
-package param_characterid
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, changeCostume3d)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func changeCostume3d(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserWearingCostume3d", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	charId := fmt.Sprintf("%v", decoded["characterId"])
-	wearingCostume := user["wearingCostume"].(map[string]any)
-	costume := wearingCostume[charId].(map[string]any)
-	costume["dressId"] = decoded["costume3dDressId"]
-	costume["hairstyleId"] = decoded["costume3dHairstyleId"]
-	db.Save()
-
-	wearingMap := map[string]any{}
-	for cid, v := range wearingCostume {
-		c2 := v.(map[string]any)
-		wearingMap[cid] = map[string]any{
-			"characterId":          cid,
-			"costume3dDressId":     c2["dressId"],
-			"costume3dHairstyleId": c2["hairstyleId"],
-		}
-	}
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userWearingCostume3dMap": map[string]any{"entries": wearingMap},
-		},
-		"userWearingCostume3d": map[string]any{
-			"characterId":          decoded["characterId"],
-			"costume3dDressId":     decoded["costume3dDressId"],
-			"costume3dHairstyleId": decoded["costume3dHairstyleId"],
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserCostume3dChangeResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/dailylivereward.go

@@ -1,66 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func handle(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"updatedBandDeckRankList": map[string]any{},
-			"userDailyLive": map[string]any{
-				"lastClearedAt":        1770992661000,
-				"liveStartedAt":        1770992661000,
-				"getDailyLiveRewardId": 6,
-			},
-			"userDailyLiveTotalRewardHistory": map[string]any{
-				"userId":         userid,
-				"dailyLiveId":    8,
-				"status":         "STARTED",
-				"dailyLiveCount": 1,
-			},
-		},
-		"response": map[string]any{
-			"userDailyLive": map[string]any{
-				"lastClearedAt":        1770992661000,
-				"liveStartedAt":        1770992661000,
-				"getDailyLiveRewardId": 6,
-				"dailyPresents": []any{
-					map[string]any{
-						"resourceId":   43,
-						"resourceType": "practice_ticket",
-						"quantity":     1,
-						"lbBonus":      1,
-					},
-				},
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserDailyLiveClearResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/deck/param_deckid.go

@@ -1,99 +0,0 @@
-package deck
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, deck)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func deck(c *fiber.Ctx) error {
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	decoded, err := pbutil.Decode("EditUserDeckRequest", decrypted)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	userid := c.Params("userid")
-
-	user := db.FindUser(userid)
-
-	decks := user["decks"].([]any)
-	isNew := false
-	var deck map[string]any
-	for _, d := range decks {
-		d := d.(map[string]any)
-		if fmt.Sprintf("%v", d["deckId"]) == c.Params("deckid") {
-			deck = d
-			break
-		}
-	}
-
-	if deck == nil {
-		deck = map[string]any{
-			"deckId": c.Params("deckid"),
-		}
-		isNew = true
-	}
-
-	if v, ok := decoded["member1"].(float64); ok && v != 0 {
-		deck["member1"] = v
-	}
-	if v, ok := decoded["member2"].(float64); ok && v != 0 {
-		deck["member2"] = v
-	}
-	if v, ok := decoded["member3"].(float64); ok && v != 0 {
-		deck["member3"] = v
-	}
-	if v, ok := decoded["member4"].(float64); ok && v != 0 {
-		deck["member4"] = v
-	}
-	if v, ok := decoded["leader"].(float64); ok && v != 0 {
-		deck["leader"] = v
-	}
-
-	deck["deckName"] = decoded["deckName"].(string)
-	deck["deckType"] = decoded["deckType"].(string)
-
-	if isNew {
-		user["decks"] = append(user["decks"].([]any), deck)
-	}
-
-	db.Save()
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDeckList": map[string]any{
-				"entries": user["decks"].([]any),
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("EditUserDeckResponse", data)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	return c.Send(encrypted)
-
-}

routes/api/suite/user/param_userid/deco/character/3d/edit.go

@@ -1,70 +0,0 @@
-package deco3d
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, deco3d)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func deco3d(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserDecoCharacter3d", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decos := user["decos"].(map[string]any)
-	decos["3d"] = map[string]any{
-		"characterId":  decoded["characterId"],
-		"dressId":      decoded["dressId"],
-		"hairstyleId":  decoded["hairstyleId"],
-		"motionId":     decoded["motionId"],
-		"backgroundId": decoded["backgroundId"],
-	}
-	db.Save()
-
-	deco3d := decos["3d"].(map[string]any)
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDecoEquipment": map[string]any{
-				"userDecoCharacter3d": map[string]any{
-					"userId":       userid,
-					"characterId":  deco3d["characterId"],
-					"dressId":      deco3d["dressId"],
-					"hairstyleId":  deco3d["hairstyleId"],
-					"motionId":     deco3d["motionId"],
-					"backgroundId": deco3d["backgroundId"],
-				},
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserDecoCharacter3d", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/deco/character/live2d/edit.go

@@ -1,68 +0,0 @@
-package live2d
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, live2d)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func live2d(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserDecoCharacterLive2d", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decos := user["decos"].(map[string]any)
-	decos["live2d"] = map[string]any{
-		"characterId":  decoded["characterId"],
-		"costumeId":    decoded["costumeId"],
-		"motionId":     decoded["motionId"],
-		"backgroundId": decoded["backgroundId"],
-	}
-	db.Save()
-
-	live2d := decos["live2d"].(map[string]any)
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDecoEquipment": map[string]any{
-				"userDecoCharacterLive2d": map[string]any{
-					"userId":       userid,
-					"characterId":  live2d["characterId"],
-					"costumeId":    live2d["costumeId"],
-					"motionId":     live2d["motionId"],
-					"backgroundId": live2d["backgroundId"],
-				},
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserDecoCharacterLive2d", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/deco/character/situation/edit.go

@@ -1,66 +0,0 @@
-package situation
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, situation)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func situation(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserDecoCharacterSituation", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decos := user["decos"].(map[string]any)
-	decos["situation"] = map[string]any{
-		"situationId":       decoded["situationId"],
-		"situationStatus":   decoded["situationStatus"],
-		"useProfileSetting": decoded["useProfileSetting"],
-	}
-	db.Save()
-
-	sit := decos["situation"].(map[string]any)
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDecoEquipment": map[string]any{
-				"userDecoCharacterSituation": map[string]any{
-					"userId":            userid,
-					"situationId":       sit["situationId"],
-					"situationStatus":   sit["situationStatus"],
-					"useProfileSetting": sit["useProfileSetting"],
-				},
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserDecoCharacterSituation", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/deco/effect.go

@@ -1,73 +0,0 @@
-package deco
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, getEffect)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func getEffect(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-	if user == nil {
-		return c.Status(404).SendStatus(404)
-	}
-
-	m := master.GetMaster()
-	now := time.Now().UnixMilli()
-
-	decoEffectEntries := map[string]any{}
-	if deMap, ok := m["masterDecoEffectList"].(map[string]any); ok {
-		if entries, ok := deMap["entries"].([]any); ok {
-			for _, v := range entries {
-				e := v.(map[string]any)
-				startAt := int64(0)
-				endAt := int64(0)
-				if s, ok := e["startAt"].(string); ok {
-					fmt.Sscanf(s, "%d", &startAt)
-				}
-				if s, ok := e["endAt"].(string); ok {
-					fmt.Sscanf(s, "%d", &endAt)
-				}
-				if startAt <= now && now <= endAt {
-					id := fmt.Sprintf("%v", e["decoEffectId"])
-					decoEffectEntries[id] = map[string]any{
-						"userId":       userid,
-						"decoEffectId": e["decoEffectId"],
-					}
-				}
-			}
-		}
-	}
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDecoEffectInventoryMap": map[string]any{"entries": decoEffectEntries},
-			"userDecoEquipment":          utils.BuildDecoEquipment(userid, user, m),
-		},
-	}
-
-	encoded, err := pbutil.Encode("UserDecoEquipmentGetResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/deco/effect/edit.go

@@ -1,59 +0,0 @@
-package effect
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, effect)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func effect(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserDecoEffectRequestBody", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decos := user["decos"].(map[string]any)
-	decos["effect"] = decoded["decoEffectId"]
-	db.Save()
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDecoEquipment": map[string]any{
-				"userDecoEffect": map[string]any{
-					"userId":       userid,
-					"decoEffectId": decos["effect"],
-				},
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserDecoCharacterSituation", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/deco/framepins/edit.go

@@ -1,75 +0,0 @@
-package framepins
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, editFramePins)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func editFramePins(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserDecoFramePinsRequestBody", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	pins := make([]any, 5)
-	for i := 0; i < 5; i++ {
-		key := fmt.Sprintf("decoPinsId%d", i+1)
-		if v, ok := decoded[key].(float64); ok && v > 0 {
-			pins[i] = v
-		} else {
-			pins[i] = 0
-		}
-	}
-
-	decos := user["decos"].(map[string]any)
-	decos["framepins"] = pins
-	decos["frameId"] = decoded["decoFrameId"]
-	db.Save()
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDecoEquipment": map[string]any{
-				"userDecoFramePins": map[string]any{
-					"userId":      userid,
-					"decoFrameId": decos["frameId"],
-					"decoPinsId1": pins[0],
-					"decoPinsId2": pins[1],
-					"decoPinsId3": pins[2],
-					"decoPinsId4": pins[3],
-					"decoPinsId5": pins[4],
-				},
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("DecoFramePinsResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/deco/settings/character/useprofilesetting.go

@@ -1,59 +0,0 @@
-package character
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, useProfileSetting)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func useProfileSetting(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserDecoSituationUseProfileSettingRequest", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	user["useProfileSettingSituation"] = decoded["useProfileSettingSituation"]
-	db.Save()
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDecoEquipment": map[string]any{
-				"userDecoSetting": map[string]any{
-					"useProfileSettingDegree":    user["useProfileSettingDegree"],
-					"useProfileSettingSituation": user["useProfileSettingSituation"],
-					"selectedCharacterType":      user["selectedCharacterType"],
-				},
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("UserDecoEquipmentGetResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/deco/settings/degree/useprofilesetting.go

@@ -1,59 +0,0 @@
-package degree
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, useProfileSetting)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func useProfileSetting(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserDecoDegreeUseProfileSettingRequest", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	user["useProfileSettingDegree"] = decoded["useProfileSettingDegree"]
-	db.Save()
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userDecoEquipment": map[string]any{
-				"userDecoSetting": map[string]any{
-					"useProfileSettingDegree":    user["useProfileSettingDegree"],
-					"useProfileSettingSituation": user["useProfileSettingSituation"],
-					"selectedCharacterType":      user["selectedCharacterType"],
-				},
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("UserDecoEquipmentGetResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/friend/application.go

@@ -1,48 +0,0 @@
-package friend
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func handle(c *fiber.Ctx) error {
-	friendDetail := map[string]any{
-		"applicationMap":   map[string]any{},
-		"approvalMap":      map[string]any{},
-		"friendMap":        map[string]any{},
-		"friendLimit":      60,
-		"approvalLimit":    50,
-		"applicationLimit": 50,
-	}
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userFriendRelationDetail": friendDetail,
-		},
-		"userFriendDetail": friendDetail,
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserFriendTopResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/friend/approval.go

@@ -1,16 +0,0 @@
-package friend
-
-import (
-	"bdgrp_go/routes"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}

routes/api/suite/user/param_userid/friend/friend.go

@@ -1,16 +0,0 @@
-package friend
-
-import (
-	"bdgrp_go/routes"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}

routes/api/suite/user/param_userid/friend/relation.go

@@ -1,45 +0,0 @@
-package friend
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, relation)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func relation(c *fiber.Ctx) error {
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userFriendRelationDetail": map[string]any{
-				"applicationMap":   nil,
-				"approvalMap":      nil,
-				"friendMap":        nil,
-				"friendLimit":      50,
-				"approvalLimit":    50,
-				"applicationLimit": 50,
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserFriendRelationResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/gacha/param_gachaid.go

@@ -1,92 +0,0 @@
-package gacha
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-	"math/rand"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, gacha)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func gacha(c *fiber.Ctx) error {
-	gachaid := c.Params("gachaid")
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserGachaRequest", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	m := master.GetMaster()
-	gachaMap := m["masterGachaMap"].(map[string]any)["entries"].(map[string]any)
-	gachaEntry, ok := gachaMap[gachaid].(map[string]any)
-	if !ok {
-		return c.Status(404).SendString("gacha not found")
-	}
-
-	var list []any
-	if details, ok := gachaEntry["details"].([]any); ok {
-		for _, d := range details {
-			detail := d.(map[string]any)
-			if detail["rarityIndex"].(float64) == 5 {
-				list = append(list, detail["situationId"])
-			}
-		}
-	}
-
-	paymentMethodId := decoded["paymentMethodId"]
-	count := 0
-	if methods, ok := gachaEntry["paymentMethods"].([]any); ok {
-		for _, pm := range methods {
-			method := pm.(map[string]any)
-			if fmt.Sprintf("%v", method["paymentMethodId"]) == fmt.Sprintf("%v", paymentMethodId) {
-				count = int(method["count"].(float64))
-				break
-			}
-		}
-	}
-
-	entries := make([]any, count)
-	for i := range entries {
-		entries[i] = map[string]any{
-			"situationId": list[rand.Intn(len(list))],
-			"isFirstGet":  true,
-		}
-	}
-
-	data := map[string]any{
-		"gachaResults": map[string]any{
-			"entries":               entries,
-			"extras":                map[string]any{},
-			"beforeGachaSeal":       14,
-			"afterGachaSeal":        15,
-			"gachaGuaranteedRarity": "none",
-		},
-		"updateResources": map[string]any{},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserGachaResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/graphicalinformation/param_id/watch.go

@@ -1,34 +0,0 @@
-package param_id
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, watch)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func watch(c *fiber.Ctx) error {
-	data := map[string]any{
-		"userGraphicalInformationList": map[string]any{},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserGetResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/index.go

@@ -1,20 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/routes"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, index)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func index(c *fiber.Ctx) error {
-	return c.SendStatus(200)
-}

routes/api/suite/user/param_userid/loginbonus/acceptall.go

@@ -1,30 +0,0 @@
-package loginbonus
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, acceptAll)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func acceptAll(c *fiber.Ctx) error {
-	data := map[string]any{
-		"updateResources": map[string]any{},
-	}
-
-	encoded, _ := pbutil.Encode("SuiteUserLoginBonusAcceptAllResponse", data)
-
-	encrypted, _ := utils.Encrypt(encoded)
-
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/memorialstory/param_eventid/param_seq.go

@@ -1,63 +0,0 @@
-package param_eventid
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, readStory)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func readStory(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	eventid := c.Params("eventid")
-	seq := c.Params("seq")
-
-	m := master.GetMaster()
-	server := os.Getenv("SERVER")
-
-	pastData, _ := os.ReadFile(filepath.Join("pastEvents", server+".json"))
-	var past map[string]any
-	json.Unmarshal(pastData, &past)
-
-	eventStoryEntries := utils.BuildEventStoryMemorialMap(userid, m, past)
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userEventStoryMemorialMap": map[string]any{"entries": eventStoryEntries},
-		},
-		"userStoryEventReadStoryResponse": map[string]any{
-			"readUserEventStory": map[string]any{
-				"userId":  userid,
-				"eventId": eventid,
-				"seq":     seq,
-				"status":  "already_read",
-			},
-			"rewards":             map[string]any{},
-			"newlyOpenedContents": map[string]any{},
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteReadStoryResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/multiroom/param_roomid.go

@@ -1,331 +0,0 @@
-package multiroom
-
-import (
-	"fmt"
-	"strconv"
-
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, post)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-var drops = []map[string]any{
-	{"resourceType": "coin", "quantity": 10000, "lbBonus": 20},
-	{"resourceId": 1, "resourceType": "practice_ticket", "quantity": 100, "lbBonus": 20},
-	{"resourceId": 2, "resourceType": "item", "quantity": 240, "lbBonus": 20},
-	{"resourceId": 1, "resourceType": "item", "quantity": 240, "lbBonus": 20},
-	{"resourceId": 3, "resourceType": "item", "quantity": 240, "lbBonus": 20},
-	{"resourceId": 8, "resourceType": "item", "quantity": 160, "lbBonus": 20},
-	{"resourceId": 7, "resourceType": "item", "quantity": 160, "lbBonus": 20},
-	{"resourceId": 8, "resourceType": "item", "quantity": 160, "lbBonus": 20},
-}
-
-func getMultiScoreRank(
-	score uint32,
-	difficultyMaster map[string]any,
-	multiDifficulty uint32,
-) string {
-	if difficultyMaster == nil {
-		return "c"
-	}
-
-	multiMap, _ := difficultyMaster["multiLiveScoreMap"].(map[string]any)
-	target, _ := multiMap[strconv.FormatUint(uint64(multiDifficulty), 10)].(map[string]any)
-
-	if target == nil {
-		return "c"
-	}
-
-	getScore := func(key string) float64 {
-		switch value := target[key].(type) {
-		case float64:
-			return value
-		case uint32:
-			return float64(value)
-		case int:
-			return float64(value)
-		default:
-			return 0
-		}
-	}
-
-	value := float64(score)
-
-	switch {
-	case value >= getScore("scoreSS"):
-		return "ss"
-	case value >= getScore("scoreS"):
-		return "s"
-	case value >= getScore("scoreA"):
-		return "a"
-	case value >= getScore("scoreB"):
-		return "b"
-	default:
-		return "c"
-	}
-}
-
-func post(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserMultiRoomRequest", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	m := master.GetMaster()
-	if m == nil {
-		return c.Status(500).
-			SendString("master data unavailable")
-	}
-
-	musicId := uint32(decoded["musicId"].(float64))
-	musicIdString := strconv.FormatUint(uint64(musicId), 10)
-
-	difficulty := fmt.Sprintf("%v", decoded["musicDifficulty"])
-	score := uint32(decoded["score"].(float64))
-	multiScore := uint32(decoded["multiScore"].(float64))
-	multiDifficulty := uint32(decoded["multiDifficulty"].(float64))
-
-	musicScore, _ := user["musicScore"].(map[string]any)
-	if musicScore == nil {
-		musicScore = map[string]any{}
-		user["musicScore"] = musicScore
-	}
-
-	scoreData, _ := musicScore[musicIdString].(map[string]any)
-	if scoreData == nil {
-		scoreData = map[string]any{
-			"entries": []any{},
-		}
-		musicScore[musicIdString] = scoreData
-	}
-
-	entries, _ := scoreData["entries"].([]any)
-
-	diffMaster := utils.GetMusicInfo(
-		m,
-		musicIdString,
-		difficulty,
-	)
-
-	scoreInfo := map[string]any{
-		"userId":          userid,
-		"musicId":         musicId,
-		"musicDifficulty": difficulty,
-		"soloHighScore":   score,
-		"maxCombo":        decoded["combo"],
-		"soloScoreRank":   utils.GetScoreRank(float64(score), diffMaster),
-		"clearStatus":     decoded["clearStatus"],
-	}
-
-	found := false
-
-	for i, raw := range entries {
-		entry, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-
-		if fmt.Sprintf("%v", entry["musicDifficulty"]) != difficulty {
-			continue
-		}
-
-		found = true
-
-		oldScore, _ := entry["soloHighScore"].(float64)
-		if oldScore < float64(score) {
-			entries[i] = scoreInfo
-		}
-
-		break
-	}
-
-	if !found {
-		entries = append(entries, scoreInfo)
-	}
-
-	scoreData["entries"] = entries
-	db.Save()
-
-	decks, _ := user["decks"].([]any)
-	mainDeckIndex := 0
-
-	if value, ok := user["mainDeck"].(float64); ok && int(value) > 1 {
-		mainDeckIndex = int(value) - 1
-	}
-
-	if len(decks) == 0 || mainDeckIndex >= len(decks) {
-		return c.Status(500).
-			SendString("main deck unavailable")
-	}
-
-	mainDeck, _ := decks[mainDeckIndex].(map[string]any)
-
-	situationFields := []string{
-		"leader",
-		"member1",
-		"member2",
-		"member3",
-		"member4",
-	}
-
-	characterSituationMap, _ := m["masterCharacterSituationMap"].(map[string]any)
-
-	characterSituationEntries, _ := characterSituationMap["entries"].(map[string]any)
-
-	situationIDs := make([]any, 0)
-	characterIDs := make([]int, 0)
-	seenCharacters := map[int]bool{}
-
-	for _, field := range situationFields {
-		situationID, ok := mainDeck[field]
-		if !ok || situationID == nil {
-			continue
-		}
-
-		situationIDs = append(situationIDs, situationID)
-
-		entry, _ := characterSituationEntries[fmt.Sprintf("%v", situationID)].(map[string]any)
-
-		if entry == nil {
-			continue
-		}
-
-		characterID, ok := entry["characterId"].(float64)
-		if !ok {
-			continue
-		}
-
-		id := int(characterID)
-		if !seenCharacters[id] {
-			seenCharacters[id] = true
-			characterIDs = append(characterIDs, id)
-		}
-	}
-
-	userSituations := utils.BuildUserSituations(userid, m, user)
-	situationList := make([]any, 0)
-
-	for _, situationID := range situationIDs {
-		for _, raw := range userSituations {
-			situation, _ := raw.(map[string]any)
-			if fmt.Sprintf("%v", situation["situationId"]) ==
-				fmt.Sprintf("%v", situationID) {
-				situationList = append(situationList, situation)
-				break
-			}
-		}
-	}
-
-	characterRankEntries := map[string]any{}
-
-	for _, characterID := range characterIDs {
-		characterRankEntries[strconv.Itoa(characterID)] = map[string]any{
-			"rank":                   100,
-			"exp":                    0,
-			"addExp":                 0,
-			"nextExp":                0,
-			"totalExp":               0,
-			"releasedPotentialLevel": 50,
-		}
-	}
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userMusicScoreMap": utils.BuildMusicScoreMap(user),
-			"userMusicClearInfoMap": utils.ComputeMusicClearInfo(
-				musicScore,
-			),
-			"userMusicClearCountInfoMap": utils.ComputeMusicClearCountInfo(
-				musicScore,
-			),
-		},
-
-		"drops": map[string]any{
-			"entries": drops,
-		},
-
-		"newlyOpenedContents": map[string]any{},
-
-		"userBandRankList": map[string]any{
-			"entries": []any{
-				map[string]any{
-					"userId":   userid,
-					"bandId":   5,
-					"bandRank": 22,
-					"exp":      8280,
-					"addExp":   6000,
-					"totalExp": 101880,
-					"nextExp":  7520,
-				},
-			},
-		},
-
-		"userSituationList": map[string]any{
-			"entries": situationList,
-		},
-
-		"achievementRewards":      map[string]any{},
-		"lbBonus":                 20,
-		"lbUseCount":              10,
-		"soloScoreRank":           utils.GetScoreRank(float64(score), diffMaster),
-		"multiScoreRank":          getMultiScoreRank(multiScore, diffMaster, multiDifficulty),
-		"userMusicAchievementMap": map[string]any{},
-		"dairyLiveRewardReceive":  "REWARDRECEIVE",
-		"limitedDrops":            map[string]any{},
-
-		"updatedBandDeckRankList": map[string]any{
-			"entries": []any{
-				map[string]any{
-					"bandId":       5,
-					"beforeSymbol": "ss",
-					"beforeLevel":  1,
-					"afterSymbol":  "ss",
-					"afterLevel":   1,
-				},
-			},
-		},
-
-		"livePoint": 114514,
-
-		"userCharacterRankMap": map[string]any{
-			"entries": characterRankEntries,
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserMultiRoom", data)
-	if err != nil {
-		return c.Status(500).
-			SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).
-			SendString(err.Error())
-	}
-
-	c.Set("Content-Type", "application/octet-stream")
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/music/param_musicid.go

@@ -1,237 +0,0 @@
-package music
-
-import (
-	"fmt"
-	"strconv"
-
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, put)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-var drops = []map[string]any{
-	{"resourceType": "coin", "quantity": 10000, "lbBonus": 20},
-	{"resourceId": 1, "resourceType": "practice_ticket", "quantity": 100, "lbBonus": 20},
-	{"resourceId": 2, "resourceType": "item", "quantity": 240, "lbBonus": 20},
-	{"resourceId": 1, "resourceType": "item", "quantity": 240, "lbBonus": 20},
-	{"resourceId": 3, "resourceType": "item", "quantity": 240, "lbBonus": 20},
-	{"resourceId": 8, "resourceType": "item", "quantity": 160, "lbBonus": 20},
-	{"resourceId": 7, "resourceType": "item", "quantity": 160, "lbBonus": 20},
-	{"resourceId": 8, "resourceType": "item", "quantity": 160, "lbBonus": 20},
-}
-
-func put(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	musicid := c.Params("musicid")
-
-	user := db.FindUser(userid)
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserMusicRequest", decrypted)
-	if err != nil {
-		return c.Status(400).SendString(err.Error())
-	}
-
-	m := master.GetMaster()
-	if m == nil {
-		return c.Status(500).SendString("master data unavailable")
-	}
-
-	musicScore, _ := user["musicScore"].(map[string]any)
-	if musicScore == nil {
-		musicScore = map[string]any{}
-		user["musicScore"] = musicScore
-	}
-
-	scoreData, _ := musicScore[musicid].(map[string]any)
-	if scoreData == nil {
-		scoreData = map[string]any{"entries": []any{}}
-		musicScore[musicid] = scoreData
-	}
-
-	entries, _ := scoreData["entries"].([]any)
-	difficulty := fmt.Sprintf("%v", decoded["musicDifficulty"])
-	score := uint32(decoded["score"].(float64))
-
-	diffMaster := utils.GetMusicInfo(m, musicid, difficulty)
-
-	scoreInfo := map[string]any{
-		"userId":          userid,
-		"musicId":         musicid,
-		"musicDifficulty": difficulty,
-		"soloHighScore":   score,
-		"maxCombo":        decoded["combo"],
-		"soloScoreRank":   utils.GetScoreRank(float64(score), diffMaster),
-		"clearStatus":     decoded["clearStatus"],
-	}
-
-	first := true
-
-	for i, raw := range entries {
-		entry, ok := raw.(map[string]any)
-		if !ok || fmt.Sprintf("%v", entry["musicDifficulty"]) != difficulty {
-			continue
-		}
-
-		first = false
-
-		oldScore, _ := entry["soloHighScore"].(float64)
-		if oldScore < float64(score) {
-			entries[i] = scoreInfo
-		}
-
-		break
-	}
-
-	if first {
-		entries = append(entries, scoreInfo)
-	}
-
-	scoreData["entries"] = entries
-	db.Save()
-
-	decks, _ := user["decks"].([]any)
-	mainDeckIndex := 0
-
-	if value, ok := user["mainDeck"].(float64); ok && int(value) > 1 {
-		mainDeckIndex = int(value) - 1
-	}
-
-	if len(decks) == 0 || mainDeckIndex >= len(decks) {
-		return c.Status(500).SendString("main deck unavailable")
-	}
-
-	mainDeck, _ := decks[mainDeckIndex].(map[string]any)
-	situationFields := []string{"leader", "member1", "member2", "member3", "member4"}
-
-	characterSituationMap, _ := m["masterCharacterSituationMap"].(map[string]any)
-	characterSituationEntries, _ := characterSituationMap["entries"].(map[string]any)
-
-	situationIDs := make([]any, 0)
-	seen := map[int]bool{}
-	characterIDs := make([]int, 0)
-
-	for _, field := range situationFields {
-		sid, ok := mainDeck[field]
-		if !ok || sid == nil {
-			continue
-		}
-
-		situationIDs = append(situationIDs, sid)
-
-		entry, _ := characterSituationEntries[fmt.Sprintf("%v", sid)].(map[string]any)
-		if entry == nil {
-			continue
-		}
-
-		if cid, ok := entry["characterId"].(float64); ok {
-			id := int(cid)
-			if !seen[id] {
-				seen[id] = true
-				characterIDs = append(characterIDs, id)
-			}
-		}
-	}
-
-	userSituations := utils.BuildUserSituations(userid, m, user)
-	situationList := make([]any, 0)
-
-	for _, sid := range situationIDs {
-		for _, raw := range userSituations {
-			situation, _ := raw.(map[string]any)
-			if fmt.Sprintf("%v", situation["situationId"]) == fmt.Sprintf("%v", sid) {
-				situationList = append(situationList, situation)
-				break
-			}
-		}
-	}
-
-	characterRankEntries := map[string]any{}
-	for _, characterID := range characterIDs {
-		characterRankEntries[strconv.Itoa(characterID)] = map[string]any{
-			"rank": 100, "exp": 0, "addExp": 0,
-			"nextExp": 0, "totalExp": 0,
-			"releasedPotentialLevel": 50,
-		}
-	}
-
-	responseMusicScore := utils.BuildMusicScoreMap(user)
-
-	if first {
-		scoreMap := responseMusicScore["entries"].(map[string]any)
-		musicResponse := scoreMap[musicid].(map[string]any)
-		responseEntries := musicResponse["entries"].([]any)
-
-		for _, raw := range responseEntries {
-			entry := raw.(map[string]any)
-			if fmt.Sprintf("%v", entry["musicDifficulty"]) == difficulty {
-				entry["soloHighScore"] = uint32(0)
-			}
-		}
-	}
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userMusicScoreMap":          responseMusicScore,
-			"userMusicClearInfoMap":      utils.ComputeMusicClearInfo(musicScore),
-			"userMusicClearCountInfoMap": utils.ComputeMusicClearCountInfo(musicScore),
-		},
-		"drops":               map[string]any{"entries": drops},
-		"newlyOpenedContents": map[string]any{},
-		"userBandRankList": map[string]any{
-			"entries": []any{map[string]any{
-				"userId": userid, "bandId": 5, "bandRank": 22,
-				"exp": 8280, "addExp": 6000,
-				"totalExp": 101880, "nextExp": 7520,
-			}},
-		},
-		"userSituationList":       map[string]any{"entries": situationList},
-		"achievementRewards":      map[string]any{},
-		"lbBonus":                 20,
-		"lbUseCount":              10,
-		"soloScoreRank":           utils.GetScoreRank(float64(score), diffMaster),
-		"userMusicAchievementMap": map[string]any{},
-		"dairyLiveRewardReceive":  "REWARDRECEIVE",
-		"limitedDrops":            map[string]any{},
-		"updatedBandDeckRankList": map[string]any{
-			"entries": []any{map[string]any{
-				"bandId": 5, "beforeSymbol": "ss",
-				"beforeLevel": 1, "afterSymbol": "ss",
-				"afterLevel": 1,
-			}},
-		},
-		"livePoint": 114514,
-		"userCharacterRankMap": map[string]any{
-			"entries": characterRankEntries,
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserMusic", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	c.Set("Content-Type", "application/octet-stream")
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/newmusicintroduction/watching/param_id.go

@@ -1,51 +0,0 @@
-package watching
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, watch)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func watch(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	m := master.GetMaster()
-
-	entries := map[string]any{}
-	if nm, ok := m["masterNewMusicIntroductionMap"].(map[string]any); ok {
-		for _, v := range nm["entries"].(map[string]any) {
-			item := v.(map[string]any)
-			id := fmt.Sprintf("%v", item["newMusicIntroductionId"])
-			entries[id] = map[string]any{
-				"userId":                 userid,
-				"newMusicIntroductionId": item["newMusicIntroductionId"],
-				"status":                 "already_read",
-			}
-		}
-	}
-
-	data := map[string]any{
-		"userNewMusicIntroductionMap": map[string]any{"entries": entries},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserGetResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/newsituationintroduction/watching/param_id.go

@@ -1,53 +0,0 @@
-package watching
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, watch)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func watch(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	m := master.GetMaster()
-
-	entries := map[string]any{}
-	if nsi, ok := m["masterNewSituationIntroductionList"].(map[string]any); ok {
-		if list, ok := nsi["entries"].([]any); ok {
-			for _, v := range list {
-				item := v.(map[string]any)
-				id := fmt.Sprintf("%v", item["newSituationIntroductionId"])
-				entries[id] = map[string]any{
-					"userId":                     userid,
-					"newSituationIntroductionId": item["newSituationIntroductionId"],
-					"status":                     "already_read",
-				}
-			}
-		}
-	}
-
-	data := map[string]any{
-		"userNewSituationIntroductionMap": map[string]any{"entries": entries},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserGetResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/suite/user/param_userid/profile/degree.go

@@ -1,79 +0,0 @@
-package profile
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func handle(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	decoded, err := pbutil.Decode("UserDecoDegreeRequest", decrypted)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	user := db.FindUser(userid)
-
-	degree := user["degree"].([]any)
-	entries := map[string]any{}
-
-	degree[0] = decoded["degreeIdFirst"]
-	entries["first"] = map[string]any{
-		"userId":            userid,
-		"profileDegreeType": "first",
-		"degreeId":          degree[0],
-	}
-
-	if v, ok := decoded["degreeIdSecond"]; ok && v != nil && v != "" {
-		degree[1] = v
-		entries["second"] = map[string]any{
-			"userId":            userid,
-			"profileDegreeType": "second",
-			"degreeId":          degree[1],
-		}
-	} else {
-		degree[1] = nil
-	}
-
-	user["degree"] = degree
-	db.Save()
-
-	data := map[string]any{
-		"updateResources": map[string]any{
-			"userProfileDegreeMap": map[string]any{
-				"entries": entries,
-			},
-		},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserDecoDegreeResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/tcpServer/param_userid.go

@@ -1,90 +0,0 @@
-package tcpServer
-
-import (
-	"bdgrp_go/routes"
-	"crypto/tls"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-var skipReqHeaders = map[string]bool{
-	"transfer-encoding": true,
-	"connection":        true,
-	"keep-alive":        true,
-	"content-encoding":  true,
-	"content-length":    true,
-	"cf-connecting-ip":  true,
-	"cf-ray":            true,
-	"cf-visitor":        true,
-	"cf-ipcountry":      true,
-	"cf-pseudo-ipv4":    true,
-	"x-forwarded-for":   true,
-	"x-forwarded-proto": true,
-	"x-real-ip":         true,
-	"cdn-loop":          true,
-}
-
-var skipRespHeaders = map[string]bool{
-	"transfer-encoding": true,
-	"connection":        true,
-	"keep-alive":        true,
-	"content-encoding":  true,
-	"content-length":    true,
-}
-
-var client = &http.Client{
-	Transport: &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	},
-}
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func handle(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	url := fmt.Sprintf("https://l3-prod-all-bd.bilibiligame.net/api/tcpServer/%s", userid)
-
-	req, err := http.NewRequest("POST", url, strings.NewReader(string(c.Body())))
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	c.Request().Header.VisitAll(func(k, v []byte) {
-		key := strings.ToLower(string(k))
-		if !skipReqHeaders[key] {
-			req.Header.Set(string(k), string(v))
-		}
-	})
-	req.Header.Set("host", "l3-prod-all-bd.bilibiligame.net")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		fmt.Println(err)
-		return c.Status(500).SendString(err.Error())
-	}
-	defer resp.Body.Close()
-
-	for key, values := range resp.Header {
-		if !skipRespHeaders[strings.ToLower(key)] {
-			c.Set(key, values[0])
-		}
-	}
-	c.Response().Header.Del("Content-Length")
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(body)
-}

routes/api/user/index.go

@@ -123,6 +123,7 @@ func postUser(c *fiber.Ctx) error {
 		"operatingSystem": newUser["operatingSystem"],
 		"tutorialStatus":  newUser["tutorialStatus"],
 		"introduction":    newUser["introduction"],
+		"unknownString":   newUser["unknownString"],
 		"tutorialEndedAt": fmt.Sprintf("%v", newUser["tutorialEndedAt"]),
 	}
 

routes/api/user/login.go

@@ -113,6 +113,7 @@ func login(c *fiber.Ctx) error {
 		"operatingSystem": user["operatingSystem"],
 		"tutorialStatus":  user["tutorialStatus"],
 		"introduction":    user["introduction"],
+		"unknownString":   user["unknownString"],
 		"tutorialEndedAt": fmt.Sprintf("%v", user["tutorialEndedAt"]),
 	}
 

routes/api/user/param_userid/actionset/album/param_characterid.go

@@ -1,64 +0,0 @@
-package album
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-	"strconv"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, albumMap)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func albumMap(c *fiber.Ctx) error {
-	characterid, _ := strconv.Atoi(c.Params("characterid"))
-	m := master.GetMaster()
-
-	entries := map[string]any{}
-	if asm, ok := m["masterActionSetMap"].(map[string]any); ok {
-		for key, v := range asm["entries"].(map[string]any) {
-			item, ok := v.(map[string]any)
-			if !ok {
-				continue
-			}
-			charIds, ok := item["characterIds"].([]any)
-			if !ok {
-				continue
-			}
-			for _, cid := range charIds {
-				if int(cid.(float64)) == characterid {
-					entry := map[string]any{
-						"actionSetId": item["actionSetId"],
-						"balloonText": item["balloonText"],
-					}
-					if _, ok := item["endSeason"]; ok {
-						entry["isMemorial"] = true
-					}
-					entries[key] = entry
-					break
-				}
-			}
-		}
-	}
-
-	encoded, err := pbutil.Encode("UserActionSetAlbumMap", map[string]any{"entries": entries})
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/area/registeropentimearea.go

@@ -1,59 +0,0 @@
-package area
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func handle(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	m := master.GetMaster()
-
-	areaMap := m["masterAreaMap"].(map[string]any)
-	entries := areaMap["entries"].(map[string]any)
-
-	// .filter(area.areaType === "common").map(...)
-	resultEntries := map[string]any{}
-	for areaId, v := range entries {
-		area := v.(map[string]any)
-		if area["areaType"] != "common" {
-			continue
-		}
-		resultEntries[areaId] = map[string]any{
-			"userId": userid,
-			"areaId": areaId,
-		}
-	}
-
-	data := map[string]any{
-		"registerTimeOpenAreaIdList": nil,
-		"userAreaStatusMap": map[string]any{
-			"entries": resultEntries,
-		},
-	}
-
-	encoded, err := pbutil.Encode("RegisterTimeOpenAreaResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/bandstory/param_bandid.go

@@ -1,69 +0,0 @@
-package bandstory
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, handle)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-var bandStoryKeys = map[string]string{
-	"1":  "masterPoppinPartyStoryMap",
-	"2":  "masterAfterglowStoryMap",
-	"3":  "masterHelloHappyWorldStoryMap",
-	"4":  "masterPastelPalettesStoryMap",
-	"5":  "masterRoseliaStoryMap",
-	"18": "masterRaiseASuilenStoryMap",
-	"21": "masterMorfonicaStoryMap",
-	"45": "masterMyGoStoryMap",
-}
-
-func handle(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	bandid := c.Params("bandid")
-	m := master.GetMaster()
-
-	key, _ := bandStoryKeys[bandid]
-
-	storyMap := m[key].(map[string]any)
-	entries := storyMap["entries"].(map[string]any)
-
-	var result []any
-	for _, v := range entries {
-		story := v.(map[string]any)
-		result = append(result, map[string]any{
-			"userId":      userid,
-			"bandStoryId": story["bandStoryId"],
-			"bandId":      story["bandId"],
-			"status":      "already_read",
-			"seq":         story["seq"],
-		})
-	}
-
-	data := map[string]any{
-		"entries": result,
-	}
-
-	encoded, err := pbutil.Encode("UserBandStoryList", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/device/update.go

@@ -1,55 +0,0 @@
-package device
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, updateDevice)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func updateDevice(c *fiber.Ctx) error {
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	decoded, err := pbutil.Decode("DeviceInfoUpdateRequest", decrypted)
-
-	userid := c.Params("userid")
-
-	user := db.FindUser(userid)
-
-	user["deviceModel"] = decoded["deviceModel"]
-	user["operatingSystem"] = decoded["operatingSystem"]
-
-	db.Save()
-
-	data := map[string]any{
-		"deviceModel": user["deviceModel"],
-		"operatingSystem": user["operatingSystem"],
-		"clientVersion": user["clientVersion"],
-	}
-
-	encoded, err := pbutil.Encode("UserRegistration", data)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/genericanimation/param_ganimationid.go

@@ -1,51 +0,0 @@
-package genericanimation
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, animation)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func animation(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	m := master.GetMaster()
-
-	entries := map[string]any{}
-	if gam, ok := m["masterGenericAnimationMap"].(map[string]any); ok {
-		for id := range gam["entries"].(map[string]any) {
-			entries[id] = map[string]any{
-				"userId":             userid,
-				"genericAnimationId": id,
-				"status":             "already_read",
-			}
-		}
-	}
-
-	data := map[string]any{
-		"userGenericAnimationMap": map[string]any{"entries": entries},
-	}
-
-	encoded, err := pbutil.Encode("SuiteUserGetResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/liveboost.go

@@ -1,40 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, liveBoost)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func liveBoost(c *fiber.Ctx) error {
-	data := map[string]any{
-		"userId":             c.Params("userId"),
-		"liveBoost":          67,
-		"serverDate":         time.Now().UnixMilli(),
-		"liveBoostBonusType": "default",
-	}
-
-	encoded, err := pbutil.Encode("UserLiveBoost", data)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/livefever.go

@@ -1,39 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, liveFever)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func liveFever(c *fiber.Ctx) error {
-	data := map[string]any {
-		"userId": c.Params("userId"),
-		"count": 67,
-		"inActivity": true,
-		"limit": 3,
-	}
-
-	encoded, err := pbutil.Encode("UserLiveFeverCount", data)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/maindeck.go

@@ -1,38 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, mainDeck)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func mainDeck(c *fiber.Ctx) error {
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	decoded, err := pbutil.Decode("UserPutRequest", decrypted)
-
-	userid := c.Params("userid")
-
-	user := db.FindUser(userid)
-
-	user["mainDeck"] = decoded["mainDeck"]
-
-	db.Save()
-
-	return c.Send(nil)
-}

routes/api/user/param_userid/memorialstory.go

@@ -1,50 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"encoding/json"
-	"fmt"
-	"maps"
-	"os"
-	"path/filepath"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, getMemorialStory)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func getMemorialStory(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	m := master.GetMaster()
-	server := os.Getenv("SERVER")
-
-	pastData, _ := os.ReadFile(filepath.Join("pastEvents", server+".json"))
-	var past map[string]any
-	json.Unmarshal(pastData, &past)
-
-	data := map[string]any{
-		"userEventStoryMemorialMap": map[string]any{
-			"entries": utils.BuildEventStoryMemorialMap(userid, m, past),
-		},
-	}
-	maps.Copy(data, past)
-
-	encoded, err := pbutil.Encode("UserEventStoryMemorialResponse", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/multiroomfriendrecruitment.go

@@ -1,20 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/routes"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, recruitment)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func recruitment(c *fiber.Ctx) error {
-	return c.SendStatus(200)
-}

routes/api/user/param_userid/music/param_musicid.go

@@ -1,20 +0,0 @@
-package music
-
-import (
-	"bdgrp_go/routes"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, music)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func music(c *fiber.Ctx) error {
-	return c.SendStatus(200)
-}

routes/api/user/param_userid/music/param_musicid/continue.go

@@ -1,82 +0,0 @@
-package param_musicid
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"crypto/sha1"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, musicContinue)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func musicContinue(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-
-	decrypted, err := utils.Decrypt(c.Body())
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	decoded, err := pbutil.Decode("UserMusicContinueRequest", decrypted)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	user := db.FindUser(userid)
-
-	str := userid + decoded["continueCount"].(string) + decoded["continueTime"].(string)
-
-	data := map[string]any{
-		"userGamedata": map[string]any{
-			"userId":                               userid,
-			"rank":                                 user["rank"],
-			"exp":                                  user["exp"],
-			"coin":                                 user["coin"],
-			"mainDeck":                             user["mainDeck"],
-			"paidStar":                             user["paidStar"],
-			"freeStar":                             user["freeStar"],
-			"seal":                                 user["seal"],
-			"degree":                               user["degree"],
-			"publishTotalDeckPowerFlg":             user["publishTotalDeckPowerFlg"],
-			"publishBandRankFlg":                   user["publishBandRankFlg"],
-			"publishMusicClearedFlg":               user["publishMusicClearedFlg"],
-			"publishMusicFullComboFlg":             user["publishMusicFullComboFlg"],
-			"publishHighScoreRatingFlg":            user["publishHighScoreRatingFlg"],
-			"pooledExp":                            user["pooledExp"],
-			"totalExp":                             user["totalExp"],
-			"nextExp":                              user["nextExp"],
-			"publishUpdatedAtFlg":                  user["publishUpdatedAtFlg"],
-			"userPaidStarRecallResponse":           nil,
-			"startDashLoginBonusReceiveFlg":        user["startDashLoginBonusReceiveFlg"],
-			"publishMusicAllPerfectFlg":            user["publishMusicAllPerfectFlg"],
-			"publishDeckRankFlg":                   user["publishDeckRankFlg"],
-			"publishStageAchievementConditionsFlg": user["publishStageAchievementConditionsFlg"],
-			"publishStageFriendRankingFlg":         user["publishStageFriendRankingFlg"],
-			"publishCharacterRankFlg":              user["publishCharacterRankFlg"],
-			"loginDays":                            user["loginDays"],
-		},
-		"continueHash": fmt.Sprintf("%x", sha1.Sum([]byte(str))),
-	}
-
-	encoded, err := pbutil.Encode("UserMusicContinueResponse", data)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/music/param_musicid/retry.go

@@ -1,20 +0,0 @@
-package param_musicid
-
-import (
-	"bdgrp_go/routes"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Post(path, retry)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func retry(c *fiber.Ctx) error {
-	return c.SendStatus(200)
-}

routes/api/user/param_userid/present.go

@@ -1,40 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, present)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func present(c *fiber.Ctx) error {
-	data := map[string]any{
-		"pagination": map[string]any{
-			"start":  9223372036854775807,
-			"limit":  c.Query("limit"),
-			"record": 0,
-		},
-	}
-
-	encoded, err := pbutil.Encode("UserPresentLimit", data)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/presenthistory.go

@@ -1,40 +0,0 @@
-package param_userid
-
-import (
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Get(path, presentHistory)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func presentHistory(c *fiber.Ctx) error {
-	data := map[string]any{
-		"pagination": map[string]any{
-			"start":  9223372036854775807,
-			"limit":  c.Query("limit"),
-			"record": 0,
-		},
-	}
-
-	encoded, err := pbutil.Encode("UserPresentHistoryList", data)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/profile/param_usrid.go

@@ -1,99 +0,0 @@
-package profile
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, profile)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func profile(c *fiber.Ctx) error {
-	userid := c.Params("usrid")
-	user := db.FindUser(userid)
-	m := master.GetMaster()
-
-	userSituations := utils.BuildUserSituations(userid, m, user)
-	situationMap := map[string]any{}
-	for _, sit := range userSituations {
-		s := sit.(map[string]any)
-		situationMap[fmt.Sprintf("%v", s["situationId"])] = s
-	}
-
-	decks := user["decks"].([]any)
-	mainDeckIdx := 1
-	if md, ok := user["mainDeck"].(float64); ok {
-		mainDeckIdx = int(md)
-	}
-	mainDeck := decks[mainDeckIdx-1].(map[string]any)
-
-	situationIdFields := []string{"leader", "member1", "member2", "member3", "member4"}
-	var mainDeckSituations []any
-	for _, field := range situationIdFields {
-		if sid, ok := mainDeck[field]; ok && sid != nil {
-			sidStr := fmt.Sprintf("%v", sid)
-			if s, ok := situationMap[sidStr]; ok {
-				mainDeckSituations = append(mainDeckSituations, s)
-			}
-		}
-	}
-
-	userProfileDegree := utils.BuildUserProfileDegree(userid, user)
-	musicScore, _ := user["musicScore"].(map[string]any)
-
-	data := map[string]any{
-		"userName":                              user["userName"],
-		"rank":                                  user["rank"],
-		"degree":                                100,
-		"introduction":                          user["introduction"],
-		"searchableFlg":                         true,
-		"publishUpdatedAtFlg":                   true,
-		"friendApplicableFlg":                   true,
-		"publishStageChallengeFriendRankingFlg": true,
-		"mainDeckUserSituations":                map[string]any{"entries": mainDeckSituations},
-		"enabledUserAreaItems":                  map[string]any{},
-		"bandRankMap":                           map[string]any{"entries": utils.BandRankMap},
-		"userHighScoreRating": map[string]any{
-			"userPoppinPartyHighScoreMusicList":    map[string]any{},
-			"userPastelPalettesHighScoreMusicList": map[string]any{},
-			"userRoseliaHighScoreMusicList":        map[string]any{},
-			"userOtherHighScoreMusicList":          map[string]any{},
-			"userMorfonicaHighScoreMusicList":      map[string]any{},
-			"userRaiseASuilenHighScoreMusicList":   map[string]any{},
-			"userMyGOScoreMusicList":               map[string]any{},
-		},
-		"mainUserDeck":                           mainDeck,
-		"userProfileSituation":                   map[string]any{},
-		"userProfileDegreeMap":                   map[string]any{"entries": userProfileDegree},
-		"userTwitter":                            map[string]any{},
-		"userDeckTotalRatingMap":                 map[string]any{"entries": utils.DeckRatingMap},
-		"stageChallengeAchievementConditionsMap": map[string]any{},
-		"userMusicClearInfoMap":                  utils.ComputeMusicClearInfo(musicScore),
-		"userCharacterRankMap":                   utils.BuildCharacterRankMap(),
-	}
-
-	encoded, err := pbutil.Encode("UserProfile", data)
-	if err != nil {
-		fmt.Println(err)
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/profile/search/param_targetid.go

@@ -1,109 +0,0 @@
-package search
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, profileSearch)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func profileSearch(c *fiber.Ctx) error {
-	targetid := c.Params("targetid")
-	user := db.FindUser(targetid)
-
-	var data map[string]any
-
-	if user == nil {
-		data = map[string]any{"searchSuccessFlg": false}
-	} else {
-		m := master.GetMaster()
-		userid := fmt.Sprintf("%v", user["userId"])
-
-		userSituations := utils.BuildUserSituations(userid, m, user)
-		situationMap := map[string]any{}
-		for _, sit := range userSituations {
-			s := sit.(map[string]any)
-			situationMap[fmt.Sprintf("%v", s["situationId"])] = s
-		}
-
-		decks := user["decks"].([]any)
-		mainDeckIdx := 1
-		if md, ok := user["mainDeck"].(float64); ok {
-			mainDeckIdx = int(md)
-		}
-		mainDeck := decks[mainDeckIdx-1].(map[string]any)
-
-		situationIdFields := []string{"leader", "member1", "member2", "member3", "member4"}
-		var mainDeckSituations []any
-		for _, field := range situationIdFields {
-			if sid, ok := mainDeck[field]; ok && sid != nil {
-				sidStr := fmt.Sprintf("%v", sid)
-				if s, ok := situationMap[sidStr]; ok {
-					mainDeckSituations = append(mainDeckSituations, s)
-				}
-			}
-		}
-
-		userProfileDegree := utils.BuildUserProfileDegree(userid, user)
-		musicScore, _ := user["musicScore"].(map[string]any)
-
-		data = map[string]any{
-			"userProfile": map[string]any{
-				"userName":                              user["userName"],
-				"rank":                                  user["rank"],
-				"degree":                                100,
-				"introduction":                          user["introduction"],
-				"searchableFlg":                         true,
-				"publishUpdatedAtFlg":                   true,
-				"friendApplicableFlg":                   true,
-				"publishStageChallengeFriendRankingFlg": true,
-				"mainDeckUserSituations":                map[string]any{"entries": mainDeckSituations},
-				"enabledUserAreaItems":                  map[string]any{},
-				"bandRankMap":                           map[string]any{"entries": utils.BandRankMap},
-				"userHighScoreRating": map[string]any{
-					"userPoppinPartyHighScoreMusicList":    map[string]any{},
-					"userPastelPalettesHighScoreMusicList": map[string]any{},
-					"userRoseliaHighScoreMusicList":        map[string]any{},
-					"userOtherHighScoreMusicList":          map[string]any{},
-					"userMorfonicaHighScoreMusicList":      map[string]any{},
-					"userRaiseASuilenHighScoreMusicList":   map[string]any{},
-					"userMyGOScoreMusicList":               map[string]any{},
-				},
-				"mainUserDeck":                           mainDeck,
-				"userProfileSituation":                   map[string]any{},
-				"userProfileDegreeMap":                   map[string]any{"entries": userProfileDegree},
-				"userTwitter":                            map[string]any{},
-				"userDeckTotalRatingMap":                 map[string]any{"entries": utils.DeckRatingMap},
-				"stageChallengeAchievementConditionsMap": map[string]any{},
-				"userMusicClearInfoMap":                  utils.ComputeMusicClearInfo(musicScore),
-				"userCharacterRankMap":                   utils.BuildCharacterRankMap(),
-			},
-		}
-	}
-
-	encoded, err := pbutil.Encode("UserProfileSearchResponse", data)
-	if err != nil {
-		fmt.Println(err)
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		fmt.Println(err)
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes/api/user/param_userid/situation/param_situationid/illust/param_illust.go

@@ -1,112 +0,0 @@
-package illust
-
-import (
-	"bdgrp_go/db"
-	"bdgrp_go/master"
-	"bdgrp_go/pbutil"
-	"bdgrp_go/routes"
-	"bdgrp_go/utils"
-	"fmt"
-
-	"github.com/gofiber/fiber/v2"
-)
-
-func init() {
-	path := routes.PathOf()
-	routes.Register(func(app *fiber.App) {
-		app.Put(path, setIllust)
-		fmt.Println("Loaded:", path)
-	})
-}
-
-func setIllust(c *fiber.Ctx) error {
-	userid := c.Params("userid")
-	situationid := c.Params("situationid")
-	illust := c.Params("illust")
-
-	user := db.FindUser(userid)
-
-	situationIllust, _ := user["situationIllust"].(map[string]any)
-	if situationIllust == nil {
-		situationIllust = map[string]any{}
-		user["situationIllust"] = situationIllust
-	}
-	situationIllust[situationid] = illust
-	db.Save()
-
-	m := master.GetMaster()
-	charSituationMap := m["masterCharacterSituationMap"].(map[string]any)["entries"].(map[string]any)
-
-	var sit map[string]any
-	for _, v := range charSituationMap {
-		s := v.(map[string]any)
-		if fmt.Sprintf("%v", s["situationId"]) == situationid {
-			sit = s
-			break
-		}
-	}
-	if sit == nil {
-		return c.Status(404).SendString("situation not found")
-	}
-
-	maxLevel := 0
-	if paramMap, ok := sit["parameterMap"].(map[string]any); ok {
-		for k := range paramMap {
-			var level int
-			fmt.Sscanf(k, "%d", &level)
-			if level > maxLevel {
-				maxLevel = level
-			}
-		}
-	}
-
-	rarity, _ := sit["rarity"].(float64)
-	hasTraining := rarity >= 3
-
-	data := map[string]any{
-		"userId":         userid,
-		"situationId":    sit["situationId"],
-		"level":          maxLevel,
-		"exp":            0,
-		"createdAt":      sit["releasedAt"],
-		"addExp":         0,
-		"trainingStatus": map[bool]string{true: "done", false: "not_doing"}[hasTraining],
-		"duplicateCount": 0,
-		"illust":         illust,
-		"skillExp":       0,
-		"skillLevel":     5,
-		"limitBreakRank": 0,
-	}
-
-	if hasTraining {
-		training, _ := sit["training"].(map[string]any)
-		appendParam := map[string]any{
-			"userId":                        userid,
-			"situationId":                   sit["situationId"],
-			"characterPotentialPerformance": 30,
-			"characterPotentialTechnique":   30,
-			"characterPotentialVisual":      30,
-			"characterBonusPerformance":     30,
-			"characterBonusTechnique":       30,
-			"characterBonusVisual":          30,
-		}
-		if training != nil {
-			appendParam["performance"] = training["trainingPerformance"]
-			appendParam["technique"] = training["trainingTechnique"]
-			appendParam["visual"] = training["trainingVisual"]
-		}
-		data["userAppendParameter"] = appendParam
-	}
-
-	encoded, err := pbutil.Encode("UserSituation", data)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	encrypted, err := utils.Encrypt(encoded)
-	if err != nil {
-		return c.Status(500).SendString(err.Error())
-	}
-
-	return c.Send(encrypted)
-}

routes_gen.go

@@ -0,0 +1,17 @@
+// Code generated by gen/gen.go — DO NOT EDIT
+package main
+
+import (
+	_ "bdgrp_go/routes/api/acdm"
+	_ "bdgrp_go/routes/api"
+	_ "bdgrp_go/routes/api/information"
+	_ "bdgrp_go/routes/api/multiroom/create"
+	_ "bdgrp_go/routes/api/suite"
+	_ "bdgrp_go/routes/api/system"
+	_ "bdgrp_go/routes/api/user/heart"
+	_ "bdgrp_go/routes/api/user"
+	_ "bdgrp_go/routes/api/user/param_userid"
+	_ "bdgrp_go/routes/api/validation"
+	_ "bdgrp_go/routes"
+	_ "bdgrp_go/routes/upstream"
+)

utils/helper.go

@@ -1,507 +0,0 @@
-package utils
-
-import "fmt"
-
-func ComputeMusicClearInfo(musicScore map[string]any) map[string]any {
-	difficulties := []string{"easy", "normal", "hard", "expert", "special"}
-	type stat struct{ cleared, fullCombo, allPerfect int }
-	stats := map[string]*stat{}
-	for _, d := range difficulties {
-		stats[d] = &stat{}
-	}
-
-	for _, v := range musicScore {
-		data := v.(map[string]any)
-		entries, ok := data["entries"].([]any)
-		if !ok {
-			continue
-		}
-		for _, e := range entries {
-			entry := e.(map[string]any)
-			diff, _ := entry["musicDifficulty"].(string)
-			clearStatus, _ := entry["clearStatus"].(string)
-			if s, ok := stats[diff]; ok {
-				s.cleared++
-				if clearStatus == "full_combo" {
-					s.fullCombo++
-				}
-				if clearStatus == "all_perfect" {
-					s.allPerfect++
-				}
-			}
-		}
-	}
-
-	result := map[string]any{}
-	for _, d := range difficulties {
-		result[d] = map[string]any{
-			"clearedMusicCount":    stats[d].cleared,
-			"fullComboMusicCount":  stats[d].fullCombo,
-			"allPerfectMusicCount": stats[d].allPerfect,
-		}
-	}
-	return map[string]any{"entries": result}
-}
-
-func ComputeMusicClearCountInfo(musicScore map[string]any) map[string]any {
-	result := map[string]any{}
-	for id, v := range musicScore {
-		data := v.(map[string]any)
-		entries, ok := data["entries"].([]any)
-		if ok && len(entries) > 0 {
-			result[id] = len(entries)
-		}
-	}
-	return map[string]any{"entries": result}
-}
-
-func BuildUserSituations(userid string, master map[string]any, user map[string]any) []any {
-	situationMap := master["masterCharacterSituationMap"].(map[string]any)["entries"].(map[string]any)
-
-	var result []any
-	for _, v := range situationMap {
-		card := v.(map[string]any)
-		releasedAt := fmt.Sprintf("%v", card["releasedAt"])
-		if releasedAt == "4128645600000" || releasedAt == "4131237600000" {
-			continue
-		}
-
-		// maxLevel
-		maxLevel := 0
-		if paramMap, ok := card["parameterMap"].(map[string]any); ok {
-			for k := range paramMap {
-				var level int
-				fmt.Sscanf(k, "%d", &level)
-				if level > maxLevel {
-					maxLevel = level
-				}
-			}
-		}
-
-		rarity := 0
-		if r, ok := card["rarity"].(float64); ok {
-			rarity = int(r)
-		}
-		hasTraining := rarity >= 3
-
-		var ep0, ep1 map[string]any
-		if eps, ok := card["episodes"].(map[string]any); ok {
-			if entries, ok := eps["entries"].([]any); ok {
-				if len(entries) > 0 {
-					ep0, _ = entries[0].(map[string]any)
-				}
-				if len(entries) > 1 {
-					ep1, _ = entries[1].(map[string]any)
-				}
-			}
-		}
-
-		illust := "normal"
-		if hasTraining {
-			illust = "after_training"
-		}
-		if user != nil {
-			if si, ok := user["situationIllust"].(map[string]any); ok {
-				if v, ok := si[fmt.Sprintf("%v", card["situationId"])]; ok {
-					illust = fmt.Sprintf("%v", v)
-				}
-			}
-		}
-
-		trainingStatus := "not_doing"
-		if hasTraining {
-			trainingStatus = "done"
-		}
-
-		sit := map[string]any{
-			"userId":         userid,
-			"situationId":    card["situationId"],
-			"level":          maxLevel,
-			"exp":            0,
-			"createdAt":      card["releasedAt"],
-			"addExp":         0,
-			"trainingStatus": trainingStatus,
-			"duplicateCount": 0,
-			"illust":         illust,
-			"skillExp":       0,
-			"skillLevel":     5,
-			"limitBreakRank": 4,
-		}
-
-		if hasTraining {
-			t, _ := card["training"].(map[string]any)
-			perf, tech, vis := 0.0, 0.0, 0.0
-			if t != nil {
-				perf, _ = t["trainingPerformance"].(float64)
-				tech, _ = t["trainingTechnique"].(float64)
-				vis, _ = t["trainingVisual"].(float64)
-			}
-			ep0Perf, ep0Tech, ep0Vis := 0.0, 0.0, 0.0
-			ep1Perf, ep1Tech, ep1Vis := 0.0, 0.0, 0.0
-			if ep0 != nil {
-				ep0Perf, _ = ep0["appendPerformance"].(float64)
-				ep0Tech, _ = ep0["appendTechnique"].(float64)
-				ep0Vis, _ = ep0["appendVisual"].(float64)
-			}
-			if ep1 != nil {
-				ep1Perf, _ = ep1["appendPerformance"].(float64)
-				ep1Tech, _ = ep1["appendTechnique"].(float64)
-				ep1Vis, _ = ep1["appendVisual"].(float64)
-			}
-
-			sit["userAppendParameter"] = map[string]any{
-				"userId":                        userid,
-				"situationId":                   card["situationId"],
-				"performance":                   perf,
-				"technique":                     tech,
-				"visual":                        vis,
-				"characterPotentialPerformance": 30,
-				"characterPotentialTechnique":   30,
-				"characterPotentialVisual":      30,
-				"characterBonusPerformance":     30 + ep0Perf + ep1Perf,
-				"characterBonusTechnique":       30 + ep0Tech + ep1Tech,
-				"characterBonusVisual":          30 + ep0Vis + ep1Vis,
-			}
-		}
-
-		result = append(result, sit)
-	}
-	return result
-}
-
-func BuildUserProfileDegree(userid string, user map[string]any) map[string]any {
-	degree := user["degree"].([]any)
-	result := map[string]any{
-		"first": map[string]any{
-			"userId":            userid,
-			"profileDegreeType": "first",
-			"degreeId":          degree[0],
-		},
-	}
-	if len(degree) > 1 && degree[1] != nil {
-		result["second"] = map[string]any{
-			"userId":            userid,
-			"profileDegreeType": "second",
-			"degreeId":          degree[1],
-		}
-	}
-	return result
-}
-
-func BuildCharacterRankMap() map[string]any {
-	entries := map[string]any{}
-	for i := 1; i <= 40; i++ {
-		entries[fmt.Sprintf("%d", i)] = map[string]any{
-			"rank": 100, "exp": 0, "addExp": 0,
-			"nextExp": 0, "totalExp": 0, "releasedPotentialLevel": 50,
-		}
-	}
-	return map[string]any{"entries": entries}
-}
-
-func GetScoreRank(score float64, difficultyMaster map[string]any) string {
-	if difficultyMaster == nil {
-		return "c"
-	}
-	get := func(key string) float64 {
-		v, _ := difficultyMaster[key].(float64)
-		return v
-	}
-	switch {
-	case score >= get("scoreSS"):
-		return "ss"
-	case score >= get("scoreS"):
-		return "s"
-	case score >= get("scoreA"):
-		return "a"
-	case score >= get("scoreB"):
-		return "b"
-	default:
-		return "c"
-	}
-}
-
-func BuildDecoEquipment(userid string, user map[string]any, m map[string]any) map[string]any {
-	decos, _ := user["decos"].(map[string]any)
-	if decos == nil {
-		decos = map[string]any{}
-	}
-	wc, _ := user["wearingCostume"].(map[string]any)
-
-	decks := user["decks"].([]any)
-	mainDeckIdx := 1
-	if md, ok := user["mainDeck"].(float64); ok {
-		mainDeckIdx = int(md)
-	}
-	mainDeck := decks[mainDeckIdx-1].(map[string]any)
-
-	charSituationMap := m["masterCharacterSituationMap"].(map[string]any)["entries"].(map[string]any)
-	leaderSitId := fmt.Sprintf("%v", mainDeck["leader"])
-	leaderEntry, _ := charSituationMap[leaderSitId].(map[string]any)
-	leaderCharId := any(nil)
-	leaderCharIdStr := ""
-	if leaderEntry != nil {
-		leaderCharId = leaderEntry["characterId"]
-		leaderCharIdStr = fmt.Sprintf("%v", leaderCharId)
-	}
-
-	decoSit, _ := decos["situation"].(map[string]any)
-	decoSitId := any(1)
-	decoSitStatus := any("normal")
-	if decoSit != nil {
-		decoSitId = decoSit["situationId"]
-		decoSitStatus = decoSit["situationStatus"]
-	}
-
-	decoL2d, _ := decos["live2d"].(map[string]any)
-	l2dCharId := leaderCharId
-	l2dCostumeId := any(nil)
-	if wc != nil && wc[leaderCharIdStr] != nil {
-		l2dCostumeId = wc[leaderCharIdStr].(map[string]any)["costumeId"]
-	}
-	l2dMotionId := any(nil)
-	if decoL2dMap, ok := m["masterDecoCharacterLive2dMotionMap"].(map[string]any); ok {
-		var firstMotion map[string]any
-		for _, v := range decoL2dMap["entries"].(map[string]any) {
-			mot := v.(map[string]any)
-			if fmt.Sprintf("%v", mot["characterId"]) == leaderCharIdStr {
-				if firstMotion == nil || mot["seq"].(float64) < firstMotion["seq"].(float64) {
-					firstMotion = mot
-				}
-			}
-		}
-		if firstMotion != nil {
-			l2dMotionId = firstMotion["motionId"]
-		}
-	}
-	l2dBackgroundId := any(1)
-	if decoL2d != nil {
-		if v, ok := decoL2d["characterId"]; ok {
-			l2dCharId = v
-		}
-		if v, ok := decoL2d["costumeId"]; ok {
-			l2dCostumeId = v
-		}
-		if v, ok := decoL2d["motionId"]; ok {
-			l2dMotionId = v
-		}
-		if v, ok := decoL2d["backgroundId"]; ok {
-			l2dBackgroundId = v
-		}
-	}
-
-	deco3d, _ := decos["3d"].(map[string]any)
-	d3dCharId := leaderCharId
-	d3dDressId := any(nil)
-	d3dHairstyleId := any(nil)
-	if wc != nil && wc[leaderCharIdStr] != nil {
-		d3dDressId = wc[leaderCharIdStr].(map[string]any)["dressId"]
-		d3dHairstyleId = wc[leaderCharIdStr].(map[string]any)["hairstyleId"]
-	}
-	d3dMotionId := any(nil)
-	if em3Map, ok := m["masterEnableCharacter3dMotionTypeMap"].(map[string]any); ok {
-		if charEntry, ok := em3Map["entries"].(map[string]any)[leaderCharIdStr].(map[string]any); ok {
-			if decoEntry, ok := charEntry["entries"].(map[string]any)["deco"].(map[string]any); ok {
-				if entries, ok := decoEntry["entries"].([]any); ok {
-					var first map[string]any
-					for _, e := range entries {
-						entry := e.(map[string]any)
-						if first == nil || entry["seq"].(float64) < first["seq"].(float64) {
-							first = entry
-						}
-					}
-					if first != nil {
-						d3dMotionId = first["motionId"]
-					}
-				}
-			}
-		}
-	}
-	d3dBackgroundId := any(11)
-	if deco3d != nil {
-		if v, ok := deco3d["characterId"]; ok {
-			d3dCharId = v
-		}
-		if v, ok := deco3d["dressId"]; ok {
-			d3dDressId = v
-		}
-		if v, ok := deco3d["hairstyleId"]; ok {
-			d3dHairstyleId = v
-		}
-		if v, ok := deco3d["motionId"]; ok {
-			d3dMotionId = v
-		}
-		if v, ok := deco3d["backgroundId"]; ok {
-			d3dBackgroundId = v
-		}
-	}
-
-	frameId := any(1)
-	if v, ok := decos["frameId"]; ok {
-		frameId = v
-	}
-	framepins, _ := decos["framepins"].([]any)
-	getPin := func(i int) any {
-		if framepins != nil && i < len(framepins) {
-			return framepins[i]
-		}
-		return nil
-	}
-
-	userProfileDegree := BuildUserProfileDegree(userid, user)
-	decoProfileDegree := map[string]any{}
-	for k, v := range userProfileDegree {
-		entry := v.(map[string]any)
-		decoProfileDegree[k] = map[string]any{
-			"decoFrameId":       entry["userId"],
-			"profileDegreeType": entry["profileDegreeType"],
-			"degreeId":          entry["degreeId"],
-		}
-	}
-
-	decoEffectId := any(1)
-	if v, ok := decos["effect"]; ok {
-		decoEffectId = v
-	}
-
-	return map[string]any{
-		"userDecoCharacterSituation": map[string]any{
-			"userId":          userid,
-			"situationId":     decoSitId,
-			"situationStatus": decoSitStatus,
-		},
-		"userDecoCharacterLive2d": map[string]any{
-			"userId":       userid,
-			"characterId":  l2dCharId,
-			"costumeId":    l2dCostumeId,
-			"motionId":     l2dMotionId,
-			"backgroundId": l2dBackgroundId,
-		},
-		"userDecoCharacter3d": map[string]any{
-			"userId":       userid,
-			"characterId":  d3dCharId,
-			"dressId":      d3dDressId,
-			"hairstyleId":  d3dHairstyleId,
-			"motionId":     d3dMotionId,
-			"backgroundId": d3dBackgroundId,
-		},
-		"userDecoFramePins": map[string]any{
-			"userId":      userid,
-			"decoFrameId": frameId,
-			"decoPinsId1": getPin(0),
-			"decoPinsId2": getPin(1),
-			"decoPinsId3": getPin(2),
-			"decoPinsId4": getPin(3),
-			"decoPinsId5": getPin(4),
-		},
-		"userDecoDegreeMap": map[string]any{"entries": decoProfileDegree},
-		"userDecoAppealMap": map[string]any{},
-		"userDecoSetting": map[string]any{
-			"useProfileSettingDegree":    user["useProfileSettingDegree"],
-			"useProfileSettingSituation": user["useProfileSettingSituation"],
-			"selectedCharacterType":      user["selectedCharacterType"],
-		},
-		"userDecoEffect": map[string]any{
-			"userId":       userid,
-			"decoEffectId": decoEffectId,
-		},
-	}
-}
-
-func BuildEventStoryMemorialMap(userid string, m map[string]any, past map[string]any) map[string]any {
-	entries := map[string]any{}
-
-	pastStoryEntries := map[string]any{}
-	if pse, ok := past["pastEventStoryMap"].(map[string]any); ok {
-		if e, ok := pse["entries"].(map[string]any); ok {
-			pastStoryEntries = e
-		}
-	}
-
-	if escMap, ok := m["masterEventStoryMemorialConfigMap"].(map[string]any); ok {
-		for eventId := range escMap["entries"].(map[string]any) {
-			length := 0
-			if pe, ok := pastStoryEntries[eventId].(map[string]any); ok {
-				if en, ok := pe["entries"].([]any); ok {
-					length = len(en)
-				}
-			}
-			storyEntries := make([]any, length)
-			for i := range storyEntries {
-				storyEntries[i] = map[string]any{
-					"userId":  userid,
-					"eventId": eventId,
-					"seq":     i,
-					"status":  "already_read",
-				}
-			}
-			entries[eventId] = map[string]any{
-				"eventId": eventId,
-				"userEventStoryList": map[string]any{
-					"entries": storyEntries,
-				},
-				"isExistUnReadStory": false,
-				"isLocked":           false,
-			}
-		}
-	}
-	return entries
-}
-
-func GetMusicInfo(master map[string]any, musicid string, difficulty string) map[string]any {
-	musicList, _ := master["masterMusicDifficultyList"].(map[string]any)
-	entries, _ := musicList["entries"].([]any)
-
-	for _, raw := range entries {
-		entry, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-
-		if fmt.Sprintf("%v", entry["musicId"]) == musicid &&
-			fmt.Sprintf("%v", entry["difficulty"]) == difficulty {
-			return entry
-		}
-	}
-
-	return nil
-}
-
-func BuildMusicScoreMap(user map[string]any) map[string]any {
-	result := map[string]any{
-		"entries": map[string]any{},
-	}
-
-	entries := result["entries"].(map[string]any)
-
-	musicScore, _ := user["musicScore"].(map[string]any)
-	for musicid, raw := range musicScore {
-		scoreData, _ := raw.(map[string]any)
-		scoreEntries, _ := scoreData["entries"].([]any)
-
-		normalizedEntries := make([]any, 0, len(scoreEntries))
-
-		for _, rawScore := range scoreEntries {
-			score, ok := rawScore.(map[string]any)
-			if !ok {
-				continue
-			}
-
-			normalizedEntries = append(normalizedEntries, map[string]any{
-				"userId":          fmt.Sprintf("%v", user["userId"]),
-				"musicId":         musicid,
-				"musicDifficulty": score["musicDifficulty"],
-				"soloHighScore":   score["soloHighScore"],
-				"maxCombo":        score["maxCombo"],
-				"soloScoreRank":   score["soloScoreRank"],
-				"clearStatus":     score["clearStatus"],
-			})
-		}
-
-		entries[musicid] = map[string]any{
-			"entries": normalizedEntries,
-		}
-	}
-
-	return result
-}

utils/profile.go

@@ -1,21 +0,0 @@
-package utils
-
-import "fmt"
-
-var BandRankMap = func() map[string]any {
-	m := map[string]any{}
-	for _, id := range []int{1, 2, 3, 4, 5, 18, 21, 45} {
-		m[fmt.Sprintf("%d", id)] = 67
-	}
-	return m
-}()
-
-var DeckRatingMap = func() map[string]any {
-	m := map[string]any{}
-	for _, id := range []int{1, 2, 3, 4, 5, 18, 21, 45} {
-		m[fmt.Sprintf("%d", id)] = map[string]any{
-			"rank": "c", "score": 0, "lowerRating": 1, "upperRating": 1600000,
-		}
-	}
-	return m
-}()