bl/modules/blazing/service/pet.go

package service

import (
	"blazing/cool"
	"blazing/modules/base/service"
	"blazing/modules/blazing/model"
	"context"
	"fmt"

	"github.com/gogf/gf/v2/util/gconv"
)

// 获取精灵信息   0是仓库,1是放生
func (s *PetService) PetInfo(flag int) []model.PetEX {
	var tt []model.PetEX
	err := s.TestModel(s.Model).Where("free", flag).Scan(&tt)
	if err != nil {
		return []model.PetEX{}
	}

	for i := 0; i < len(tt); i++ {
		tt[i].Data.CatchTime = tt[i].CatchTime

	}

	return tt

}
func (s *PetService) PetCount(flag int) int {

	ret, err := s.TestModel(s.Model).Where("player_id", s.userid).Where("free", flag).Count()

	if err != nil {
		return 0
	}

	return ret

}
func (s *PetService) UPdateFree(ctime uint32, free uint32) {

	s.TestModel(s.Model).Where("player_id", s.userid).Where("catch_time", ctime).Data(

		"free", free,
	).Update()

}
func (s *PetService) UPdate(t model.PetInfo) {

	m := s.TestModel(s.Model).Where("player_id", s.userid).Where("catch_time", t.CatchTime)
	var tt model.PetEX
	m.Scan(&tt)
	if tt.CatchTime == 0 {
		return
	}
	tt.Data = t
	_, err := m.OnConflict("catch_time").Update(tt)
	if err != nil {
		panic(err)
	}
}
func (s *PetService) PetInfo_One(cachetime uint32) *model.PetEX {

	m := s.TestModel(s.Model).Where("player_id", s.userid).Where("catch_time", cachetime)
	var tt *model.PetEX

	m.Scan(&tt)
	tt.Data.CatchTime = tt.CatchTime
	return tt
}
func (s *PetService) PetInfo_One_ohter(userid, cachetime uint32) model.PetEX {

	m := s.TestModel(s.Model).Where("player_id", userid).Where("catch_time", cachetime)
	var tt model.PetEX

	m.Scan(&tt)
	tt.Data.CatchTime = tt.CatchTime
	return tt
}
func (s *PetService) PetInfo_One_Unscoped(cachetime uint32) model.PetEX {

	m := s.TestModel(s.Model).Where("player_id", s.userid).Where("catch_time", cachetime).Unscoped()
	var tt model.PetEX

	m.Scan(&tt)
	tt.Data.CatchTime = tt.CatchTime
	return tt
}
func (s *PetService) Pet_del(cachetime uint32) {

	s.TestModel(s.Model).Where("player_id", s.userid).Where("catch_time", cachetime).Delete()

}

// 精灵真正添加后的捕捉时间才是真正的时间
func (s *PetService) PetAdd(y *model.PetInfo) {
	if y == nil {
		return
	}
	sql := fmt.Sprintf(`
UPDATE %s 
SET max_ts = CASE
    WHEN max_ts < EXTRACT(EPOCH FROM NOW())::INT THEN EXTRACT(EPOCH FROM NOW())::INT
    ELSE max_ts + 1
END
WHERE id = ? AND deleted_at IS NULL
RETURNING max_ts;
`, service.NewBaseSysUserService().Model.TableName())

	// 执行 Raw SQL 并扫描返回值
	ret, err := cool.DBM(service.NewBaseSysUserService().Model).Raw(sql, s.userid).All()
	//fmt.Println(ret, err)
	y.CatchTime = ret.Array()[0].Uint32()
	m1 := cool.DBM(s.Model).Where("player_id", s.userid)
	var player model.PetEX
	player.PlayerID = s.userid
	player.Data = *y
	player.CatchTime = y.CatchTime
	player.Free = 0

	_, err = m1.Insert(player)
	if err != nil {
		panic(err)
	}

}
func (s *PetService) ModifyBefore(ctx context.Context, method string, param map[string]interface{}) (err error) {
	admin := cool.GetAdmin(ctx)
	userId := admin.UserId
	s.userid = uint32(userId)
	if method == "Update" {

		if gconv.Uint(param["free"]) != 0 {
			err = fmt.Errorf("修改失败")
		}
		if userId != gconv.Uint(param["player_id"]) {
			err = fmt.Errorf("修改失败")
		}

	}

	return
}

type PetService struct {
	BaseService
}

func NewPetService(userid uint32) *PetService {
	return &PetService{
		BaseService: BaseService{
			userid: userid,
			Service: &cool.Service{
				Model: model.NewPet(),
				PageQueryOp: &cool.QueryOp{
					Where: func(ctx context.Context) [][]interface{} {
						var (
							admin  = cool.GetAdmin(ctx)
							userId = admin.UserId
						)
						if userId != 10001 {
							return [][]interface{}{
								{"player_id", userId, true},
								{"free", 1, true},
							}
						} else {
							return [][]interface{}{
								{"player_id", userId, true},
								{"free", 1, true},
							}
						}

					},
				},
			},
		},
	}
}