Multi users data [1/N]

Signed-off-by: Yuan Si <do4suki@gmail.com>

.gitignore

@@ -6,7 +6,7 @@ publickey.pem
 data
 logs
 
-assets/account.db
+assets/data.db
 
 assets/api1.json
 assets/api2.json

config/config.go

@@ -4,6 +4,9 @@
 package config
 
 import (
+	"honoka-chan/utils"
+	"os"
+
 	_ "github.com/mattn/go-sqlite3"
 	"xorm.io/xorm"
 )
@@ -11,6 +14,9 @@ import (
 var (
 	ConfName  = "config.yml"
 	Conf      = &AppConfigs{}
+	ExampleDb = "assets/data.example.db"
+	MainDb    = "assets/main.db"
+	UserDb    = "assets/data.db"
 	MainEng   *xorm.Engine
 	UserEng   *xorm.Engine
 )
@@ -18,7 +24,12 @@ var (
 func init() {
 	Conf = Load(ConfName)
 
-	eng, err := xorm.NewEngine("sqlite3", "assets/main.db")
+	_, err := os.Stat(UserDb)
+	if err != nil {
+		utils.WriteAllText(UserDb, utils.ReadAllText(ExampleDb))
+	}
+
+	eng, err := xorm.NewEngine("sqlite3", MainDb)
 	if err != nil {
 		panic(err)
 	}
@@ -30,7 +41,7 @@ func init() {
 	MainEng.SetMaxOpenConns(50)
 	MainEng.SetMaxIdleConns(10)
 
-	eng, err = xorm.NewEngine("sqlite3", "assets/account.db")
+	eng, err = xorm.NewEngine("sqlite3", UserDb)
 	if err != nil {
 		panic(err)
 	}

handler/live.go

@@ -107,6 +107,11 @@ func PlayLiveHandler(ctx *gin.Context) {
 	CheckErr(err)
 	deckId := playReq.UnitDeckID
 
+	// Save Deck Id for /live/reward
+	key := "live_deck_" + userId[0]
+	err = database.LevelDb.Put([]byte(key), []byte(strconv.Itoa(deckId)))
+	CheckErr(err)
+
 	// Song type: normal / special
 	// sqlite3 doesn't support FULL OUTER JOIN so use UNION ALL here.
 	sql := `SELECT notes_setting_asset,c_rank_score,b_rank_score,a_rank_score,s_rank_score,ac_flag,swing_flag FROM live_setting_m WHERE live_setting_id IN (SELECT live_setting_id FROM normal_live_m WHERE live_difficulty_id = ? UNION ALL SELECT live_setting_id FROM special_live_m WHERE live_difficulty_id = ?)`
@@ -119,7 +124,7 @@ func PlayLiveHandler(ctx *gin.Context) {
 	// fmt.Println(c_rank_score, b_rank_score, a_rank_score, s_rank_score)
 
 	notes := []model.NotesList{}
-	fmt.Println("./assets/notes/" + notes_setting_asset)
+	// fmt.Println("./assets/notes/" + notes_setting_asset)
 	notes_list := utils.ReadAllText("./assets/notes/" + notes_setting_asset)
 	err = json.Unmarshal([]byte(notes_list), &notes)
 	CheckErr(err)
@@ -312,7 +317,7 @@ func PlayScoreHandler(ctx *gin.Context) {
 	// fmt.Println(c_rank_score, b_rank_score, a_rank_score, s_rank_score)
 
 	notes := []model.NotesList{}
-	fmt.Println("./assets/notes/" + notes_setting_asset)
+	// fmt.Println("./assets/notes/" + notes_setting_asset)
 	notes_list := utils.ReadAllText("./assets/notes/" + notes_setting_asset)
 	err = json.Unmarshal([]byte(notes_list), &notes)
 	CheckErr(err)
@@ -434,10 +439,13 @@ func PlayRewardHandler(ctx *gin.Context) {
 	err = MainEng.DB().QueryRow(sql, difficultyId, difficultyId).Scan(&c_rank_score, &b_rank_score, &a_rank_score, &s_rank_score, &c_rank_combo, &b_rank_combo, &a_rank_combo, &s_rank_combo, &ac_flag, &swing_flag)
 	CheckErr(err)
 
-	unitsList := []model.PlayRewardUnitList{}
+	key := "live_deck_" + userId[0]
-	deck, err := database.LevelDb.Get([]byte("deck_info"))
+	deckId, err := database.LevelDb.Get([]byte(key))
 	CheckErr(err)
-	err = json.Unmarshal(deck, &unitsList)
+	unitsList := []model.PlayRewardUnitList{}
+	err = UserEng.Table("deck_unit_m").Select("*").
+		Join("LEFT", "user_deck_m", "deck_unit_m.user_deck_id = user_deck_m.id").
+		Where("user_id = ? AND deck_id = ?", userId[0], string(deckId)).Find(&unitsList)
 	CheckErr(err)
 
 	totalScore := playRewardReq.ScoreSmile + playRewardReq.ScoreCool + playRewardReq.ScoreCute

handler/private.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"honoka-chan/database"
 	"honoka-chan/encrypt"
+	"honoka-chan/tools"
 	"honoka-chan/utils"
 	"io"
 	"net/http"
@@ -318,8 +319,13 @@ func AccountLoginHandler(ctx *gin.Context) {
 	defer stmt.Close()
 
 	var pass, autokey, ticket, userid string
-	err = stmt.QueryRow(phone).Scan(&pass, &autokey, &ticket, &userid)
+	rows, err := stmt.Query(phone)
 	CheckErr(err)
+	defer rows.Close()
+	for rows.Next() {
+		err = rows.Scan(&pass, &autokey, &ticket, &userid)
+		CheckErr(err)
+	}
 
 	loginResp := LoginResp{}
 	loginCode := 0
@@ -372,6 +378,8 @@ func AccountLoginHandler(ctx *gin.Context) {
 			panic(err)
 		}
 
+		tools.InitUserData(int(loginTime))
+
 		// Login Response
 		loginResp.Autokey = autokey
 		loginResp.HasRealInfo = 1

middleware/middleware.go

@@ -18,6 +18,7 @@ func CommonMid(ctx *gin.Context) {
 		res, _ := database.LevelDb.Get([]byte(userId[0]))
 		if authStr != string(res) {
 			ctx.String(http.StatusForbidden, handler.ErrorMsg)
+			ctx.Abort()
 			return
 		}
 	}
@@ -26,4 +27,6 @@ func CommonMid(ctx *gin.Context) {
 	ctx.Header("server_version", config.Conf.Server.VersionDate)
 	ctx.Header("version_up", config.Conf.Server.VersionUp)
 	ctx.Header("status_code", "200")
+
+	ctx.Next()
 }

model/live.go

@@ -397,22 +397,42 @@ type EffortPoint struct {
 	Rewards                  []Rewards `json:"rewards"`
 }
 
+// type PlayRewardUnitList struct {
+// 	UnitOwningUserID int  `json:"unit_owning_user_id"`
+// 	UnitID           int  `json:"unit_id"`
+// 	Position         int  `json:"position"`
+// 	Level            int  `json:"level"`
+// 	LevelLimitID     int  `json:"level_limit_id"`
+// 	DisplayRank      int  `json:"display_rank"`
+// 	Love             int  `json:"love"`
+// 	UnitSkillLevel   int  `json:"unit_skill_level"`
+// 	IsRankMax        bool `json:"is_rank_max"`
+// 	IsLoveMax        bool `json:"is_love_max"`
+// 	IsLevelMax       bool `json:"is_level_max"`
+// 	IsSigned         bool `json:"is_signed"`
+// 	BeforeLove       int  `json:"before_love"`
+// 	MaxLove          int  `json:"max_love"`
+// 	// Costume Costume `json:"costume,omitempty"`
+// }
+
 type PlayRewardUnitList struct {
-	UnitOwningUserID int  `json:"unit_owning_user_id"`
+	ID               int   `xorm:"id pk autoincr" json:"-"`
-	UnitID           int  `json:"unit_id"`
+	UserDeckID       int   `xorm:"user_deck_id" json:"-"`
-	Position         int  `json:"position"`
+	UnitOwningUserID int   `xorm:"unit_owning_user_id" json:"unit_owning_user_id"`
-	Level            int  `json:"level"`
+	UnitID           int   `xorm:"unit_id" json:"unit_id"`
-	LevelLimitID     int  `json:"level_limit_id"`
+	Position         int   `xorm:"position" json:"position"`
-	DisplayRank      int  `json:"display_rank"`
+	Level            int   `xorm:"level" json:"level"`
-	Love             int  `json:"love"`
+	LevelLimitID     int   `xorm:"level_limit_id" json:"level_limit_id"`
-	UnitSkillLevel   int  `json:"unit_skill_level"`
+	DisplayRank      int   `xorm:"display_rank" json:"display_rank"`
-	IsRankMax        bool `json:"is_rank_max"`
+	Love             int   `xorm:"love" json:"love"`
-	IsLoveMax        bool `json:"is_love_max"`
+	UnitSkillLevel   int   `xorm:"unit_skill_level" json:"unit_skill_level"`
-	IsLevelMax       bool `json:"is_level_max"`
+	IsRankMax        bool  `xorm:"is_rank_max" json:"is_rank_max"`
-	IsSigned         bool `json:"is_signed"`
+	IsLoveMax        bool  `xorm:"is_love_max" json:"is_love_max"`
-	BeforeLove       int  `json:"before_love"`
+	IsLevelMax       bool  `xorm:"is_level_max" json:"is_level_max"`
-	MaxLove          int  `json:"max_love"`
+	IsSigned         bool  `xorm:"is_signed" json:"is_signed"`
-	// Costume Costume `json:"costume,omitempty"`
+	BeforeLove       int   `xorm:"before_love" json:"before_love"`
+	MaxLove          int   `xorm:"max_love" json:"max_love"`
+	InsertData       int64 `xorm:"insert_date" json:"-"`
 }
 
 type BeforeUserInfo struct {

model/unit.go

@@ -21,30 +21,31 @@ type Costume struct {
 }
 
 type Active struct {
-	UnitOwningUserID            int    `json:"unit_owning_user_id"`
+	UnitOwningUserID            int    `xorm:"unit_owning_user_id pk autoincr" json:"unit_owning_user_id"`
-	UnitID                      int    `json:"unit_id"`
+	UserID                      int    `xorm:"user_id" json:"-"`
-	Exp                         int    `json:"exp"`
+	UnitID                      int    `xorm:"unit_id" json:"unit_id"`
-	NextExp                     int    `json:"next_exp"`
+	Exp                         int    `xorm:"exp" json:"exp"`
-	Level                       int    `json:"level"`
+	NextExp                     int    `xorm:"next_exp" json:"next_exp"`
-	MaxLevel                    int    `json:"max_level"`
+	Level                       int    `xorm:"level" json:"level"`
-	LevelLimitID                int    `json:"level_limit_id"`
+	MaxLevel                    int    `xorm:"max_level" json:"max_level"`
-	Rank                        int    `json:"rank"`
+	LevelLimitID                int    `xorm:"level_limit_id" json:"level_limit_id"`
-	MaxRank                     int    `json:"max_rank"`
+	Rank                        int    `xorm:"rank" json:"rank"`
-	Love                        int    `json:"love"`
+	MaxRank                     int    `xorm:"max_rank" json:"max_rank"`
-	MaxLove                     int    `json:"max_love"`
+	Love                        int    `xorm:"love" json:"love"`
-	UnitSkillExp                int    `json:"unit_skill_exp"`
+	MaxLove                     int    `xorm:"max_love" json:"max_love"`
-	UnitSkillLevel              int    `json:"unit_skill_level"`
+	UnitSkillExp                int    `xorm:"unit_skill_exp" json:"unit_skill_exp"`
-	MaxHp                       int    `json:"max_hp"`
+	UnitSkillLevel              int    `xorm:"unit_skill_level" json:"unit_skill_level"`
-	UnitRemovableSkillCapacity  int    `json:"unit_removable_skill_capacity"`
+	MaxHp                       int    `xorm:"max_hp" json:"max_hp"`
-	FavoriteFlag                bool   `json:"favorite_flag"`
+	UnitRemovableSkillCapacity  int    `xorm:"unit_removable_skill_capacity" json:"unit_removable_skill_capacity"`
-	DisplayRank                 int    `json:"display_rank"`
+	FavoriteFlag                bool   `xorm:"favorite_flag" json:"favorite_flag"`
-	IsRankMax                   bool   `json:"is_rank_max"`
+	DisplayRank                 int    `xorm:"display_rank" json:"display_rank"`
-	IsLoveMax                   bool   `json:"is_love_max"`
+	IsRankMax                   bool   `xorm:"is_rank_max" json:"is_rank_max"`
-	IsLevelMax                  bool   `json:"is_level_max"`
+	IsLoveMax                   bool   `xorm:"is_love_max" json:"is_love_max"`
-	IsSigned                    bool   `json:"is_signed"`
+	IsLevelMax                  bool   `xorm:"is_level_max" json:"is_level_max"`
-	IsSkillLevelMax             bool   `json:"is_skill_level_max"`
+	IsSigned                    bool   `xorm:"is_signed" json:"is_signed"`
-	IsRemovableSkillCapacityMax bool   `json:"is_removable_skill_capacity_max"`
+	IsSkillLevelMax             bool   `xorm:"is_skill_level_max" json:"is_skill_level_max"`
-	InsertDate                  string `json:"insert_date"`
+	IsRemovableSkillCapacityMax bool   `xorm:"is_removable_skill_capacity_max" json:"is_removable_skill_capacity_max"`
+	InsertDate                  string `xorm:"insert_date" json:"insert_date"`
 	// Costume                     Costume `json:"costume,omitempty"`
 }
 

tools/create.go

@@ -0,0 +1,273 @@
+package tools
+
+import (
+	"encoding/json"
+	"fmt"
+	"honoka-chan/model"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+type UnitData struct {
+	UnitOwningUserID            int    `xorm:"unit_owning_user_id pk autoincr" json:"unit_owning_user_id"`
+	UserID                      int    `xorm:"user_id" json:"-"`
+	UnitID                      int    `xorm:"unit_id" json:"unit_id"`
+	Exp                         int    `xorm:"exp" json:"exp"`
+	NextExp                     int    `xorm:"next_exp" json:"next_exp"`
+	Level                       int    `xorm:"level" json:"level"`
+	MaxLevel                    int    `xorm:"max_level" json:"max_level"`
+	LevelLimitID                int    `xorm:"level_limit_id" json:"level_limit_id"`
+	Rank                        int    `xorm:"rank" json:"rank"`
+	MaxRank                     int    `xorm:"max_rank" json:"max_rank"`
+	Love                        int    `xorm:"love" json:"love"`
+	MaxLove                     int    `xorm:"max_love" json:"max_love"`
+	UnitSkillExp                int    `xorm:"unit_skill_exp" json:"unit_skill_exp"`
+	UnitSkillLevel              int    `xorm:"unit_skill_level" json:"unit_skill_level"`
+	MaxHp                       int    `xorm:"max_hp" json:"max_hp"`
+	UnitRemovableSkillCapacity  int    `xorm:"unit_removable_skill_capacity" json:"unit_removable_skill_capacity"`
+	FavoriteFlag                bool   `xorm:"favorite_flag" json:"favorite_flag"`
+	DisplayRank                 int    `xorm:"display_rank" json:"display_rank"`
+	IsRankMax                   bool   `xorm:"is_rank_max" json:"is_rank_max"`
+	IsLoveMax                   bool   `xorm:"is_love_max" json:"is_love_max"`
+	IsLevelMax                  bool   `xorm:"is_level_max" json:"is_level_max"`
+	IsSigned                    bool   `xorm:"is_signed" json:"is_signed"`
+	IsSkillLevelMax             bool   `xorm:"is_skill_level_max" json:"is_skill_level_max"`
+	IsRemovableSkillCapacityMax bool   `xorm:"is_removable_skill_capacity_max" json:"is_removable_skill_capacity_max"`
+	InsertDate                  string `xorm:"insert_date" json:"insert_date"`
+}
+
+type UserDeckData struct {
+	ID         int    `xorm:"id pk autoincr"`
+	DeckID     int    `xorm:"deck_id"`
+	MainFlag   int    `xorm:"main_flag"`
+	DeckName   string `xorm:"deck_name"`
+	UserID     int    `xorm:"user_id"`
+	InsertDate int64  `xorm:"insert_date"`
+}
+
+type UnitDeckData struct {
+	ID               int   `xorm:"id pk autoincr" json:"-"`
+	UserDeckID       int   `xorm:"user_deck_id" json:"-"`
+	UnitOwningUserID int   `xorm:"unit_owning_user_id" json:"unit_owning_user_id"`
+	UnitID           int   `xorm:"unit_id" json:"unit_id"`
+	Position         int   `xorm:"position" json:"position"`
+	Level            int   `xorm:"level" json:"level"`
+	LevelLimitID     int   `xorm:"level_limit_id" json:"level_limit_id"`
+	DisplayRank      int   `xorm:"display_rank" json:"display_rank"`
+	Love             int   `xorm:"love" json:"love"`
+	UnitSkillLevel   int   `xorm:"unit_skill_level" json:"unit_skill_level"`
+	IsRankMax        bool  `xorm:"is_rank_max" json:"is_rank_max"`
+	IsLoveMax        bool  `xorm:"is_love_max" json:"is_love_max"`
+	IsLevelMax       bool  `xorm:"is_level_max" json:"is_level_max"`
+	IsSigned         bool  `xorm:"is_signed" json:"is_signed"`
+	BeforeLove       int   `xorm:"before_love" json:"before_love"`
+	MaxLove          int   `xorm:"max_love" json:"max_love"`
+	InsertData       int64 `xorm:"insert_date" json:"-"`
+}
+
+type AlbumSeries struct {
+	UnitID                        int `json:"unit_id"`
+	AlbumSeriesID                 int `json:"album_series_id"`
+	Rarity                        int `json:"rarity"`
+	RankMin                       int `json:"rank_min"`
+	RankMax                       int `json:"rank_max"`
+	HpMax                         int `json:"hp_max"`
+	DefaultRemovableSkillCapacity int `json:"default_removable_skill_capacity"`
+}
+
+func GenCommonUnitData2() {
+	sql := `SELECT unit_id,album_series_id,rarity,rank_min,rank_max,hp_max,default_removable_skill_capacity FROM unit_m WHERE unit_id NOT IN (SELECT unit_id FROM unit_m WHERE unit_type_id IN (SELECT unit_type_id FROM unit_type_m WHERE image_button_asset IS NULL AND (background_color = 'dcdbe3' AND original_attribute_id IS NULL) OR (unit_type_id IN (10,110,127,128,129) OR unit_type_id BETWEEN 131 AND 140))) ORDER BY unit_number ASC`
+	rows, err := MainEng.QueryInterface(sql)
+	CheckErr(err)
+
+	rb, err := json.Marshal(rows)
+	CheckErr(err)
+	// fmt.Println(string(rb))
+
+	// 默认卡组
+	userDeck := UserDeckData{
+		DeckID:     1,
+		MainFlag:   1,
+		DeckName:   "Default deck",
+		UserID:     1,
+		InsertDate: time.Now().Unix(),
+	}
+	_, err = UserEng.Table("user_deck_m").Insert(&userDeck)
+	CheckErr(err)
+	userDeckId := userDeck.ID
+	fmt.Println("userDeckId:", userDeckId)
+
+	position := 1
+
+	albums := []AlbumSeries{}
+	if err = json.Unmarshal(rb, &albums); err != nil {
+		panic(err)
+	}
+
+	startTime := time.Now().Add(-time.Hour * 24 * 30)
+	for _, v := range albums {
+		unitData := UnitData{}
+		startTime = startTime.Add(time.Second * 3)
+
+		unitData.UnitID = v.UnitID
+		unitData.NextExp = 0
+		unitData.Rank = v.RankMin
+		unitData.MaxRank = v.RankMax
+		unitData.MaxHp = v.HpMax
+		unitData.DisplayRank = 2
+		unitData.UnitSkillLevel = 8
+		unitData.FavoriteFlag = true
+		unitData.IsRankMax = true
+		unitData.IsLevelMax = true
+		unitData.IsLoveMax = true
+		unitData.IsSkillLevelMax = true
+		unitData.IsRemovableSkillCapacityMax = true
+		unitData.InsertDate = startTime.Local().Format("2006-01-02 03:04:05")
+		if v.Rarity != 4 {
+			unitData.LevelLimitID = 0
+			unitData.UnitRemovableSkillCapacity = v.DefaultRemovableSkillCapacity
+			unitData.IsSigned = false
+			switch v.Rarity {
+			case 1:
+				// N
+				unitData.Exp = 8000
+				unitData.Level = 40
+				unitData.MaxLevel = 40
+				unitData.Love = 50
+				unitData.MaxLove = 50
+				unitData.UnitSkillExp = 0
+				unitData.UnitSkillLevel = 0
+				unitData.FavoriteFlag = false
+				unitData.IsRankMax = false
+				unitData.IsLevelMax = false
+				unitData.IsLoveMax = false
+				unitData.IsSkillLevelMax = false
+				unitData.IsRemovableSkillCapacityMax = false
+			case 2:
+				// R
+				unitData.Exp = 13500
+				unitData.Level = 60
+				unitData.MaxLevel = 60
+				unitData.Love = 200
+				unitData.MaxLove = 200
+				unitData.UnitSkillExp = 490
+			case 3:
+				// SR
+				unitData.Exp = 36800
+				unitData.Level = 80
+				unitData.MaxLevel = 80
+				unitData.Love = 500
+				unitData.MaxLove = 500
+				unitData.UnitSkillExp = 4900
+			case 5:
+				// SSR
+				unitData.Exp = 56657
+				unitData.Level = 90
+				unitData.MaxLevel = 90
+				unitData.Love = 750
+				unitData.MaxLove = 750
+				unitData.UnitSkillExp = 12700
+			}
+		} else {
+			// UR
+			unitData.Exp = 79700
+			unitData.Level = 100
+			unitData.MaxLevel = 100
+			unitData.LevelLimitID = 2
+			unitData.Love = 1000
+			unitData.MaxLove = 1000
+			unitData.UnitSkillExp = 29900
+			unitData.UnitRemovableSkillCapacity = 8
+
+			stmt, err := MainEng.DB().Prepare("SELECT COUNT(*) AS ct FROM unit_sign_asset_m WHERE unit_id = ?")
+			CheckErr(err)
+			defer stmt.Close()
+
+			var ct int
+			err = stmt.QueryRow(v.UnitID).Scan(&ct)
+			CheckErr(err)
+
+			if ct > 0 {
+				unitData.IsSigned = true
+			} else {
+				unitData.IsSigned = false
+			}
+		}
+
+		_, err = MainEng.Table("common_unit_m").Insert(&unitData)
+		CheckErr(err)
+		// fmt.Println("Inserted ID:", unitData.UnitOwningUserID)
+
+		// 默认卡组
+		if v.AlbumSeriesID == 615 { // 仆光套
+			unitDeckData := UnitDeckData{
+				UserDeckID:       userDeckId,
+				UnitOwningUserID: unitData.UnitOwningUserID,
+				UnitID:           v.UnitID,
+				Position:         position,
+				Level:            100,
+				LevelLimitID:     2,
+				DisplayRank:      2,
+				Love:             1000,
+				UnitSkillLevel:   8,
+				IsRankMax:        true,
+				IsLoveMax:        true,
+				IsLevelMax:       true,
+				IsSigned:         unitData.IsSigned,
+				BeforeLove:       1000,
+				MaxLove:          1000,
+				InsertData:       time.Now().Unix(),
+			}
+
+			// 入库
+			_, err = UserEng.Table("deck_unit_m").Insert(&unitDeckData)
+			CheckErr(err)
+			deckUnitId := unitDeckData.ID
+			fmt.Println("deckUnitId:", deckUnitId)
+
+			//
+			position++
+		}
+	}
+}
+
+func GenCommonUnitData3() {
+	uId := 1681205441 // Hardcode for now
+	userDeck := []UserDeckData{}
+	err := UserEng.Table("user_deck_m").Where("user_id = ?", uId).Asc("deck_id").Find(&userDeck)
+	CheckErr(err)
+
+	unitDeckInfo := []model.UnitDeckInfo{}
+	for _, deck := range userDeck {
+		deckUnit := []UnitDeckData{}
+		err = UserEng.Table("deck_unit_m").Where("user_deck_id = ?", deck.ID).Asc("position").Find(&deckUnit)
+		CheckErr(err)
+
+		oUids := []model.UnitOwningUserIds{}
+		for _, unit := range deckUnit {
+			oUids = append(oUids, model.UnitOwningUserIds{
+				Position:         unit.Position,
+				UnitOwningUserID: unit.UnitOwningUserID,
+			})
+		}
+
+		mainFlag := false
+		if deck.MainFlag == 1 {
+			mainFlag = true
+		}
+		unitDeckInfo = append(unitDeckInfo, model.UnitDeckInfo{
+			UnitDeckID:        deck.DeckID,
+			MainFlag:          mainFlag,
+			DeckName:          deck.DeckName,
+			UnitOwningUserIds: oUids,
+		})
+	}
+
+	b, err := json.Marshal(unitDeckInfo)
+	CheckErr(err)
+	fmt.Println(string(b))
+}
+
+func GenCommonUnitData() {
+}

tools/gen.go

@@ -3,7 +3,6 @@ package tools
 import (
 	"encoding/json"
 	"fmt"
-	"honoka-chan/database"
 	"honoka-chan/model"
 	"honoka-chan/utils"
 	"strings"
@@ -149,7 +148,7 @@ type ProfileResp struct {
 }
 
 var (
-	CenterId int
+	CenterId = 41674
 )
 
 func GenApi1Data() {
@@ -242,143 +241,19 @@ func GenApi1Data() {
 	respAll = append(respAll, liveListResp)
 
 	// unit_list_result
-	sql = `SELECT unit_id,album_series_id,rarity,rank_min,rank_max,hp_max,default_removable_skill_capacity FROM unit_m WHERE unit_id NOT IN (SELECT unit_id FROM unit_m WHERE unit_type_id IN (SELECT unit_type_id FROM unit_type_m WHERE image_button_asset IS NULL AND (background_color = 'dcdbe3' AND original_attribute_id IS NULL) OR (unit_type_id IN (10,110,127,128,129) OR unit_type_id BETWEEN 131 AND 140))) ORDER BY unit_number ASC;`
-	rows, err = MainEng.DB().Query(sql)
-	CheckErr(err)
-
 	unitsData := []model.Active{}
-	oId := 3000000000 // 起始卡片 ID，随意设置
+	err = MainEng.Table("common_unit_m").Select("*").Find(&unitsData)
-	sdt := time.Now().Add(-time.Hour * 24 * 30)
-
-	defaultDeckUnitList := []model.PlayRewardUnitList{}
-
-	for rows.Next() {
-		unitData := model.Active{}
-		var uid, rit, rank, max_rank, hp_max, skill_capacity int
-		var album_series_id interface{}
-		err = rows.Scan(&uid, &album_series_id, &rit, &rank, &max_rank, &hp_max, &skill_capacity)
 	if err != nil {
-			fmt.Println(err)
+		panic(err)
-			continue
-		}
-		oId++
-		sdt = sdt.Add(time.Second * 3)
-
-		unitData.UnitOwningUserID = oId
-		unitData.UnitID = uid
-		unitData.NextExp = 0
-		unitData.Rank = rank
-		unitData.MaxRank = max_rank
-		unitData.MaxHp = hp_max
-		unitData.DisplayRank = 2
-		unitData.UnitSkillLevel = 8
-		unitData.FavoriteFlag = true
-		unitData.IsRankMax = true
-		unitData.IsLevelMax = true
-		unitData.IsLoveMax = true
-		unitData.IsSkillLevelMax = true
-		unitData.IsRemovableSkillCapacityMax = true
-		unitData.InsertDate = sdt.Local().Format("2006-01-02 03:04:05")
-		if rit != 4 {
-			unitData.LevelLimitID = 0
-			unitData.UnitRemovableSkillCapacity = skill_capacity
-			unitData.IsSigned = false
-			switch rit {
-			case 1:
-				// N
-				unitData.Exp = 8000
-				unitData.Level = 40
-				unitData.MaxLevel = 40
-				unitData.Love = 50
-				unitData.MaxLove = 50
-				unitData.UnitSkillExp = 0
-				unitData.UnitSkillLevel = 0
-				unitData.FavoriteFlag = false
-				unitData.IsRankMax = false
-				unitData.IsLevelMax = false
-				unitData.IsLoveMax = false
-				unitData.IsSkillLevelMax = false
-				unitData.IsRemovableSkillCapacityMax = false
-			case 2:
-				// R
-				unitData.Exp = 13500
-				unitData.Level = 60
-				unitData.MaxLevel = 60
-				unitData.Love = 200
-				unitData.MaxLove = 200
-				unitData.UnitSkillExp = 490
-			case 3:
-				// SR
-				unitData.Exp = 36800
-				unitData.Level = 80
-				unitData.MaxLevel = 80
-				unitData.Love = 500
-				unitData.MaxLove = 500
-				unitData.UnitSkillExp = 4900
-			case 5:
-				// SSR
-				unitData.Exp = 56657
-				unitData.Level = 90
-				unitData.MaxLevel = 90
-				unitData.Love = 750
-				unitData.MaxLove = 750
-				unitData.UnitSkillExp = 12700
-			}
-		} else {
-			// UR
-			unitData.Exp = 79700
-			unitData.Level = 100
-			unitData.MaxLevel = 100
-			unitData.LevelLimitID = 2
-			unitData.Love = 1000
-			unitData.MaxLove = 1000
-			unitData.UnitSkillExp = 29900
-			unitData.UnitRemovableSkillCapacity = 8
-
-			stmt, err := MainEng.DB().Prepare("SELECT COUNT(*) AS ct FROM unit_sign_asset_m WHERE unit_id = ?")
-			CheckErr(err)
-			defer stmt.Close()
-
-			var count int
-			err = stmt.QueryRow(uid).Scan(&count)
-			CheckErr(err)
-
-			if count > 0 {
-				unitData.IsSigned = true
-			} else {
-				unitData.IsSigned = false
-			}
 	}
 
-		unitsData = append(unitsData, unitData)
+	userUnits := []model.Active{}
-
+	err = UserEng.Table("user_unit_m").Select("*").Find(&userUnits)
-		// 中心位成员
+	if err != nil {
-		if uid == 3927 { // AC15 果
+		panic(err)
-			CenterId = oId
 	}
 
-		switch album_series_id := album_series_id.(type) {
+	unitsData = append(unitsData, userUnits...)
-		case int64:
-			if album_series_id == 615 {
-				// 仆光套
-				defaultDeckUnitList = append(defaultDeckUnitList, model.PlayRewardUnitList{
-					UnitOwningUserID: oId,
-					UnitID:           uid,
-					Level:            100,
-					LevelLimitID:     2,
-					DisplayRank:      2,
-					Love:             1000,
-					UnitSkillLevel:   8,
-					IsRankMax:        true,
-					IsLoveMax:        true,
-					IsLevelMax:       true,
-					IsSigned:         unitData.IsSigned,
-					BeforeLove:       1000,
-					MaxLove:          1000,
-				})
-			}
-		}
-	}
 
 	unitListResp := model.UnitAllResp{
 		// _ = model.UnitAllResp{
@@ -393,37 +268,45 @@ func GenApi1Data() {
 	respAll = append(respAll, unitListResp)
 
 	// unit_deck_result
+	uId := 1681205441 // Hardcode for now
+	userDeck := []UserDeckData{}
+	err = UserEng.Table("user_deck_m").Where("user_id = ?", uId).Asc("deck_id").Find(&userDeck)
+	CheckErr(err)
+
+	unitDeckInfo := []model.UnitDeckInfo{}
+	for _, deck := range userDeck {
+		deckUnit := []UnitDeckData{}
+		err = UserEng.Table("deck_unit_m").Where("user_deck_id = ?", deck.ID).Asc("position").Find(&deckUnit)
+		CheckErr(err)
+
 		oUids := []model.UnitOwningUserIds{}
-	for k, v := range defaultDeckUnitList[0:9] {
+		for _, unit := range deckUnit {
-		position := k + 1
-		defaultDeckUnitList[k].Position = position
 			oUids = append(oUids, model.UnitOwningUserIds{
-			Position:         position,
+				Position:         unit.Position,
-			UnitOwningUserID: v.UnitOwningUserID,
+				UnitOwningUserID: unit.UnitOwningUserID,
+			})
+		}
+
+		mainFlag := false
+		if deck.MainFlag == 1 {
+			mainFlag = true
+		}
+		unitDeckInfo = append(unitDeckInfo, model.UnitDeckInfo{
+			UnitDeckID:        deck.DeckID,
+			MainFlag:          mainFlag,
+			DeckName:          deck.DeckName,
+			UnitOwningUserIds: oUids,
 		})
 	}
 	unitDeckResp := model.UnitDeckInfoResp{
 		// _ = model.UnitDeckInfoResp{
-		Result: []model.UnitDeckInfo{
+		Result:     unitDeckInfo,
-			{
-				UnitDeckID:        1,
-				MainFlag:          true,
-				DeckName:          "Future style",
-				UnitOwningUserIds: oUids,
-			},
-		},
 		Status:     200,
 		CommandNum: false,
 		TimeStamp:  time.Now().Unix(),
 	}
 	respAll = append(respAll, unitDeckResp)
 
-	// HACK 保存卡组信息
-	deck, err := json.Marshal(defaultDeckUnitList)
-	CheckErr(err)
-	err = database.LevelDb.Put([]byte("deck_info"), deck)
-	CheckErr(err)
-
 	// unit_support_result
 	unitSupportResp := model.UnitSupportResp{
 		// _ = model.UnitSupportResp{
@@ -969,7 +852,7 @@ func GenApi2Data() {
 			FriendVarietyCnt:       0,
 			FriendNewCnt:           0,
 			PresentCnt:             0,
-			SecretBoxBadgeFlag:     true,
+			SecretBoxBadgeFlag:     false,
 			ServerDatetime:         time.Now().Format("2006-01-02 15:04:05"),
 			ServerTimestamp:        time.Now().Unix(),
 			NoticeFriendDatetime:   time.Now().Format("2006-01-02 15:04:05"),

tools/init.go

@@ -0,0 +1,151 @@
+package tools
+
+import (
+	"fmt"
+	"time"
+)
+
+type UserData struct {
+	ID            int    `xorm:"id pk autoincr"`
+	Phone         string `xorm:"phone"`
+	Password      string `xorm:"password"`
+	Autokey       string `xorm:"autokey"`
+	Ticket        string `xorm:"ticket"`
+	UserID        int    `xorm:"userid"`
+	LastLoginTime int64  `xorm:"last_login_time"`
+}
+
+type UserPref struct {
+	ID               int    `xorm:"id pk autoincr"`
+	UserID           int    `xorm:"user_id"`
+	AwardID          int    `xorm:"award_id"`
+	BackgroundID     int    `xorm:"background_id"`
+	UnitOwningUserID int    `xorm:"unit_owning_user_id"`
+	UserName         string `xorm:"user_name"`
+	UserLevel        int    `xorm:"user_level"`
+	UserDesc         string `xorm:"user_desc"`
+	UpdateTime       int64  `xorm:"update_time"`
+}
+
+func InitUserData(userId int) {
+	userList := []UserData{}
+	if userId != 0 {
+		err := UserEng.Table("users").Where("userid = ?", userId).Find(&userList)
+		CheckErr(err)
+	} else {
+		err := UserEng.Table("users").Asc("id").Find(&userList)
+		CheckErr(err)
+	}
+
+	session := UserEng.NewSession()
+	defer session.Close()
+
+	for _, user := range userList {
+		// 检查用户配置
+		exists, err := UserEng.Table("user_preference_m").Where("user_id = ?", user.UserID).Exist()
+		CheckErr(err)
+
+		if !exists {
+			// 默认中心成员（）
+			var oId int
+			_, err = MainEng.Table("common_unit_m").Cols("unit_owning_user_id").Where("unit_id = ?", 31).Get(&oId)
+			CheckErr(err)
+			fmt.Println("Center UnitOwningUserID:", oId)
+			userPref := UserPref{
+				UserID:           user.UserID,
+				AwardID:          1, // 音乃木坂学生
+				BackgroundID:     1, // 初始背景
+				UnitOwningUserID: oId,
+				UserName:         "音乃木坂学生",
+				UserLevel:        1,
+				UserDesc:         "你好。",
+				UpdateTime:       time.Now().Unix(),
+			}
+			_, err = UserEng.Table("user_preference_m").Insert(&userPref)
+			CheckErr(err)
+			fmt.Println("UserPref ID", userPref.ID)
+		} else {
+			userPref := UserPref{}
+			_, err = UserEng.Table("user_preference_m").Where("user_id = ?", user.UserID).Get(&userPref)
+			CheckErr(err)
+		}
+
+		// 检查用户卡组配置
+		exists, err = UserEng.Table("user_deck_m").Where("user_id = ?", user.UserID).Asc("deck_id").Exist()
+		CheckErr(err)
+		fmt.Println("UserDeck exists:", exists)
+
+		if !exists {
+			userDeck := UserDeckData{
+				DeckID:     1,
+				MainFlag:   1,
+				DeckName:   "队伍A",
+				UserID:     user.UserID,
+				InsertDate: time.Now().Unix(),
+			}
+
+			if err = session.Begin(); err != nil {
+				panic(err)
+			}
+
+			// 默认队伍
+			_, err = session.Table("user_deck_m").Insert(&userDeck)
+			if err != nil {
+				session.Rollback()
+				panic(err)
+			}
+			userDeckId := userDeck.ID
+			fmt.Println("New UserDeck:", userDeckId)
+
+			// 默认卡组
+			unitIds := []int{}
+			err = MainEng.Table("unit_m").Cols("unit_id").Where("album_series_id = ?", 615).Find(&unitIds)
+			if err != nil {
+				session.Rollback()
+				panic(err)
+			}
+
+			unitData := []UnitData{}
+			err = MainEng.Table("common_unit_m").In("unit_id", unitIds).Find(&unitData)
+			if err != nil {
+				session.Rollback()
+				panic(err)
+			}
+			// fmt.Println(unitData)
+
+			position := 1
+			for _, unit := range unitData {
+				unitDeckData := UnitDeckData{
+					UserDeckID:       userDeckId,
+					UnitOwningUserID: unit.UnitOwningUserID,
+					UnitID:           unit.UnitID,
+					Position:         position,
+					Level:            100,
+					LevelLimitID:     2,
+					DisplayRank:      2,
+					Love:             1000,
+					UnitSkillLevel:   8,
+					IsRankMax:        true,
+					IsLoveMax:        true,
+					IsLevelMax:       true,
+					IsSigned:         unit.IsSigned,
+					BeforeLove:       1000,
+					MaxLove:          1000,
+					InsertData:       time.Now().Unix(),
+				}
+				_, err = session.Table("deck_unit_m").Insert(&unitDeckData)
+				if err != nil {
+					session.Rollback()
+					panic(err)
+				}
+				fmt.Println("New DeckUnit:", unitDeckData.ID)
+
+				position++
+			}
+
+			if err = session.Commit(); err != nil {
+				panic(err)
+			}
+		}
+	}
+}

tools/tools.go

@@ -15,15 +15,17 @@ func init() {
 	MainEng = config.MainEng
 	UserEng = config.UserEng
 
-	GenApi1Data()
+	// GenApi1Data()
-	GenApi2Data()
+	// GenApi2Data()
-	GenApi3Data()
+	// GenApi3Data()
-	LoadApi1Data("assets/api1.json")
+	// LoadApi1Data("assets/api1.json")
-	LoadApi2Data("assets/api2.json")
+	// LoadApi2Data("assets/api2.json")
-	LoadApi3Data("assets/api3.json")
+	// LoadApi3Data("assets/api3.json")
 	// ListUnitData()
 	// go SyncNotesList()
 	// GenDownloadDb()
+	// GenCommonUnitData()
+	InitUserData(0)
 }
 
 func CheckErr(err error) {