432 lines
10 KiB
Go
432 lines
10 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"blazing/common/data/xmlres"
|
|
"blazing/cool"
|
|
"blazing/modules/config/model"
|
|
"slices"
|
|
"sort"
|
|
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
"github.com/gogf/gf/v2/util/gconv"
|
|
)
|
|
|
|
type PeakTianxuanService struct {
|
|
*cool.Service
|
|
}
|
|
|
|
func NewPeakTianxuanService() *PeakTianxuanService {
|
|
return &PeakTianxuanService{
|
|
&cool.Service{
|
|
Model: model.NewPeakTianxuan(),
|
|
Where: func(ctx context.Context) []g.Array {
|
|
admin := cool.GetAdmin(ctx)
|
|
return []g.Array{{"player_id", uint32(admin.UserId)}}
|
|
},
|
|
InsertParam: func(ctx context.Context) g.MapStrAny {
|
|
admin := cool.GetAdmin(ctx)
|
|
return g.MapStrAny{
|
|
"player_id": uint32(admin.UserId),
|
|
}
|
|
},
|
|
PageQueryOp: &cool.QueryOp{
|
|
KeyWordField: []string{"preset_name", "remark"},
|
|
FieldEQ: []string{"player_id", "pet_id", "is_enable"},
|
|
Where: func(ctx context.Context) []g.Array {
|
|
admin := cool.GetAdmin(ctx)
|
|
return []g.Array{{"player_id", uint32(admin.UserId)}}
|
|
},
|
|
AddOrderby: g.MapStrStr{
|
|
"display_order": "asc",
|
|
"id": "desc",
|
|
},
|
|
},
|
|
ListQueryOp: &cool.QueryOp{
|
|
KeyWordField: []string{"preset_name", "remark"},
|
|
FieldEQ: []string{"player_id", "pet_id", "is_enable"},
|
|
Where: func(ctx context.Context) []g.Array {
|
|
admin := cool.GetAdmin(ctx)
|
|
return []g.Array{{"player_id", uint32(admin.UserId)}}
|
|
},
|
|
AddOrderby: g.MapStrStr{
|
|
"display_order": "asc",
|
|
"id": "desc",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func (s *PeakTianxuanService) ModifyBefore(ctx context.Context, method string, param g.MapStrAny) (err error) {
|
|
if method == "Delete" {
|
|
return nil
|
|
}
|
|
|
|
admin := cool.GetAdmin(ctx)
|
|
param["player_id"] = uint32(admin.UserId)
|
|
|
|
var (
|
|
playerID = gconv.Uint32(param["player_id"])
|
|
petID = gconv.Uint32(param["pet_id"])
|
|
level = gconv.Uint32(param["level"])
|
|
hp = gconv.Uint32(param["hp"])
|
|
maxHp = gconv.Uint32(param["max_hp"])
|
|
recordID = gconv.Uint32(param["id"])
|
|
)
|
|
|
|
if playerID == 0 {
|
|
return gerror.New("配置玩家不能为空")
|
|
}
|
|
if petID == 0 {
|
|
return gerror.New("天选精灵ID不能为空")
|
|
}
|
|
if level == 0 {
|
|
return gerror.New("预设等级不能为空")
|
|
}
|
|
if maxHp > 0 && hp > maxHp {
|
|
return gerror.New("当前生命不能大于最大生命")
|
|
}
|
|
|
|
var currentCount int
|
|
query := cool.DBM(s.Model).
|
|
Where("player_id", playerID).
|
|
Where("pet_id", petID)
|
|
if recordID > 0 {
|
|
query = query.WhereNot("id", recordID)
|
|
}
|
|
if currentCount, err = query.Count(); err != nil {
|
|
return err
|
|
}
|
|
if currentCount > 0 {
|
|
return gerror.New("同一玩家不能重复配置同一只天选精灵")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func dateWeekIndex(t time.Time) uint32 {
|
|
year, week := t.ISOWeek()
|
|
return uint32(year*100 + week)
|
|
}
|
|
|
|
func currentDateWeekIndex() uint32 {
|
|
return dateWeekIndex(time.Now())
|
|
}
|
|
|
|
func prevDateWeekIndex() uint32 {
|
|
return dateWeekIndex(time.Now().AddDate(0, 0, -7))
|
|
}
|
|
|
|
func (s *PeakTianxuanService) CurrentVoteWeekIndex() (uint32, uint32, error) {
|
|
return currentDateWeekIndex(), prevDateWeekIndex(), nil
|
|
}
|
|
|
|
func (s *PeakTianxuanService) ListWeekPetIDs(weekIndex uint32, playerIDs ...uint32) (map[uint32]struct{}, error) {
|
|
ret := make(map[uint32]struct{})
|
|
if weekIndex == 0 {
|
|
return ret, nil
|
|
}
|
|
|
|
var voteRows []struct {
|
|
PetID uint32 `json:"pet_id"`
|
|
}
|
|
if err := cool.DBM(model.NewPeakTianxuanVote()).
|
|
Fields("pet_id").
|
|
Where("week_index", weekIndex).
|
|
Group("pet_id").
|
|
Scan(&voteRows); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, item := range voteRows {
|
|
ret[item.PetID] = struct{}{}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
func (s *PeakTianxuanService) GetWeekList(weekIndex uint32, playerIDs ...uint32) ([]model.PeakTianxuan, error) {
|
|
var list []model.PeakTianxuan
|
|
|
|
query := dbm_enable(s.Model)
|
|
if len(playerIDs) > 0 && playerIDs[0] > 0 {
|
|
query = query.Where("player_id", playerIDs[0])
|
|
}
|
|
err := query.Order("display_order asc,id asc").Scan(&list)
|
|
return list, err
|
|
}
|
|
|
|
func (s *PeakTianxuanService) GetCurrentWeekList(playerIDs ...uint32) ([]model.PeakTianxuan, uint32, error) {
|
|
weekIndex := currentDateWeekIndex()
|
|
list, err := s.GetWeekList(0, playerIDs...)
|
|
return list, weekIndex, err
|
|
}
|
|
|
|
func (s *PeakTianxuanService) NormalizeVotePetIDs(petIDs []uint32) ([]uint32, error) {
|
|
candidateList, _, _, err := s.BuildVoteCandidatePoolPayload()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
allowed := make(map[uint32]struct{}, len(candidateList))
|
|
for _, item := range candidateList {
|
|
allowed[gconv.Uint32(item["pet_id"])] = struct{}{}
|
|
}
|
|
|
|
ret := make([]uint32, 0, len(petIDs))
|
|
for _, petID := range petIDs {
|
|
if petID == 0 {
|
|
continue
|
|
}
|
|
if _, ok := allowed[petID]; !ok {
|
|
continue
|
|
}
|
|
if slices.Contains(ret, petID) {
|
|
continue
|
|
}
|
|
ret = append(ret, petID)
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
func (s *PeakTianxuanService) SaveVote(playerID uint32, petID uint32) (uint32, error) {
|
|
normalize, err := s.NormalizeVotePetIDs([]uint32{petID})
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if len(normalize) == 0 {
|
|
return 0, gerror.New("投票精灵不在候选池中")
|
|
}
|
|
|
|
voteWeekIndex, _, err := s.CurrentVoteWeekIndex()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
voteModel := model.NewPeakTianxuanVote()
|
|
data := model.PeakTianxuanVote{
|
|
WeekIndex: voteWeekIndex,
|
|
PlayerID: playerID,
|
|
PetID: normalize[0],
|
|
}
|
|
|
|
var count int
|
|
count, err = cool.DBM(voteModel).
|
|
Where("week_index", voteWeekIndex).
|
|
Where("player_id", playerID).
|
|
Count()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if count > 0 {
|
|
_, err = cool.DBM(voteModel).
|
|
Where("week_index", voteWeekIndex).
|
|
Where("player_id", playerID).
|
|
Data(data).
|
|
Update()
|
|
} else {
|
|
_, err = cool.DBM(voteModel).Data(data).Insert()
|
|
}
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return normalize[0], nil
|
|
}
|
|
|
|
func (s *PeakTianxuanService) GetPlayerVote(playerID uint32) (uint32, error) {
|
|
voteWeekIndex, prevWeekIndex, err := s.CurrentVoteWeekIndex()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
var vote model.PeakTianxuanVote
|
|
if err = cool.DBM(model.NewPeakTianxuanVote()).
|
|
Where("week_index", voteWeekIndex).
|
|
Where("player_id", playerID).
|
|
Scan(&vote); err != nil {
|
|
return 0, err
|
|
}
|
|
if vote.PetID > 0 || prevWeekIndex == 0 {
|
|
return vote.PetID, nil
|
|
}
|
|
|
|
// 兼容旧数据：之前投票可能写在“当前正式周”里，打开页面仍需标出玩家已选。
|
|
if err = cool.DBM(model.NewPeakTianxuanVote()).
|
|
Where("week_index", prevWeekIndex).
|
|
Where("player_id", playerID).
|
|
Scan(&vote); err != nil {
|
|
return 0, err
|
|
}
|
|
return vote.PetID, nil
|
|
}
|
|
|
|
func (s *PeakTianxuanService) BuildCurrentTianxuanPayload(playerIDs ...uint32) ([]g.Map, uint32, error) {
|
|
list, weekIndex, err := s.GetCurrentWeekList(playerIDs...)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
ret := make([]g.Map, 0, len(list))
|
|
for _, item := range list {
|
|
name := item.PresetName
|
|
if name == "" {
|
|
if pet, ok := xmlres.PetMAP[int(item.PetID)]; ok {
|
|
name = pet.DefName
|
|
}
|
|
}
|
|
ret = append(ret, g.Map{
|
|
"id": item.ID,
|
|
"player_id": item.PlayerID,
|
|
"display_order": item.DisplayOrder,
|
|
"pet_id": item.PetID,
|
|
"petId": item.PetID,
|
|
"name": name,
|
|
"preset_name": item.PresetName,
|
|
"level": item.Level,
|
|
"nature": item.Nature,
|
|
"hp": item.Hp,
|
|
"max_hp": item.MaxHp,
|
|
"attack": item.Attack,
|
|
"defence": item.Defence,
|
|
"sp_attack": item.SpAttack,
|
|
"sp_defence": item.SpDefence,
|
|
"speed": item.Speed,
|
|
"skin_id": item.SkinID,
|
|
"effect_ids": item.EffectIDs,
|
|
"skill_ids": item.SkillIDs,
|
|
"vote_count": item.VoteCount,
|
|
"is_enable": item.IsEnable,
|
|
"remark": item.Remark,
|
|
})
|
|
}
|
|
|
|
return ret, weekIndex, nil
|
|
}
|
|
|
|
func (s *PeakTianxuanService) BuildVoteCandidatePoolPayload() ([]g.Map, uint32, uint32, error) {
|
|
voteWeekIndex, prevWeekIndex, err := s.CurrentVoteWeekIndex()
|
|
if err != nil {
|
|
return nil, 0, 0, err
|
|
}
|
|
|
|
currentWeekVoteMap := make(map[uint32]uint32)
|
|
var voteRows []struct {
|
|
PetID uint32 `json:"pet_id"`
|
|
VoteCount uint32 `json:"vote_count"`
|
|
}
|
|
if err = cool.DBM(model.NewPeakTianxuanVote()).
|
|
Fields("pet_id, COUNT(1) AS vote_count").
|
|
Where("week_index", voteWeekIndex).
|
|
Group("pet_id").
|
|
Scan(&voteRows); err != nil {
|
|
return nil, 0, 0, err
|
|
}
|
|
for _, item := range voteRows {
|
|
currentWeekVoteMap[item.PetID] = item.VoteCount
|
|
}
|
|
|
|
var meleeList []model.PetBaseConfig
|
|
if err = cool.DBM(model.NewMeettConfig()).Order("mon_id asc").Scan(&meleeList); err != nil {
|
|
return nil, 0, 0, err
|
|
}
|
|
|
|
type candidate struct {
|
|
PetID uint32
|
|
Level uint32
|
|
}
|
|
|
|
unique := make(map[uint32]candidate)
|
|
for _, item := range meleeList {
|
|
petID := gconv.Uint32(item.MonID)
|
|
if petID == 0 {
|
|
continue
|
|
}
|
|
if _, ok := unique[petID]; ok {
|
|
continue
|
|
}
|
|
unique[petID] = candidate{
|
|
PetID: petID,
|
|
Level: gconv.Uint32(item.Lv),
|
|
}
|
|
}
|
|
|
|
keys := make([]int, 0, len(unique))
|
|
for petID := range unique {
|
|
keys = append(keys, int(petID))
|
|
}
|
|
sort.Ints(keys)
|
|
|
|
ret := make([]g.Map, 0, len(keys))
|
|
for _, key := range keys {
|
|
item := unique[uint32(key)]
|
|
name := ""
|
|
if pet, ok := xmlres.PetMAP[int(item.PetID)]; ok {
|
|
name = pet.DefName
|
|
}
|
|
ret = append(ret, g.Map{
|
|
"pet_id": item.PetID,
|
|
"petId": item.PetID,
|
|
"name": name,
|
|
"level": item.Level,
|
|
"vote_count": currentWeekVoteMap[item.PetID],
|
|
"source": "melee_pool",
|
|
"excluded_week": prevWeekIndex,
|
|
})
|
|
}
|
|
|
|
return ret, voteWeekIndex, prevWeekIndex, nil
|
|
}
|
|
|
|
func (s *PeakTianxuanService) CurrentTianxuanPetIDs(playerIDs ...uint32) ([]uint32, error) {
|
|
list, _, err := s.GetCurrentWeekList(playerIDs...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ret := make([]uint32, 0, len(list))
|
|
for _, item := range list {
|
|
if item.PetID == 0 {
|
|
continue
|
|
}
|
|
ret = append(ret, item.PetID)
|
|
}
|
|
return ret, nil
|
|
}
|
|
|
|
func (s *PeakTianxuanService) BuildWeekTianxuanPayload(weekIndex uint32) ([]g.Map, error) {
|
|
var voteRows []struct {
|
|
PetID uint32 `json:"pet_id"`
|
|
VoteCount uint32 `json:"vote_count"`
|
|
}
|
|
if err := cool.DBM(model.NewPeakTianxuanVote()).
|
|
Fields("pet_id, COUNT(1) AS vote_count").
|
|
Where("week_index", weekIndex).
|
|
Group("pet_id").
|
|
Order("vote_count desc, pet_id asc").
|
|
Scan(&voteRows); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ret := make([]g.Map, 0, len(voteRows))
|
|
for _, item := range voteRows {
|
|
name := ""
|
|
if pet, ok := xmlres.PetMAP[int(item.PetID)]; ok {
|
|
name = pet.DefName
|
|
}
|
|
ret = append(ret, g.Map{
|
|
"pet_id": item.PetID,
|
|
"petId": item.PetID,
|
|
"name": name,
|
|
"vote_count": item.VoteCount,
|
|
})
|
|
}
|
|
|
|
return ret, nil
|
|
}
|