1338 lines
37 KiB
Go
1338 lines
37 KiB
Go
package tools
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/json"
|
|
"fmt"
|
|
"honoka-chan/database"
|
|
"honoka-chan/model"
|
|
"honoka-chan/utils"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "github.com/mattn/go-sqlite3"
|
|
)
|
|
|
|
type DifficultyResult struct {
|
|
Difficulty int `json:"difficulty"`
|
|
ClearCnt int `json:"clear_cnt"`
|
|
}
|
|
|
|
type DifficultyResp struct {
|
|
Result []DifficultyResult `json:"result"`
|
|
Status int `json:"status"`
|
|
CommandNum bool `json:"commandNum"`
|
|
TimeStamp int64 `json:"timeStamp"`
|
|
}
|
|
|
|
type LoveResp struct {
|
|
Result []interface{} `json:"result"`
|
|
Status int `json:"status"`
|
|
CommandNum bool `json:"commandNum"`
|
|
TimeStamp int64 `json:"timeStamp"`
|
|
}
|
|
|
|
type UserInfo struct {
|
|
UserID int `json:"user_id"`
|
|
Name string `json:"name"`
|
|
Level int `json:"level"`
|
|
CostMax int `json:"cost_max"`
|
|
UnitMax int `json:"unit_max"`
|
|
EnergyMax int `json:"energy_max"`
|
|
FriendMax int `json:"friend_max"`
|
|
UnitCnt int `json:"unit_cnt"`
|
|
InviteCode string `json:"invite_code"`
|
|
ElapsedTimeFromLogin string `json:"elapsed_time_from_login"`
|
|
Introduction string `json:"introduction"`
|
|
}
|
|
|
|
type AccessoryInfo struct {
|
|
AccessoryOwningUserID int `json:"accessory_owning_user_id"`
|
|
AccessoryID int `json:"accessory_id"`
|
|
Exp int `json:"exp"`
|
|
NextExp int `json:"next_exp"`
|
|
Level int `json:"level"`
|
|
MaxLevel int `json:"max_level"`
|
|
RankUpCount int `json:"rank_up_count"`
|
|
FavoriteFlag bool `json:"favorite_flag"`
|
|
}
|
|
|
|
type Costume struct {
|
|
UnitID int `json:"unit_id"`
|
|
IsRankMax bool `json:"is_rank_max"`
|
|
IsSigned bool `json:"is_signed"`
|
|
}
|
|
|
|
type CenterUnitInfo struct {
|
|
UnitOwningUserID int `json:"unit_owning_user_id"`
|
|
UnitID int `json:"unit_id"`
|
|
Exp int `json:"exp"`
|
|
NextExp int `json:"next_exp"`
|
|
Level int `json:"level"`
|
|
LevelLimitID int `json:"level_limit_id"`
|
|
MaxLevel int `json:"max_level"`
|
|
Rank int `json:"rank"`
|
|
MaxRank int `json:"max_rank"`
|
|
Love int `json:"love"`
|
|
MaxLove int `json:"max_love"`
|
|
UnitSkillLevel int `json:"unit_skill_level"`
|
|
MaxHp int `json:"max_hp"`
|
|
FavoriteFlag bool `json:"favorite_flag"`
|
|
DisplayRank int `json:"display_rank"`
|
|
UnitSkillExp int `json:"unit_skill_exp"`
|
|
UnitRemovableSkillCapacity int `json:"unit_removable_skill_capacity"`
|
|
Attribute int `json:"attribute"`
|
|
Smile int `json:"smile"`
|
|
Cute int `json:"cute"`
|
|
Cool int `json:"cool"`
|
|
IsLoveMax bool `json:"is_love_max"`
|
|
IsLevelMax bool `json:"is_level_max"`
|
|
IsRankMax bool `json:"is_rank_max"`
|
|
IsSigned bool `json:"is_signed"`
|
|
IsSkillLevelMax bool `json:"is_skill_level_max"`
|
|
SettingAwardID int `json:"setting_award_id"`
|
|
RemovableSkillIds []int `json:"removable_skill_ids"`
|
|
AccessoryInfo AccessoryInfo `json:"accessory_info"`
|
|
Costume Costume `json:"costume"`
|
|
TotalSmile int `json:"total_smile"`
|
|
TotalCute int `json:"total_cute"`
|
|
TotalCool int `json:"total_cool"`
|
|
TotalHp int `json:"total_hp"`
|
|
}
|
|
|
|
type NaviUnitInfo struct {
|
|
UnitOwningUserID int `json:"unit_owning_user_id"`
|
|
UnitID int `json:"unit_id"`
|
|
Exp int `json:"exp"`
|
|
NextExp int `json:"next_exp"`
|
|
Level int `json:"level"`
|
|
MaxLevel int `json:"max_level"`
|
|
LevelLimitID int `json:"level_limit_id"`
|
|
Rank int `json:"rank"`
|
|
MaxRank int `json:"max_rank"`
|
|
Love int `json:"love"`
|
|
MaxLove int `json:"max_love"`
|
|
UnitSkillExp int `json:"unit_skill_exp"`
|
|
UnitSkillLevel int `json:"unit_skill_level"`
|
|
MaxHp int `json:"max_hp"`
|
|
UnitRemovableSkillCapacity int `json:"unit_removable_skill_capacity"`
|
|
FavoriteFlag bool `json:"favorite_flag"`
|
|
DisplayRank int `json:"display_rank"`
|
|
IsRankMax bool `json:"is_rank_max"`
|
|
IsLoveMax bool `json:"is_love_max"`
|
|
IsLevelMax bool `json:"is_level_max"`
|
|
IsSigned bool `json:"is_signed"`
|
|
IsSkillLevelMax bool `json:"is_skill_level_max"`
|
|
IsRemovableSkillCapacityMax bool `json:"is_removable_skill_capacity_max"`
|
|
InsertDate string `json:"insert_date"`
|
|
TotalSmile int `json:"total_smile"`
|
|
TotalCute int `json:"total_cute"`
|
|
TotalCool int `json:"total_cool"`
|
|
TotalHp int `json:"total_hp"`
|
|
RemovableSkillIds []int `json:"removable_skill_ids"`
|
|
}
|
|
|
|
type ProfileResult struct {
|
|
UserInfo UserInfo `json:"user_info"`
|
|
CenterUnitInfo CenterUnitInfo `json:"center_unit_info"`
|
|
NaviUnitInfo NaviUnitInfo `json:"navi_unit_info"`
|
|
IsAlliance bool `json:"is_alliance"`
|
|
FriendStatus int `json:"friend_status"`
|
|
SettingAwardID int `json:"setting_award_id"`
|
|
SettingBackgroundID int `json:"setting_background_id"`
|
|
}
|
|
|
|
type ProfileResp struct {
|
|
Result ProfileResult `json:"result"`
|
|
Status int `json:"status"`
|
|
CommandNum bool `json:"commandNum"`
|
|
TimeStamp int64 `json:"timeStamp"`
|
|
}
|
|
|
|
var (
|
|
CenterId int
|
|
)
|
|
|
|
func GenApi1Data() {
|
|
db, err := sql.Open("sqlite3", "assets/main.db")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer db.Close()
|
|
|
|
// global
|
|
var respAll []interface{}
|
|
|
|
// live_status_result
|
|
var liveDifficultyId int
|
|
normalLives := []model.NormalLiveStatusList{}
|
|
sql := `SELECT live_difficulty_id FROM normal_live_m ORDER BY live_difficulty_id ASC`
|
|
rows, err := db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
for rows.Next() {
|
|
err = rows.Scan(&liveDifficultyId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
normalLive := model.NormalLiveStatusList{
|
|
LiveDifficultyID: liveDifficultyId,
|
|
Status: 1,
|
|
HiScore: 0,
|
|
HiComboCount: 0,
|
|
ClearCnt: 0,
|
|
AchievedGoalIDList: []int{},
|
|
}
|
|
|
|
normalLives = append(normalLives, normalLive)
|
|
}
|
|
|
|
specialLives := []model.SpecialLiveStatusList{}
|
|
sql = `SELECT live_difficulty_id FROM special_live_m ORDER BY live_difficulty_id ASC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
for rows.Next() {
|
|
err = rows.Scan(&liveDifficultyId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
specialLive := model.SpecialLiveStatusList{
|
|
LiveDifficultyID: liveDifficultyId,
|
|
Status: 1,
|
|
HiScore: 0,
|
|
HiComboCount: 0,
|
|
ClearCnt: 0,
|
|
AchievedGoalIDList: []int{},
|
|
}
|
|
|
|
specialLives = append(specialLives, specialLive)
|
|
}
|
|
|
|
LiveStatusResp := model.LiveStatusResp{
|
|
// _ = model.LiveStatusResp{
|
|
Result: model.LiveStatusResult{
|
|
NormalLiveStatusList: normalLives,
|
|
SpecialLiveStatusList: specialLives,
|
|
TrainingLiveStatusList: []model.TrainingLiveStatusList{},
|
|
MarathonLiveStatusList: []interface{}{},
|
|
FreeLiveStatusList: []interface{}{},
|
|
CanResumeLive: false,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, LiveStatusResp)
|
|
|
|
// live_list_result
|
|
livesList := []model.LiveList{}
|
|
for _, v := range specialLives {
|
|
livesList = append(livesList, model.LiveList{
|
|
LiveDifficultyID: v.LiveDifficultyID,
|
|
StartDate: "2023-01-01 00:00:00",
|
|
EndDate: "2037-01-01 00:00:00",
|
|
IsRandom: false,
|
|
})
|
|
}
|
|
liveListResp := model.LiveScheduleResp{
|
|
// _ = model.LiveScheduleResp{
|
|
Result: model.LiveScheduleResult{
|
|
EventList: []interface{}{},
|
|
LiveList: livesList,
|
|
LimitedBonusList: []interface{}{},
|
|
LimitedBonusCommonList: []model.LimitedBonusCommonList{}, // 特效道具
|
|
RandomLiveList: []model.RandomLiveList{}, // 随机歌曲
|
|
FreeLiveList: []interface{}{},
|
|
TrainingLiveList: []model.TrainingLiveList{}, // 挑战歌曲
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
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 = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
unitsData := []model.Active{}
|
|
oId := 3000000000 // 起始卡片 ID，随意设置
|
|
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)
|
|
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
|
|
|
|
rs, err := db.Query("SELECT COUNT(*) AS ct FROM unit_sign_asset_m WHERE unit_id = ?", uid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
ct := 0
|
|
for rs.Next() {
|
|
err = rs.Scan(&ct)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
if ct > 0 {
|
|
unitData.IsSigned = true
|
|
} else {
|
|
unitData.IsSigned = false
|
|
}
|
|
}
|
|
|
|
unitsData = append(unitsData, unitData)
|
|
|
|
// 中心位成员
|
|
if uid == 3927 { // AC15 果
|
|
CenterId = oId
|
|
}
|
|
|
|
switch album_series_id := album_series_id.(type) {
|
|
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{
|
|
Result: model.UnitAllResult{
|
|
Active: unitsData,
|
|
Waiting: []model.Waiting{},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, unitListResp)
|
|
|
|
// unit_deck_result
|
|
oUids := []model.UnitOwningUserIds{}
|
|
for k, v := range defaultDeckUnitList[0:9] {
|
|
position := k + 1
|
|
defaultDeckUnitList[k].Position = position
|
|
oUids = append(oUids, model.UnitOwningUserIds{
|
|
Position: position,
|
|
UnitOwningUserID: v.UnitOwningUserID,
|
|
})
|
|
}
|
|
unitDeckResp := model.UnitDeckInfoResp{
|
|
// _ = model.UnitDeckInfoResp{
|
|
Result: []model.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)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
err = database.LevelDb.Put([]byte("deck_info"), deck)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// unit_support_result
|
|
unitSupportResp := model.UnitSupportResp{
|
|
// _ = model.UnitSupportResp{
|
|
Result: model.UnitSupportResult{
|
|
UnitSupportList: []model.UnitSupportList{},
|
|
}, // 练习道具
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, unitSupportResp)
|
|
|
|
// owning_equip_result
|
|
rmSkillResp := model.RemovableSkillResp{
|
|
// _ = model.RemovableSkillResp{
|
|
Result: model.RemovableSkillResult{
|
|
OwningInfo: []model.OwningInfo{},
|
|
EquipmentInfo: []interface{}{},
|
|
}, // 宝石
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, rmSkillResp)
|
|
|
|
// costume_list_result
|
|
costumeListResp := model.CostumeListResp{
|
|
// _ = model.CostumeListResp{
|
|
Result: model.CostumeListResult{
|
|
CostumeList: []model.CostumeList{},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, costumeListResp)
|
|
|
|
// album_unit_result
|
|
albumLists := []model.AlbumResult{}
|
|
sql = `SELECT unit_id,rarity FROM unit_m ORDER BY unit_id ASC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
for rows.Next() {
|
|
albumList := model.AlbumResult{
|
|
RankMaxFlag: true,
|
|
LoveMaxFlag: true,
|
|
RankLevelMaxFlag: true,
|
|
AllMaxFlag: true,
|
|
FavoritePoint: 1000,
|
|
}
|
|
var uid, rit int
|
|
err = rows.Scan(&uid, &rit)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
albumList.UnitID = uid
|
|
if rit != 4 {
|
|
albumList.SignFlag = false
|
|
if rit == 1 {
|
|
albumList.HighestLovePerUnit = 50
|
|
albumList.TotalLove = 50
|
|
} else if rit == 2 {
|
|
albumList.HighestLovePerUnit = 200
|
|
albumList.TotalLove = 200
|
|
} else if rit == 3 {
|
|
albumList.HighestLovePerUnit = 500
|
|
albumList.TotalLove = 500
|
|
} else if rit == 5 {
|
|
albumList.HighestLovePerUnit = 750
|
|
albumList.TotalLove = 750
|
|
}
|
|
} else {
|
|
albumList.HighestLovePerUnit = 1000
|
|
albumList.TotalLove = 1000
|
|
|
|
rs, err := db.Query("SELECT COUNT(*) AS ct FROM unit_sign_asset_m WHERE unit_id = ?", uid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
ct := 0
|
|
for rs.Next() {
|
|
err = rs.Scan(&ct)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
if ct > 0 {
|
|
albumList.SignFlag = true
|
|
} else {
|
|
albumList.SignFlag = false
|
|
}
|
|
}
|
|
|
|
albumLists = append(albumLists, albumList)
|
|
}
|
|
|
|
albumResp := model.AlbumResp{
|
|
// _ = model.AlbumResp{
|
|
Result: albumLists,
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, albumResp)
|
|
|
|
// scenario_status_result
|
|
sql = `SELECT scenario_id FROM scenario_m ORDER BY scenario_id ASC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
scenarioLists := []model.ScenarioStatusList{}
|
|
for rows.Next() {
|
|
var sid int
|
|
err = rows.Scan(&sid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
scenarioLists = append(scenarioLists, model.ScenarioStatusList{
|
|
ScenarioID: sid,
|
|
Status: 2,
|
|
})
|
|
}
|
|
scenarioResp := model.ScenarioStatusResp{
|
|
// _ = model.ScenarioStatusResp{
|
|
Result: model.ScenarioStatusResult{
|
|
ScenarioStatusList: scenarioLists,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, scenarioResp)
|
|
|
|
// subscenario_status_result
|
|
sql = `SELECT subscenario_id FROM subscenario_m ORDER BY subscenario_id ASC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
subScenarioLists := []model.SubscenarioStatusList{}
|
|
for rows.Next() {
|
|
var sid int
|
|
err = rows.Scan(&sid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
subScenarioLists = append(subScenarioLists, model.SubscenarioStatusList{
|
|
SubscenarioID: sid,
|
|
Status: 2,
|
|
})
|
|
}
|
|
subScenarioResp := model.SubscenarioStatusResp{
|
|
// _ = model.SubscenarioStatusResp{
|
|
Result: model.SubscenarioStatusResult{
|
|
SubscenarioStatusList: subScenarioLists,
|
|
UnlockedSubscenarioIds: []interface{}{},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, subScenarioResp)
|
|
|
|
// event_scenario_result
|
|
eventsList := []model.EventScenarioList{}
|
|
sql = `SELECT event_id FROM event_scenario_m GROUP BY event_id ORDER BY event_id DESC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
for rows.Next() {
|
|
var eventId int
|
|
err = rows.Scan(&eventId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
sql = `SELECT event_scenario_id,chapter,chapter_asset,open_date FROM event_scenario_m WHERE event_id = ? ORDER BY chapter DESC`
|
|
chaps, err := db.Query(sql, eventId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
chapsList := []model.EventScenarioChapterList{}
|
|
var open_date string
|
|
for chaps.Next() {
|
|
var event_scenario_id, chapter int
|
|
var chapter_asset interface{}
|
|
err = chaps.Scan(&event_scenario_id, &chapter, &chapter_asset, &open_date)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
chapList := model.EventScenarioChapterList{
|
|
EventScenarioID: event_scenario_id,
|
|
Chapter: chapter,
|
|
Status: 2,
|
|
OpenFlashFlag: 0,
|
|
IsReward: false,
|
|
CostType: 1000,
|
|
ItemID: 1200,
|
|
Amount: 1,
|
|
}
|
|
if chapter_asset != nil {
|
|
chapList.ChapterAsset = chapter_asset.(string)
|
|
}
|
|
|
|
chapsList = append(chapsList, chapList)
|
|
}
|
|
|
|
eventList := model.EventScenarioList{
|
|
EventID: eventId,
|
|
OpenDate: strings.ReplaceAll(open_date, "/", "-"),
|
|
ChapterList: chapsList,
|
|
}
|
|
|
|
// HACK event_scenario_btn_asset
|
|
if eventId == 10001 {
|
|
eventList.EventScenarioBtnAsset = "assets/image/ui/eventscenario/38_se_ba_t.png"
|
|
} else if eventId == 221 {
|
|
eventList.EventScenarioBtnAsset = "assets/image/ui/eventscenario/215_se_ba_t.png"
|
|
} else {
|
|
eventList.EventScenarioBtnAsset = fmt.Sprintf("assets/image/ui/eventscenario/%d_se_ba_t.png", eventId)
|
|
}
|
|
|
|
eventsList = append(eventsList, eventList)
|
|
}
|
|
eventScenarioResp := model.EventScenarioStatusResp{
|
|
// _ = model.EventScenarioStatusResp{
|
|
Result: model.EventScenarioStatusResult{
|
|
EventScenarioList: eventsList, //
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, eventScenarioResp)
|
|
|
|
// multi_unit_scenario_result
|
|
sql = `SELECT multi_unit_id FROM multi_unit_scenario_m GROUP BY multi_unit_id ORDER BY multi_unit_id ASC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
var mId int
|
|
multiUnitsList := []model.MultiUnitScenarioStatusList{}
|
|
for rows.Next() {
|
|
err = rows.Scan(&mId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
sql = `SELECT multi_unit_scenario_btn_asset,open_date,multi_unit_scenario_id,chapter FROM multi_unit_scenario_m a LEFT JOIN multi_unit_scenario_open_m b ON a.multi_unit_id = b.multi_unit_id WHERE a.multi_unit_id = ?`
|
|
units, err := db.Query(sql, mId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
var multi_unit_scenario_id, chapter int
|
|
var multi_unit_scenario_btn_asset, open_date string
|
|
for units.Next() {
|
|
err = units.Scan(&multi_unit_scenario_btn_asset, &open_date, &multi_unit_scenario_id, &chapter)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
multiUnitsList = append(multiUnitsList, model.MultiUnitScenarioStatusList{
|
|
MultiUnitID: mId,
|
|
Status: 2,
|
|
MultiUnitScenarioBtnAsset: multi_unit_scenario_btn_asset,
|
|
OpenDate: strings.ReplaceAll(open_date, "/", "-"),
|
|
ChapterList: []model.MultiUnitScenarioChapterList{
|
|
{
|
|
MultiUnitScenarioID: multi_unit_scenario_id,
|
|
Chapter: chapter,
|
|
Status: 2,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
unitsResp := model.MultiUnitScenarioStatusResp{
|
|
// _ = model.MultiUnitScenarioStatusResp{
|
|
Result: model.MultiUnitScenarioStatusResult{
|
|
MultiUnitScenarioStatusList: multiUnitsList,
|
|
UnlockedMultiUnitScenarioIds: []interface{}{},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, unitsResp)
|
|
|
|
// product_result
|
|
productResp := model.ProductListResp{
|
|
// _ = model.ProductListResp{
|
|
Result: model.ProductListResult{
|
|
RestrictionInfo: model.RestrictionInfo{
|
|
Restricted: false,
|
|
},
|
|
UnderAgeInfo: model.UnderAgeInfo{
|
|
BirthSet: false,
|
|
HasLimit: false,
|
|
LimitAmount: nil,
|
|
MonthUsed: 0,
|
|
},
|
|
SnsProductList: []model.SnsProductList{},
|
|
ProductList: []model.ProductList{},
|
|
SubscriptionList: []model.SubscriptionList{},
|
|
ShowPointShop: false,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, productResp)
|
|
|
|
// banner_result
|
|
bannerResp := model.BannerListResp{
|
|
// _ = model.BannerListResp{
|
|
Result: model.BannerListResult{
|
|
TimeLimit: "2037-12-31 23:59:59",
|
|
BannerList: []model.BannerList{
|
|
{
|
|
BannerType: 1,
|
|
TargetID: 1743,
|
|
AssetPath: "assets/image/secretbox/icon/s_ba_1743_1.png",
|
|
FixedFlag: false,
|
|
BackSide: false,
|
|
BannerID: 101151,
|
|
StartDate: "2013-04-15 00:00:00",
|
|
EndDate: "2037-12-31 23:59:59",
|
|
AddUnitStartDate: "2022-01-01 00:00:00",
|
|
},
|
|
{
|
|
BannerType: 2,
|
|
TargetID: 1,
|
|
AssetPath: "assets/image/webview/wv_ba_01.png",
|
|
WebviewURL: "/manga",
|
|
FixedFlag: false,
|
|
BackSide: true,
|
|
BannerID: 200001,
|
|
StartDate: "2016-10-15 15:00:00",
|
|
EndDate: "2037-12-31 23:59:59",
|
|
},
|
|
},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, bannerResp)
|
|
|
|
// item_marquee_result
|
|
marqueeResp := model.NoticeMarqueeResp{
|
|
// _ = model.NoticeMarqueeResp{
|
|
Result: model.NoticeMarqueeResult{
|
|
ItemCount: 0,
|
|
MarqueeList: []interface{}{},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, marqueeResp)
|
|
|
|
// user_intro_result
|
|
userIntroResp := model.UserNaviResp{
|
|
// _ = model.UserNaviResp{
|
|
Result: model.UserNaviResult{
|
|
User: model.User{
|
|
UserID: 9999999,
|
|
UnitOwningUserID: CenterId,
|
|
},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, userIntroResp)
|
|
|
|
// special_cutin_result
|
|
cutinResp := model.SpecialCutinResp{
|
|
// _ = model.SpecialCutinResp{
|
|
Result: model.SpecialCutinResult{
|
|
SpecialCutinList: []interface{}{},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, cutinResp)
|
|
|
|
// award_result
|
|
sql = `SELECT award_id FROM award_m ORDER BY award_id ASC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
awardsList := []model.AwardInfo{}
|
|
for rows.Next() {
|
|
var aId int
|
|
err = rows.Scan(&aId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
isSet := false
|
|
if aId == 113 { // 极推穗乃果
|
|
isSet = true
|
|
}
|
|
awardsList = append(awardsList, model.AwardInfo{
|
|
AwardID: aId,
|
|
IsSet: isSet,
|
|
InsertDate: time.Now().Format("2006-01-02 03:04:05"),
|
|
})
|
|
}
|
|
awardResp := model.AwardInfoResp{
|
|
// _ = model.AwardInfoResp{
|
|
Result: model.AwardInfoResult{
|
|
AwardInfo: awardsList,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, awardResp)
|
|
|
|
// background_result
|
|
sql = `SELECT background_id FROM background_m ORDER BY background_id ASC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
backgroundsList := []model.BackgroundInfo{}
|
|
for rows.Next() {
|
|
var bId int
|
|
err = rows.Scan(&bId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
isSet := false
|
|
if bId == 143 { // 穗乃果的房间[情人节]
|
|
isSet = true
|
|
}
|
|
backgroundsList = append(backgroundsList, model.BackgroundInfo{
|
|
BackgroundID: bId,
|
|
IsSet: isSet,
|
|
InsertDate: time.Now().Format("2006-01-02 03:04:05"),
|
|
})
|
|
}
|
|
backgroundResp := model.BackgroundInfoResp{
|
|
// _ = model.BackgroundInfoResp{
|
|
Result: model.BackgroundInfoResult{
|
|
BackgroundInfo: backgroundsList,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, backgroundResp)
|
|
|
|
// stamp_result 使用不到的功能就不弄了
|
|
stampResp := utils.ReadAllText("assets/stamp.json")
|
|
var mStampResp interface{}
|
|
err = json.Unmarshal([]byte(stampResp), &mStampResp)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
// _ = utils.ReadAllText("assets/stamp.json")
|
|
respAll = append(respAll, mStampResp)
|
|
|
|
// exchange_point_result
|
|
sql = `SELECT exchange_point_id FROM exchange_point_m ORDER BY exchange_point_id ASC`
|
|
rows, err = db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
exPointsList := []model.ExchangePointList{}
|
|
for rows.Next() {
|
|
var eId int
|
|
err = rows.Scan(&eId)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
exPointsList = append(exPointsList, model.ExchangePointList{
|
|
Rarity: eId,
|
|
ExchangePoint: 9999,
|
|
})
|
|
}
|
|
exPointsResp := model.ExchangePointResp{
|
|
// _ = model.ExchangePointResp{
|
|
Result: model.ExchangePointResult{
|
|
ExchangePointList: exPointsList,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, exPointsResp)
|
|
|
|
// live_se_result
|
|
liveSeResp := model.LiveSeInfoResp{
|
|
// _ = model.LiveSeInfoResp{
|
|
Result: model.LiveSeInfoResult{
|
|
LiveSeList: []int{1, 2, 3},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, liveSeResp)
|
|
|
|
// live_icon_result
|
|
liveIconResp := model.LiveIconInfoResp{
|
|
// _ = model.LiveIconInfoResp{
|
|
Result: model.LiveIconInfoResult{
|
|
LiveNotesIconList: []int{1, 2, 3},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, liveIconResp)
|
|
|
|
// item_list_result 暂时不知道部分字段啥逻辑
|
|
itemResp := utils.ReadAllText("assets/item.json")
|
|
// _ = utils.ReadAllText("assets/item.json")
|
|
var mItemResp interface{}
|
|
err = json.Unmarshal([]byte(itemResp), &mItemResp)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
respAll = append(respAll, mItemResp)
|
|
|
|
// marathon_result
|
|
marathonResp := model.MarathonInfoResp{
|
|
// _ = model.MarathonInfoResp{
|
|
Result: []interface{}{},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, marathonResp)
|
|
|
|
// challenge_result
|
|
challengeResp := model.ChallengeInfoResp{
|
|
// _ = model.ChallengeInfoResp{
|
|
Result: []interface{}{},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, challengeResp)
|
|
|
|
// Final
|
|
k, err := json.Marshal(respAll)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
resp := model.Response{
|
|
ResponseData: k,
|
|
ReleaseInfo: []interface{}{},
|
|
StatusCode: 200,
|
|
}
|
|
k, err = json.Marshal(resp)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
// fmt.Println(string(k))
|
|
|
|
utils.WriteAllText("assets/api1.json", string(k))
|
|
}
|
|
|
|
func GenApi2Data() {
|
|
db, err := sql.Open("sqlite3", "assets/main.db")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer db.Close()
|
|
|
|
// global
|
|
var respAll []interface{}
|
|
|
|
// login_topinfo_result
|
|
topInfoResp := model.TopInfoResp{
|
|
// _ = model.TopInfoResp{
|
|
Result: model.TopInfoResult{
|
|
FriendActionCnt: 0,
|
|
FriendGreetCnt: 0,
|
|
FriendVarietyCnt: 0,
|
|
FriendNewCnt: 0,
|
|
PresentCnt: 0,
|
|
SecretBoxBadgeFlag: true,
|
|
ServerDatetime: time.Now().Format("2006-01-02 15:04:05"),
|
|
ServerTimestamp: time.Now().Unix(),
|
|
NoticeFriendDatetime: time.Now().Format("2006-01-02 15:04:05"),
|
|
NoticeMailDatetime: "2000-01-01 12:00:00",
|
|
FriendsApprovalWaitCnt: 0,
|
|
FriendsRequestCnt: 0,
|
|
IsTodayBirthday: false,
|
|
LicenseInfo: model.TopInfoLicenseInfo{
|
|
LicenseList: []interface{}{},
|
|
LicensedInfo: []interface{}{},
|
|
ExpiredInfo: []interface{}{},
|
|
BadgeFlag: false,
|
|
},
|
|
UsingBuffInfo: []interface{}{},
|
|
IsKlabIDTaskFlag: false,
|
|
KlabIDTaskCanSync: false,
|
|
HasUnreadAnnounce: false,
|
|
ExchangeBadgeCnt: []int{0, 0, 0},
|
|
AdFlag: false,
|
|
HasAdReward: false,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, topInfoResp)
|
|
|
|
// login_topinfo_once_result
|
|
topInfoOnceResp := model.TopInfoOnceResp{
|
|
// _ = model.TopInfoOnceResp{
|
|
Result: model.TopInfoOnceResult{
|
|
NewAchievementCnt: 0,
|
|
UnaccomplishedAchievementCnt: 0,
|
|
LiveDailyRewardExist: false,
|
|
TrainingEnergy: 10,
|
|
TrainingEnergyMax: 10,
|
|
Notification: model.TopInfoOnceNotification{
|
|
Push: false,
|
|
Lp: false,
|
|
UpdateInfo: false,
|
|
Campaign: false,
|
|
Live: false,
|
|
Lbonus: false,
|
|
Event: false,
|
|
Secretbox: false,
|
|
Birthday: true,
|
|
},
|
|
OpenArena: true,
|
|
CostumeStatus: true,
|
|
OpenAccessory: true,
|
|
ArenaSiSkillUniqueCheck: true,
|
|
OpenV98: true,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, topInfoOnceResp)
|
|
|
|
// unit_accessory_result
|
|
unitAccResp := model.UnitAccessoryAllResp{
|
|
// _ = model.UnitAccessoryAllResp{
|
|
Result: model.UnitAccessoryAllResult{
|
|
AccessoryList: []interface{}{},
|
|
WearingInfo: []interface{}{},
|
|
EspecialCreateFlag: false,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, unitAccResp)
|
|
|
|
// museum_result
|
|
sql := `SELECT museum_contents_id,smile_buff,pure_buff,cool_buff FROM museum_contents_m ORDER BY museum_contents_id ASC`
|
|
rows, err := db.Query(sql)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
var smileBuf, pureBuf, coolBuf int
|
|
var mIds []int
|
|
for rows.Next() {
|
|
var museum_contents_id, smile_buff, pure_buff, cool_buff int
|
|
err = rows.Scan(&museum_contents_id, &smile_buff, &pure_buff, &cool_buff)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
smileBuf += smile_buff
|
|
pureBuf += pure_buff
|
|
coolBuf += cool_buff
|
|
mIds = append(mIds, museum_contents_id)
|
|
}
|
|
|
|
museumInfoResp := model.MuseumInfoResp{
|
|
Result: model.MuseumInfoResult{
|
|
MuseumInfo: model.MuseumInfo{
|
|
Parameter: model.MuseumInfoParameter{
|
|
Smile: smileBuf,
|
|
Pure: pureBuf,
|
|
Cool: coolBuf,
|
|
},
|
|
ContentsIDList: mIds,
|
|
},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, museumInfoResp)
|
|
|
|
// Final
|
|
k, err := json.Marshal(respAll)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
resp := model.Response{
|
|
ResponseData: k,
|
|
ReleaseInfo: []interface{}{},
|
|
StatusCode: 200,
|
|
}
|
|
k, err = json.Marshal(resp)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
// fmt.Println(string(k))
|
|
|
|
utils.WriteAllText("assets/api2.json", string(k))
|
|
}
|
|
|
|
func GenApi3Data() {
|
|
// global
|
|
var respAll []interface{}
|
|
|
|
// profile_livecnt_result
|
|
difficultyResp := DifficultyResp{
|
|
// _ = DifficultyResp{
|
|
Result: []DifficultyResult{
|
|
{
|
|
Difficulty: 1,
|
|
ClearCnt: 315,
|
|
},
|
|
{
|
|
Difficulty: 2,
|
|
ClearCnt: 310,
|
|
},
|
|
{
|
|
Difficulty: 3,
|
|
ClearCnt: 314,
|
|
},
|
|
{
|
|
Difficulty: 4,
|
|
ClearCnt: 455,
|
|
},
|
|
{
|
|
Difficulty: 6,
|
|
ClearCnt: 233,
|
|
},
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, difficultyResp)
|
|
|
|
// profile_card_ranking_result
|
|
var result []interface{}
|
|
love := utils.ReadAllText("assets/love.json")
|
|
err := json.Unmarshal([]byte(love), &result)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
loveResp := LoveResp{
|
|
// _ = LoveResp{
|
|
Result: result,
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, loveResp)
|
|
|
|
// profile_info_result
|
|
profileResp := ProfileResp{
|
|
Result: ProfileResult{
|
|
UserInfo: UserInfo{
|
|
UserID: 9999999, // 3241988
|
|
Name: "\u68a6\u8def @\u65c5\u7acb\u3061\u306e\u65e5\u306b",
|
|
Level: 1028,
|
|
CostMax: 100,
|
|
UnitMax: 5000,
|
|
EnergyMax: 417,
|
|
FriendMax: 99,
|
|
UnitCnt: 3898,
|
|
InviteCode: "377385143",
|
|
ElapsedTimeFromLogin: "14\u5c0f\u65f6\u524d",
|
|
Introduction: "\u5728\u4e0d\u77e5\u4e0d\u89c9\u4e2d \u65f6\u5149\u4ece\u4e0d\u505c\u7559\\n\u5982\u4eca\u7684\u6211\u4eec \u6bd5\u4e1a\u518d\u56de\u9996\\n\u8ffd\u68a6\u7684\u670b\u53cb\u4eec\u4e00\u540c \u8e0f\u4e0a\u4e86\u65b0\u7684\u5f81\u9014\\n\u5728\u4e0d\u4e45\u7684\u4eca\u540e \u5728\u672a\u77e5\u7684\u67d0\u5904\\n \u6211\u4eec\u4e00\u5b9a\u4f1a\u518d\u4e00\u6b21\u9082\u9005\\n \u8bf7\u4e0d\u8981\u5fd8\u8bb0\u6211\u4eec \u66fe\u7ecf\u7684\u7b11\u5bb9\r",
|
|
},
|
|
CenterUnitInfo: CenterUnitInfo{
|
|
UnitOwningUserID: CenterId,
|
|
UnitID: 3927,
|
|
Exp: 79700,
|
|
NextExp: 0,
|
|
Level: 100,
|
|
LevelLimitID: 2,
|
|
MaxLevel: 100,
|
|
Rank: 2,
|
|
MaxRank: 2,
|
|
Love: 1000,
|
|
MaxLove: 1000,
|
|
UnitSkillLevel: 8,
|
|
MaxHp: 6,
|
|
FavoriteFlag: true,
|
|
DisplayRank: 2,
|
|
UnitSkillExp: 29900,
|
|
UnitRemovableSkillCapacity: 8,
|
|
Attribute: 1,
|
|
Smile: 1,
|
|
Cute: 1,
|
|
Cool: 1,
|
|
IsLoveMax: true,
|
|
IsLevelMax: true,
|
|
IsRankMax: true,
|
|
IsSigned: true,
|
|
IsSkillLevelMax: true,
|
|
SettingAwardID: 113,
|
|
RemovableSkillIds: []int{},
|
|
AccessoryInfo: AccessoryInfo{},
|
|
Costume: Costume{},
|
|
TotalSmile: 1,
|
|
TotalCute: 1,
|
|
TotalCool: 1,
|
|
TotalHp: 6,
|
|
},
|
|
NaviUnitInfo: NaviUnitInfo{
|
|
UnitOwningUserID: CenterId,
|
|
UnitID: 3927,
|
|
Exp: 79700,
|
|
NextExp: 0,
|
|
Level: 100,
|
|
MaxLevel: 100,
|
|
LevelLimitID: 2,
|
|
Rank: 2,
|
|
MaxRank: 2,
|
|
Love: 1000,
|
|
MaxLove: 1000,
|
|
UnitSkillExp: 29900,
|
|
UnitSkillLevel: 8,
|
|
MaxHp: 6,
|
|
UnitRemovableSkillCapacity: 8,
|
|
FavoriteFlag: true,
|
|
DisplayRank: 2,
|
|
IsLoveMax: true,
|
|
IsLevelMax: true,
|
|
IsRankMax: true,
|
|
IsSigned: true,
|
|
IsSkillLevelMax: true,
|
|
IsRemovableSkillCapacityMax: true,
|
|
InsertDate: "2016-10-11 10:33:03",
|
|
TotalSmile: 1,
|
|
TotalCute: 1,
|
|
TotalCool: 1,
|
|
TotalHp: 6,
|
|
RemovableSkillIds: []int{},
|
|
},
|
|
IsAlliance: false,
|
|
FriendStatus: 0,
|
|
SettingAwardID: 113,
|
|
SettingBackgroundID: 143,
|
|
},
|
|
Status: 200,
|
|
CommandNum: false,
|
|
TimeStamp: time.Now().Unix(),
|
|
}
|
|
respAll = append(respAll, profileResp)
|
|
|
|
// Final
|
|
k, err := json.Marshal(respAll)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
resp := model.Response{
|
|
ResponseData: k,
|
|
ReleaseInfo: []interface{}{},
|
|
StatusCode: 200,
|
|
}
|
|
k, err = json.Marshal(resp)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
// fmt.Println(string(k))
|
|
|
|
utils.WriteAllText("assets/api3.json", string(k))
|
|
}
|