fixed lots of bugs

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

@@ -8,6 +8,7 @@ import (
 	"bdgrp_go/utils"
 	"fmt"
 	"math/rand"
+	"strconv"
 	"time"
 
 	"github.com/gofiber/fiber/v2"
@@ -83,8 +84,8 @@ func get(c *fiber.Ctx) error {
 	var seasonId any
 	for _, v := range seasonMap {
 		s := v.(map[string]any)
-		startAt := int64(s["startAt"].(float64))
-		endAt := int64(s["endAt"].(float64))
+		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

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

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,20 @@
+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/param_characterid/costume/param_costumeid.go

@@ -0,0 +1,65 @@
+package costume
+
+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, 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)
+	costume["costumeId"] = costumeid
+	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

@@ -0,0 +1,74 @@
+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/deco/character/3d/edit.go

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,59 @@
+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/gacha/param_gachaid.go

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,34 @@
+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/memorialstory/param_eventid/param_seq.go

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,331 @@
+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 +1,237 @@
 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":         score,
+		"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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,53 @@
+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)
+}