xiugai

internal/http/msg/event_log.go

@@ -33,6 +33,8 @@ type EventLogReq struct {
 	Wave         int64 `json:"wave"`          // 波数
 	BattleTime   int64 `json:"battle_time"`   // 战斗时长
 	BattleResult int64 `json:"battle_result"` // 战斗结果 0未通关 1通关
+	IsRevive     int   `json:"is_revive"`     // 是否复活 0否 1是
+	ReviveWave   int   `json:"revive_wave"`   // 复活波数
 
 	// guide
 	GuideId int64 `json:"guide_id"` // 引导id

internal/http/service/event_log.go

@@ -22,8 +22,11 @@ func (s *EventLogService) ReportEventLog(ctx *gin.Context, req *msg.EventLogReq)
 	case msg.EventTypeWatchAd:
 		err = s.adLog(req)
 	case msg.EventTypeBattle:
+		err = s.battleLog(req)
 	case msg.EventTypeGuide:
+		err = s.guideLog(req)
 	case msg.EventTypeOnlineDuration:
+		err = s.onlineDurationLog(req)
 	default:
 		return &msg.EventLogResp{
 			Code: 1,
@@ -47,7 +50,7 @@ func (s *EventLogService) eventLog(req *msg.EventLogReq) error {
 	data := &model.LoginLog{
 		PlayerID:  req.PlayerId,
 		EventType: req.SubType,
-		Duration:  req.Duration,
+		Duration:  int32(req.Duration),
 		IsNew:     s.isNewPlayer(req.PlayerCreateTime),
 		EventID:   req.EventId,
 		EventTime: now,
@@ -59,12 +62,63 @@ func (s *EventLogService) eventLog(req *msg.EventLogReq) error {
 	return nil
 }
 
+func (s *EventLogService) battleLog(req *msg.EventLogReq) error {
+	now := time.Now()
+	data := &model.BattleLog{
+		ChapterID:    int32(req.ChapterId),
+		Wave:         int32(req.Wave),
+		PlayerID:     req.PlayerId,
+		BattleTime:   int32(req.BattleTime),
+		BattleResult: int32(req.BattleResult),
+		IsNew:        s.isNewPlayer(req.PlayerCreateTime),
+		EventTime:    now,
+		EventDay:     now,
+		Channel:      req.Channel,
+		IsRevive:     int32(req.IsRevive),
+		ReviveWave:   int32(req.ReviveWave),
+	}
+	batchtask.Batch.Push(data.TableName(), data)
+
+	return nil
+}
+
+func (s *EventLogService) guideLog(req *msg.EventLogReq) error {
+	now := time.Now()
+	data := &model.GuideLog{
+		GuideID:   int32(req.GuideId),
+		StepID:    int32(req.StepId),
+		PlayerID:  req.PlayerId,
+		IsNew:     s.isNewPlayer(req.PlayerCreateTime),
+		EventTime: now,
+		EventDay:  now,
+		Channel:   req.Channel,
+	}
+	batchtask.Batch.Push(data.TableName(), data)
+
+	return nil
+}
+
+func (s *EventLogService) onlineDurationLog(req *msg.EventLogReq) error {
+	now := time.Now()
+	data := &model.OnlineDurationLog{
+		PlayerID: req.PlayerId,
+		LoginAt:  req.LoginAt,
+		LogoutAt: now.Unix(),
+		IsNew:    s.isNewPlayer(req.PlayerCreateTime),
+		IsValid:  int32(req.IsValid),
+		Channel:  req.Channel,
+	}
+	batchtask.Batch.Push(data.TableName(), data)
+
+	return nil
+}
+
 func (s *EventLogService) adLog(req *msg.EventLogReq) error {
 	now := time.Now()
 	data := &model.AdLog{
-		AdID:      req.AdId,
+		AdID:      int32(req.AdId),
 		PlayerID:  req.PlayerId,
-		Status:    req.Status,
+		Status:    int32(req.Status),
 		Channel:   req.Channel,
 		IsNew:     s.isNewPlayer(req.PlayerCreateTime),
 		EventTime: now,
@@ -75,7 +129,7 @@ func (s *EventLogService) adLog(req *msg.EventLogReq) error {
 	return nil
 }
 
-func (s *EventLogService) isNewPlayer(createTime int64) int64 {
+func (s *EventLogService) isNewPlayer(createTime int64) int32 {
 	if timext.IsSameDateByTs(createTime, time.Now().Unix()) {
 		return 1
 	}

orm/model/ad_log.gen.go

@@ -1,28 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package model
-
-import (
-	"time"
-)
-
-const TableNameAdLog = "ad_log"
-
-// AdLog mapped from table <ad_log>
-type AdLog struct {
-	ID        int64     `gorm:"column:id;primaryKey;autoIncrement:true" json:"id"`
-	AdID      int64     `gorm:"column:ad_id" json:"ad_id"`
-	PlayerID  int64     `gorm:"column:player_id" json:"player_id"`
-	Status    int64     `gorm:"column:status" json:"status"`
-	Channel   string    `gorm:"column:channel;comment:wx;dy" json:"channel"`          // wx;dy
-	IsNew     int64     `gorm:"column:is_new;not null;comment:0:否 1:是" json:"is_new"` // 0:否 1:是
-	EventTime time.Time `gorm:"column:event_time" json:"event_time"`
-	EventDay  time.Time `gorm:"column:event_day" json:"event_day"`
-}
-
-// TableName AdLog's table name
-func (*AdLog) TableName() string {
-	return TableNameAdLog
-}

orm/model/battle_log.gen.go

@@ -0,0 +1,32 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"time"
+)
+
+const TableNameBattleLog = "battle_log"
+
+// BattleLog mapped from table <battle_log>
+type BattleLog struct {
+	ID           int64     `gorm:"column:id;primaryKey;autoIncrement:true" json:"id"`
+	ChapterID    int32     `gorm:"column:chapter_id" json:"chapter_id"`
+	Wave         int32     `gorm:"column:wave" json:"wave"`
+	PlayerID     int64     `gorm:"column:player_id" json:"player_id"`
+	BattleTime   int32     `gorm:"column:battle_time" json:"battle_time"`
+	BattleResult int32     `gorm:"column:battle_result;comment:战斗结果 0未通关 1通关" json:"battle_result"` // 战斗结果 0未通关 1通关
+	IsNew        int32     `gorm:"column:is_new" json:"is_new"`
+	EventTime    time.Time `gorm:"column:event_time" json:"event_time"`
+	EventDay     time.Time `gorm:"column:event_day" json:"event_day"`
+	Channel      string    `gorm:"column:channel" json:"channel"`
+	IsRevive     int32     `gorm:"column:is_revive;comment:是否使用复活 0未使用 1使用" json:"is_revive"` // 是否使用复活 0未使用 1使用
+	ReviveWave   int32     `gorm:"column:revive_wave;comment:在那一波复活" json:"revive_wave"`      // 在那一波复活
+}
+
+// TableName BattleLog's table name
+func (*BattleLog) TableName() string {
+	return TableNameBattleLog
+}

orm/model/guide_log.gen.go

@@ -1,28 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package model
-
-import (
-	"time"
-)
-
-const TableNameGuideLog = "guide_log"
-
-// GuideLog mapped from table <guide_log>
-type GuideLog struct {
-	ID        int64     `gorm:"column:id;primaryKey;autoIncrement:true" json:"id"`
-	GuideID   int32     `gorm:"column:guide_id" json:"guide_id"`
-	StepID    int32     `gorm:"column:step_id" json:"step_id"`
-	PlayerID  int64     `gorm:"column:player_id" json:"player_id"`
-	IsNew     int32     `gorm:"column:is_new" json:"is_new"`
-	EventTime time.Time `gorm:"column:event_time" json:"event_time"`
-	EventDay  time.Time `gorm:"column:event_day" json:"event_day"`
-	Channel   string    `gorm:"column:channel" json:"channel"`
-}
-
-// TableName GuideLog's table name
-func (*GuideLog) TableName() string {
-	return TableNameGuideLog
-}

orm/model/login_log.gen.go

@@ -1,29 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package model
-
-import (
-	"time"
-)
-
-const TableNameLoginLog = "login_log"
-
-// LoginLog mapped from table <login_log>
-type LoginLog struct {
-	ID        int64     `gorm:"column:id;primaryKey;autoIncrement:true" json:"id"`
-	PlayerID  int64     `gorm:"column:player_id" json:"player_id"`
-	EventType string    `gorm:"column:event_type" json:"event_type"`
-	Duration  int64     `gorm:"column:duration;comment:事件完成时长 单位毫秒" json:"duration"` // 事件完成时长 单位毫秒
-	IsNew     int64     `gorm:"column:is_new" json:"is_new"`
-	EventID   string    `gorm:"column:event_id;comment:客户端生成的唯一id 玩家登录成功之后更新玩家id用" json:"event_id"` // 客户端生成的唯一id 玩家登录成功之后更新玩家id用
-	EventTime time.Time `gorm:"column:event_time" json:"event_time"`
-	EventDay  time.Time `gorm:"column:event_day" json:"event_day"`
-	Channel   string    `gorm:"column:channel" json:"channel"`
-}
-
-// TableName LoginLog's table name
-func (*LoginLog) TableName() string {
-	return TableNameLoginLog
-}

orm/model/online_duration_log.gen.go

@@ -1,23 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package model
-
-const TableNameOnlineDurationLog = "online_duration_log"
-
-// OnlineDurationLog mapped from table <online_duration_log>
-type OnlineDurationLog struct {
-	ID       int64  `gorm:"column:id;primaryKey;autoIncrement:true" json:"id"`
-	PlayerID int64  `gorm:"column:player_id" json:"player_id"`
-	LoginAt  int64  `gorm:"column:login_at" json:"login_at"`
-	LogoutAt int64  `gorm:"column:logout_at" json:"logout_at"`
-	IsNew    int32  `gorm:"column:is_new" json:"is_new"`
-	IsValid  int32  `gorm:"column:is_valid;comment:是否是有效用户 0否 1是" json:"is_valid"` // 是否是有效用户 0否 1是
-	Channel  string `gorm:"column:channel" json:"channel"`
-}
-
-// TableName OnlineDurationLog's table name
-func (*OnlineDurationLog) TableName() string {
-	return TableNameOnlineDurationLog
-}

orm/query/ad_log.gen.go

@@ -1,355 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package query
-
-import (
-	"context"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-
-	"sparkteam-dash/orm/model"
-)
-
-func newAdLog(db *gorm.DB, opts ...gen.DOOption) adLog {
-	_adLog := adLog{}
-
-	_adLog.adLogDo.UseDB(db, opts...)
-	_adLog.adLogDo.UseModel(&model.AdLog{})
-
-	tableName := _adLog.adLogDo.TableName()
-	_adLog.ALL = field.NewAsterisk(tableName)
-	_adLog.ID = field.NewInt64(tableName, "id")
-	_adLog.AdID = field.NewInt32(tableName, "ad_id")
-	_adLog.PlayerID = field.NewInt64(tableName, "player_id")
-	_adLog.Status = field.NewInt32(tableName, "status")
-	_adLog.Channel = field.NewString(tableName, "channel")
-	_adLog.IsNew = field.NewInt32(tableName, "is_new")
-	_adLog.EventTime = field.NewTime(tableName, "event_time")
-	_adLog.EventDay = field.NewTime(tableName, "event_day")
-
-	_adLog.fillFieldMap()
-
-	return _adLog
-}
-
-type adLog struct {
-	adLogDo adLogDo
-
-	ALL       field.Asterisk
-	ID        field.Int64
-	AdID      field.Int32
-	PlayerID  field.Int64
-	Status    field.Int32
-	Channel   field.String // wx;dy
-	IsNew     field.Int32  // 0:否 1:是
-	EventTime field.Time
-	EventDay  field.Time
-
-	fieldMap map[string]field.Expr
-}
-
-func (a adLog) Table(newTableName string) *adLog {
-	a.adLogDo.UseTable(newTableName)
-	return a.updateTableName(newTableName)
-}
-
-func (a adLog) As(alias string) *adLog {
-	a.adLogDo.DO = *(a.adLogDo.As(alias).(*gen.DO))
-	return a.updateTableName(alias)
-}
-
-func (a *adLog) updateTableName(table string) *adLog {
-	a.ALL = field.NewAsterisk(table)
-	a.ID = field.NewInt64(table, "id")
-	a.AdID = field.NewInt32(table, "ad_id")
-	a.PlayerID = field.NewInt64(table, "player_id")
-	a.Status = field.NewInt32(table, "status")
-	a.Channel = field.NewString(table, "channel")
-	a.IsNew = field.NewInt32(table, "is_new")
-	a.EventTime = field.NewTime(table, "event_time")
-	a.EventDay = field.NewTime(table, "event_day")
-
-	a.fillFieldMap()
-
-	return a
-}
-
-func (a *adLog) WithContext(ctx context.Context) *adLogDo { return a.adLogDo.WithContext(ctx) }
-
-func (a adLog) TableName() string { return a.adLogDo.TableName() }
-
-func (a adLog) Alias() string { return a.adLogDo.Alias() }
-
-func (a adLog) Columns(cols ...field.Expr) gen.Columns { return a.adLogDo.Columns(cols...) }
-
-func (a *adLog) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := a.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (a *adLog) fillFieldMap() {
-	a.fieldMap = make(map[string]field.Expr, 8)
-	a.fieldMap["id"] = a.ID
-	a.fieldMap["ad_id"] = a.AdID
-	a.fieldMap["player_id"] = a.PlayerID
-	a.fieldMap["status"] = a.Status
-	a.fieldMap["channel"] = a.Channel
-	a.fieldMap["is_new"] = a.IsNew
-	a.fieldMap["event_time"] = a.EventTime
-	a.fieldMap["event_day"] = a.EventDay
-}
-
-func (a adLog) clone(db *gorm.DB) adLog {
-	a.adLogDo.ReplaceConnPool(db.Statement.ConnPool)
-	return a
-}
-
-func (a adLog) replaceDB(db *gorm.DB) adLog {
-	a.adLogDo.ReplaceDB(db)
-	return a
-}
-
-type adLogDo struct{ gen.DO }
-
-func (a adLogDo) Debug() *adLogDo {
-	return a.withDO(a.DO.Debug())
-}
-
-func (a adLogDo) WithContext(ctx context.Context) *adLogDo {
-	return a.withDO(a.DO.WithContext(ctx))
-}
-
-func (a adLogDo) ReadDB() *adLogDo {
-	return a.Clauses(dbresolver.Read)
-}
-
-func (a adLogDo) WriteDB() *adLogDo {
-	return a.Clauses(dbresolver.Write)
-}
-
-func (a adLogDo) Session(config *gorm.Session) *adLogDo {
-	return a.withDO(a.DO.Session(config))
-}
-
-func (a adLogDo) Clauses(conds ...clause.Expression) *adLogDo {
-	return a.withDO(a.DO.Clauses(conds...))
-}
-
-func (a adLogDo) Returning(value interface{}, columns ...string) *adLogDo {
-	return a.withDO(a.DO.Returning(value, columns...))
-}
-
-func (a adLogDo) Not(conds ...gen.Condition) *adLogDo {
-	return a.withDO(a.DO.Not(conds...))
-}
-
-func (a adLogDo) Or(conds ...gen.Condition) *adLogDo {
-	return a.withDO(a.DO.Or(conds...))
-}
-
-func (a adLogDo) Select(conds ...field.Expr) *adLogDo {
-	return a.withDO(a.DO.Select(conds...))
-}
-
-func (a adLogDo) Where(conds ...gen.Condition) *adLogDo {
-	return a.withDO(a.DO.Where(conds...))
-}
-
-func (a adLogDo) Order(conds ...field.Expr) *adLogDo {
-	return a.withDO(a.DO.Order(conds...))
-}
-
-func (a adLogDo) Distinct(cols ...field.Expr) *adLogDo {
-	return a.withDO(a.DO.Distinct(cols...))
-}
-
-func (a adLogDo) Omit(cols ...field.Expr) *adLogDo {
-	return a.withDO(a.DO.Omit(cols...))
-}
-
-func (a adLogDo) Join(table schema.Tabler, on ...field.Expr) *adLogDo {
-	return a.withDO(a.DO.Join(table, on...))
-}
-
-func (a adLogDo) LeftJoin(table schema.Tabler, on ...field.Expr) *adLogDo {
-	return a.withDO(a.DO.LeftJoin(table, on...))
-}
-
-func (a adLogDo) RightJoin(table schema.Tabler, on ...field.Expr) *adLogDo {
-	return a.withDO(a.DO.RightJoin(table, on...))
-}
-
-func (a adLogDo) Group(cols ...field.Expr) *adLogDo {
-	return a.withDO(a.DO.Group(cols...))
-}
-
-func (a adLogDo) Having(conds ...gen.Condition) *adLogDo {
-	return a.withDO(a.DO.Having(conds...))
-}
-
-func (a adLogDo) Limit(limit int) *adLogDo {
-	return a.withDO(a.DO.Limit(limit))
-}
-
-func (a adLogDo) Offset(offset int) *adLogDo {
-	return a.withDO(a.DO.Offset(offset))
-}
-
-func (a adLogDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *adLogDo {
-	return a.withDO(a.DO.Scopes(funcs...))
-}
-
-func (a adLogDo) Unscoped() *adLogDo {
-	return a.withDO(a.DO.Unscoped())
-}
-
-func (a adLogDo) Create(values ...*model.AdLog) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return a.DO.Create(values)
-}
-
-func (a adLogDo) CreateInBatches(values []*model.AdLog, batchSize int) error {
-	return a.DO.CreateInBatches(values, batchSize)
-}
-
-// Save : !!! underlying implementation is different with GORM
-// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
-func (a adLogDo) Save(values ...*model.AdLog) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return a.DO.Save(values)
-}
-
-func (a adLogDo) First() (*model.AdLog, error) {
-	if result, err := a.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.AdLog), nil
-	}
-}
-
-func (a adLogDo) Take() (*model.AdLog, error) {
-	if result, err := a.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.AdLog), nil
-	}
-}
-
-func (a adLogDo) Last() (*model.AdLog, error) {
-	if result, err := a.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.AdLog), nil
-	}
-}
-
-func (a adLogDo) Find() ([]*model.AdLog, error) {
-	result, err := a.DO.Find()
-	return result.([]*model.AdLog), err
-}
-
-func (a adLogDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AdLog, err error) {
-	buf := make([]*model.AdLog, 0, batchSize)
-	err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
-		defer func() { results = append(results, buf...) }()
-		return fc(tx, batch)
-	})
-	return results, err
-}
-
-func (a adLogDo) FindInBatches(result *[]*model.AdLog, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return a.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (a adLogDo) Attrs(attrs ...field.AssignExpr) *adLogDo {
-	return a.withDO(a.DO.Attrs(attrs...))
-}
-
-func (a adLogDo) Assign(attrs ...field.AssignExpr) *adLogDo {
-	return a.withDO(a.DO.Assign(attrs...))
-}
-
-func (a adLogDo) Joins(fields ...field.RelationField) *adLogDo {
-	for _, _f := range fields {
-		a = *a.withDO(a.DO.Joins(_f))
-	}
-	return &a
-}
-
-func (a adLogDo) Preload(fields ...field.RelationField) *adLogDo {
-	for _, _f := range fields {
-		a = *a.withDO(a.DO.Preload(_f))
-	}
-	return &a
-}
-
-func (a adLogDo) FirstOrInit() (*model.AdLog, error) {
-	if result, err := a.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.AdLog), nil
-	}
-}
-
-func (a adLogDo) FirstOrCreate() (*model.AdLog, error) {
-	if result, err := a.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.AdLog), nil
-	}
-}
-
-func (a adLogDo) FindByPage(offset int, limit int) (result []*model.AdLog, count int64, err error) {
-	result, err = a.Offset(offset).Limit(limit).Find()
-	if err != nil {
-		return
-	}
-
-	if size := len(result); 0 < limit && 0 < size && size < limit {
-		count = int64(size + offset)
-		return
-	}
-
-	count, err = a.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (a adLogDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = a.Count()
-	if err != nil {
-		return
-	}
-
-	err = a.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (a adLogDo) Scan(result interface{}) (err error) {
-	return a.DO.Scan(result)
-}
-
-func (a adLogDo) Delete(models ...*model.AdLog) (result gen.ResultInfo, err error) {
-	return a.DO.Delete(models)
-}
-
-func (a *adLogDo) withDO(do gen.Dao) *adLogDo {
-	a.DO = *do.(*gen.DO)
-	return a
-}

orm/query/battle_log.gen.go

@@ -0,0 +1,373 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package query
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"sparkteam-dash/orm/model"
+)
+
+func newBattleLog(db *gorm.DB, opts ...gen.DOOption) battleLog {
+	_battleLog := battleLog{}
+
+	_battleLog.battleLogDo.UseDB(db, opts...)
+	_battleLog.battleLogDo.UseModel(&model.BattleLog{})
+
+	tableName := _battleLog.battleLogDo.TableName()
+	_battleLog.ALL = field.NewAsterisk(tableName)
+	_battleLog.ID = field.NewInt64(tableName, "id")
+	_battleLog.ChapterID = field.NewInt32(tableName, "chapter_id")
+	_battleLog.Wave = field.NewInt32(tableName, "wave")
+	_battleLog.PlayerID = field.NewInt64(tableName, "player_id")
+	_battleLog.BattleTime = field.NewInt32(tableName, "battle_time")
+	_battleLog.BattleResult = field.NewInt32(tableName, "battle_result")
+	_battleLog.IsNew = field.NewInt32(tableName, "is_new")
+	_battleLog.EventTime = field.NewTime(tableName, "event_time")
+	_battleLog.EventDay = field.NewTime(tableName, "event_day")
+	_battleLog.Channel = field.NewString(tableName, "channel")
+	_battleLog.IsRevive = field.NewInt32(tableName, "is_revive")
+	_battleLog.ReviveWave = field.NewInt32(tableName, "revive_wave")
+
+	_battleLog.fillFieldMap()
+
+	return _battleLog
+}
+
+type battleLog struct {
+	battleLogDo battleLogDo
+
+	ALL          field.Asterisk
+	ID           field.Int64
+	ChapterID    field.Int32
+	Wave         field.Int32
+	PlayerID     field.Int64
+	BattleTime   field.Int32
+	BattleResult field.Int32 // 战斗结果 0未通关 1通关
+	IsNew        field.Int32
+	EventTime    field.Time
+	EventDay     field.Time
+	Channel      field.String
+	IsRevive     field.Int32 // 是否使用复活 0未使用 1使用
+	ReviveWave   field.Int32 // 在那一波复活
+
+	fieldMap map[string]field.Expr
+}
+
+func (b battleLog) Table(newTableName string) *battleLog {
+	b.battleLogDo.UseTable(newTableName)
+	return b.updateTableName(newTableName)
+}
+
+func (b battleLog) As(alias string) *battleLog {
+	b.battleLogDo.DO = *(b.battleLogDo.As(alias).(*gen.DO))
+	return b.updateTableName(alias)
+}
+
+func (b *battleLog) updateTableName(table string) *battleLog {
+	b.ALL = field.NewAsterisk(table)
+	b.ID = field.NewInt64(table, "id")
+	b.ChapterID = field.NewInt32(table, "chapter_id")
+	b.Wave = field.NewInt32(table, "wave")
+	b.PlayerID = field.NewInt64(table, "player_id")
+	b.BattleTime = field.NewInt32(table, "battle_time")
+	b.BattleResult = field.NewInt32(table, "battle_result")
+	b.IsNew = field.NewInt32(table, "is_new")
+	b.EventTime = field.NewTime(table, "event_time")
+	b.EventDay = field.NewTime(table, "event_day")
+	b.Channel = field.NewString(table, "channel")
+	b.IsRevive = field.NewInt32(table, "is_revive")
+	b.ReviveWave = field.NewInt32(table, "revive_wave")
+
+	b.fillFieldMap()
+
+	return b
+}
+
+func (b *battleLog) WithContext(ctx context.Context) *battleLogDo {
+	return b.battleLogDo.WithContext(ctx)
+}
+
+func (b battleLog) TableName() string { return b.battleLogDo.TableName() }
+
+func (b battleLog) Alias() string { return b.battleLogDo.Alias() }
+
+func (b battleLog) Columns(cols ...field.Expr) gen.Columns { return b.battleLogDo.Columns(cols...) }
+
+func (b *battleLog) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := b.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (b *battleLog) fillFieldMap() {
+	b.fieldMap = make(map[string]field.Expr, 12)
+	b.fieldMap["id"] = b.ID
+	b.fieldMap["chapter_id"] = b.ChapterID
+	b.fieldMap["wave"] = b.Wave
+	b.fieldMap["player_id"] = b.PlayerID
+	b.fieldMap["battle_time"] = b.BattleTime
+	b.fieldMap["battle_result"] = b.BattleResult
+	b.fieldMap["is_new"] = b.IsNew
+	b.fieldMap["event_time"] = b.EventTime
+	b.fieldMap["event_day"] = b.EventDay
+	b.fieldMap["channel"] = b.Channel
+	b.fieldMap["is_revive"] = b.IsRevive
+	b.fieldMap["revive_wave"] = b.ReviveWave
+}
+
+func (b battleLog) clone(db *gorm.DB) battleLog {
+	b.battleLogDo.ReplaceConnPool(db.Statement.ConnPool)
+	return b
+}
+
+func (b battleLog) replaceDB(db *gorm.DB) battleLog {
+	b.battleLogDo.ReplaceDB(db)
+	return b
+}
+
+type battleLogDo struct{ gen.DO }
+
+func (b battleLogDo) Debug() *battleLogDo {
+	return b.withDO(b.DO.Debug())
+}
+
+func (b battleLogDo) WithContext(ctx context.Context) *battleLogDo {
+	return b.withDO(b.DO.WithContext(ctx))
+}
+
+func (b battleLogDo) ReadDB() *battleLogDo {
+	return b.Clauses(dbresolver.Read)
+}
+
+func (b battleLogDo) WriteDB() *battleLogDo {
+	return b.Clauses(dbresolver.Write)
+}
+
+func (b battleLogDo) Session(config *gorm.Session) *battleLogDo {
+	return b.withDO(b.DO.Session(config))
+}
+
+func (b battleLogDo) Clauses(conds ...clause.Expression) *battleLogDo {
+	return b.withDO(b.DO.Clauses(conds...))
+}
+
+func (b battleLogDo) Returning(value interface{}, columns ...string) *battleLogDo {
+	return b.withDO(b.DO.Returning(value, columns...))
+}
+
+func (b battleLogDo) Not(conds ...gen.Condition) *battleLogDo {
+	return b.withDO(b.DO.Not(conds...))
+}
+
+func (b battleLogDo) Or(conds ...gen.Condition) *battleLogDo {
+	return b.withDO(b.DO.Or(conds...))
+}
+
+func (b battleLogDo) Select(conds ...field.Expr) *battleLogDo {
+	return b.withDO(b.DO.Select(conds...))
+}
+
+func (b battleLogDo) Where(conds ...gen.Condition) *battleLogDo {
+	return b.withDO(b.DO.Where(conds...))
+}
+
+func (b battleLogDo) Order(conds ...field.Expr) *battleLogDo {
+	return b.withDO(b.DO.Order(conds...))
+}
+
+func (b battleLogDo) Distinct(cols ...field.Expr) *battleLogDo {
+	return b.withDO(b.DO.Distinct(cols...))
+}
+
+func (b battleLogDo) Omit(cols ...field.Expr) *battleLogDo {
+	return b.withDO(b.DO.Omit(cols...))
+}
+
+func (b battleLogDo) Join(table schema.Tabler, on ...field.Expr) *battleLogDo {
+	return b.withDO(b.DO.Join(table, on...))
+}
+
+func (b battleLogDo) LeftJoin(table schema.Tabler, on ...field.Expr) *battleLogDo {
+	return b.withDO(b.DO.LeftJoin(table, on...))
+}
+
+func (b battleLogDo) RightJoin(table schema.Tabler, on ...field.Expr) *battleLogDo {
+	return b.withDO(b.DO.RightJoin(table, on...))
+}
+
+func (b battleLogDo) Group(cols ...field.Expr) *battleLogDo {
+	return b.withDO(b.DO.Group(cols...))
+}
+
+func (b battleLogDo) Having(conds ...gen.Condition) *battleLogDo {
+	return b.withDO(b.DO.Having(conds...))
+}
+
+func (b battleLogDo) Limit(limit int) *battleLogDo {
+	return b.withDO(b.DO.Limit(limit))
+}
+
+func (b battleLogDo) Offset(offset int) *battleLogDo {
+	return b.withDO(b.DO.Offset(offset))
+}
+
+func (b battleLogDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *battleLogDo {
+	return b.withDO(b.DO.Scopes(funcs...))
+}
+
+func (b battleLogDo) Unscoped() *battleLogDo {
+	return b.withDO(b.DO.Unscoped())
+}
+
+func (b battleLogDo) Create(values ...*model.BattleLog) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return b.DO.Create(values)
+}
+
+func (b battleLogDo) CreateInBatches(values []*model.BattleLog, batchSize int) error {
+	return b.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (b battleLogDo) Save(values ...*model.BattleLog) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return b.DO.Save(values)
+}
+
+func (b battleLogDo) First() (*model.BattleLog, error) {
+	if result, err := b.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.BattleLog), nil
+	}
+}
+
+func (b battleLogDo) Take() (*model.BattleLog, error) {
+	if result, err := b.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.BattleLog), nil
+	}
+}
+
+func (b battleLogDo) Last() (*model.BattleLog, error) {
+	if result, err := b.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.BattleLog), nil
+	}
+}
+
+func (b battleLogDo) Find() ([]*model.BattleLog, error) {
+	result, err := b.DO.Find()
+	return result.([]*model.BattleLog), err
+}
+
+func (b battleLogDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.BattleLog, err error) {
+	buf := make([]*model.BattleLog, 0, batchSize)
+	err = b.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (b battleLogDo) FindInBatches(result *[]*model.BattleLog, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return b.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (b battleLogDo) Attrs(attrs ...field.AssignExpr) *battleLogDo {
+	return b.withDO(b.DO.Attrs(attrs...))
+}
+
+func (b battleLogDo) Assign(attrs ...field.AssignExpr) *battleLogDo {
+	return b.withDO(b.DO.Assign(attrs...))
+}
+
+func (b battleLogDo) Joins(fields ...field.RelationField) *battleLogDo {
+	for _, _f := range fields {
+		b = *b.withDO(b.DO.Joins(_f))
+	}
+	return &b
+}
+
+func (b battleLogDo) Preload(fields ...field.RelationField) *battleLogDo {
+	for _, _f := range fields {
+		b = *b.withDO(b.DO.Preload(_f))
+	}
+	return &b
+}
+
+func (b battleLogDo) FirstOrInit() (*model.BattleLog, error) {
+	if result, err := b.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.BattleLog), nil
+	}
+}
+
+func (b battleLogDo) FirstOrCreate() (*model.BattleLog, error) {
+	if result, err := b.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.BattleLog), nil
+	}
+}
+
+func (b battleLogDo) FindByPage(offset int, limit int) (result []*model.BattleLog, count int64, err error) {
+	result, err = b.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = b.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (b battleLogDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = b.Count()
+	if err != nil {
+		return
+	}
+
+	err = b.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (b battleLogDo) Scan(result interface{}) (err error) {
+	return b.DO.Scan(result)
+}
+
+func (b battleLogDo) Delete(models ...*model.BattleLog) (result gen.ResultInfo, err error) {
+	return b.DO.Delete(models)
+}
+
+func (b *battleLogDo) withDO(do gen.Dao) *battleLogDo {
+	b.DO = *do.(*gen.DO)
+	return b
+}

orm/query/gen.go

@@ -1,111 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package query
-
-import (
-	"context"
-	"database/sql"
-
-	"gorm.io/gorm"
-
-	"gorm.io/gen"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
-	return &Query{
-		db:                db,
-		AdLog:             newAdLog(db, opts...),
-		GuideLog:          newGuideLog(db, opts...),
-		LoginLog:          newLoginLog(db, opts...),
-		OnlineDurationLog: newOnlineDurationLog(db, opts...),
-	}
-}
-
-type Query struct {
-	db *gorm.DB
-
-	AdLog             adLog
-	GuideLog          guideLog
-	LoginLog          loginLog
-	OnlineDurationLog onlineDurationLog
-}
-
-func (q *Query) Available() bool { return q.db != nil }
-
-func (q *Query) clone(db *gorm.DB) *Query {
-	return &Query{
-		db:                db,
-		AdLog:             q.AdLog.clone(db),
-		GuideLog:          q.GuideLog.clone(db),
-		LoginLog:          q.LoginLog.clone(db),
-		OnlineDurationLog: q.OnlineDurationLog.clone(db),
-	}
-}
-
-func (q *Query) ReadDB() *Query {
-	return q.ReplaceDB(q.db.Clauses(dbresolver.Read))
-}
-
-func (q *Query) WriteDB() *Query {
-	return q.ReplaceDB(q.db.Clauses(dbresolver.Write))
-}
-
-func (q *Query) ReplaceDB(db *gorm.DB) *Query {
-	return &Query{
-		db:                db,
-		AdLog:             q.AdLog.replaceDB(db),
-		GuideLog:          q.GuideLog.replaceDB(db),
-		LoginLog:          q.LoginLog.replaceDB(db),
-		OnlineDurationLog: q.OnlineDurationLog.replaceDB(db),
-	}
-}
-
-type queryCtx struct {
-	AdLog             *adLogDo
-	GuideLog          *guideLogDo
-	LoginLog          *loginLogDo
-	OnlineDurationLog *onlineDurationLogDo
-}
-
-func (q *Query) WithContext(ctx context.Context) *queryCtx {
-	return &queryCtx{
-		AdLog:             q.AdLog.WithContext(ctx),
-		GuideLog:          q.GuideLog.WithContext(ctx),
-		LoginLog:          q.LoginLog.WithContext(ctx),
-		OnlineDurationLog: q.OnlineDurationLog.WithContext(ctx),
-	}
-}
-
-func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error {
-	return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...)
-}
-
-func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx {
-	tx := q.db.Begin(opts...)
-	return &QueryTx{Query: q.clone(tx), Error: tx.Error}
-}
-
-type QueryTx struct {
-	*Query
-	Error error
-}
-
-func (q *QueryTx) Commit() error {
-	return q.db.Commit().Error
-}
-
-func (q *QueryTx) Rollback() error {
-	return q.db.Rollback().Error
-}
-
-func (q *QueryTx) SavePoint(name string) error {
-	return q.db.SavePoint(name).Error
-}
-
-func (q *QueryTx) RollbackTo(name string) error {
-	return q.db.RollbackTo(name).Error
-}

orm/query/guide_log.gen.go

@@ -1,355 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package query
-
-import (
-	"context"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-
-	"sparkteam-dash/orm/model"
-)
-
-func newGuideLog(db *gorm.DB, opts ...gen.DOOption) guideLog {
-	_guideLog := guideLog{}
-
-	_guideLog.guideLogDo.UseDB(db, opts...)
-	_guideLog.guideLogDo.UseModel(&model.GuideLog{})
-
-	tableName := _guideLog.guideLogDo.TableName()
-	_guideLog.ALL = field.NewAsterisk(tableName)
-	_guideLog.ID = field.NewInt64(tableName, "id")
-	_guideLog.GuideID = field.NewInt32(tableName, "guide_id")
-	_guideLog.StepID = field.NewInt32(tableName, "step_id")
-	_guideLog.PlayerID = field.NewInt64(tableName, "player_id")
-	_guideLog.IsNew = field.NewInt32(tableName, "is_new")
-	_guideLog.EventTime = field.NewTime(tableName, "event_time")
-	_guideLog.EventDay = field.NewTime(tableName, "event_day")
-	_guideLog.Channel = field.NewString(tableName, "channel")
-
-	_guideLog.fillFieldMap()
-
-	return _guideLog
-}
-
-type guideLog struct {
-	guideLogDo guideLogDo
-
-	ALL       field.Asterisk
-	ID        field.Int64
-	GuideID   field.Int32
-	StepID    field.Int32
-	PlayerID  field.Int64
-	IsNew     field.Int32
-	EventTime field.Time
-	EventDay  field.Time
-	Channel   field.String
-
-	fieldMap map[string]field.Expr
-}
-
-func (g guideLog) Table(newTableName string) *guideLog {
-	g.guideLogDo.UseTable(newTableName)
-	return g.updateTableName(newTableName)
-}
-
-func (g guideLog) As(alias string) *guideLog {
-	g.guideLogDo.DO = *(g.guideLogDo.As(alias).(*gen.DO))
-	return g.updateTableName(alias)
-}
-
-func (g *guideLog) updateTableName(table string) *guideLog {
-	g.ALL = field.NewAsterisk(table)
-	g.ID = field.NewInt64(table, "id")
-	g.GuideID = field.NewInt32(table, "guide_id")
-	g.StepID = field.NewInt32(table, "step_id")
-	g.PlayerID = field.NewInt64(table, "player_id")
-	g.IsNew = field.NewInt32(table, "is_new")
-	g.EventTime = field.NewTime(table, "event_time")
-	g.EventDay = field.NewTime(table, "event_day")
-	g.Channel = field.NewString(table, "channel")
-
-	g.fillFieldMap()
-
-	return g
-}
-
-func (g *guideLog) WithContext(ctx context.Context) *guideLogDo { return g.guideLogDo.WithContext(ctx) }
-
-func (g guideLog) TableName() string { return g.guideLogDo.TableName() }
-
-func (g guideLog) Alias() string { return g.guideLogDo.Alias() }
-
-func (g guideLog) Columns(cols ...field.Expr) gen.Columns { return g.guideLogDo.Columns(cols...) }
-
-func (g *guideLog) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := g.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (g *guideLog) fillFieldMap() {
-	g.fieldMap = make(map[string]field.Expr, 8)
-	g.fieldMap["id"] = g.ID
-	g.fieldMap["guide_id"] = g.GuideID
-	g.fieldMap["step_id"] = g.StepID
-	g.fieldMap["player_id"] = g.PlayerID
-	g.fieldMap["is_new"] = g.IsNew
-	g.fieldMap["event_time"] = g.EventTime
-	g.fieldMap["event_day"] = g.EventDay
-	g.fieldMap["channel"] = g.Channel
-}
-
-func (g guideLog) clone(db *gorm.DB) guideLog {
-	g.guideLogDo.ReplaceConnPool(db.Statement.ConnPool)
-	return g
-}
-
-func (g guideLog) replaceDB(db *gorm.DB) guideLog {
-	g.guideLogDo.ReplaceDB(db)
-	return g
-}
-
-type guideLogDo struct{ gen.DO }
-
-func (g guideLogDo) Debug() *guideLogDo {
-	return g.withDO(g.DO.Debug())
-}
-
-func (g guideLogDo) WithContext(ctx context.Context) *guideLogDo {
-	return g.withDO(g.DO.WithContext(ctx))
-}
-
-func (g guideLogDo) ReadDB() *guideLogDo {
-	return g.Clauses(dbresolver.Read)
-}
-
-func (g guideLogDo) WriteDB() *guideLogDo {
-	return g.Clauses(dbresolver.Write)
-}
-
-func (g guideLogDo) Session(config *gorm.Session) *guideLogDo {
-	return g.withDO(g.DO.Session(config))
-}
-
-func (g guideLogDo) Clauses(conds ...clause.Expression) *guideLogDo {
-	return g.withDO(g.DO.Clauses(conds...))
-}
-
-func (g guideLogDo) Returning(value interface{}, columns ...string) *guideLogDo {
-	return g.withDO(g.DO.Returning(value, columns...))
-}
-
-func (g guideLogDo) Not(conds ...gen.Condition) *guideLogDo {
-	return g.withDO(g.DO.Not(conds...))
-}
-
-func (g guideLogDo) Or(conds ...gen.Condition) *guideLogDo {
-	return g.withDO(g.DO.Or(conds...))
-}
-
-func (g guideLogDo) Select(conds ...field.Expr) *guideLogDo {
-	return g.withDO(g.DO.Select(conds...))
-}
-
-func (g guideLogDo) Where(conds ...gen.Condition) *guideLogDo {
-	return g.withDO(g.DO.Where(conds...))
-}
-
-func (g guideLogDo) Order(conds ...field.Expr) *guideLogDo {
-	return g.withDO(g.DO.Order(conds...))
-}
-
-func (g guideLogDo) Distinct(cols ...field.Expr) *guideLogDo {
-	return g.withDO(g.DO.Distinct(cols...))
-}
-
-func (g guideLogDo) Omit(cols ...field.Expr) *guideLogDo {
-	return g.withDO(g.DO.Omit(cols...))
-}
-
-func (g guideLogDo) Join(table schema.Tabler, on ...field.Expr) *guideLogDo {
-	return g.withDO(g.DO.Join(table, on...))
-}
-
-func (g guideLogDo) LeftJoin(table schema.Tabler, on ...field.Expr) *guideLogDo {
-	return g.withDO(g.DO.LeftJoin(table, on...))
-}
-
-func (g guideLogDo) RightJoin(table schema.Tabler, on ...field.Expr) *guideLogDo {
-	return g.withDO(g.DO.RightJoin(table, on...))
-}
-
-func (g guideLogDo) Group(cols ...field.Expr) *guideLogDo {
-	return g.withDO(g.DO.Group(cols...))
-}
-
-func (g guideLogDo) Having(conds ...gen.Condition) *guideLogDo {
-	return g.withDO(g.DO.Having(conds...))
-}
-
-func (g guideLogDo) Limit(limit int) *guideLogDo {
-	return g.withDO(g.DO.Limit(limit))
-}
-
-func (g guideLogDo) Offset(offset int) *guideLogDo {
-	return g.withDO(g.DO.Offset(offset))
-}
-
-func (g guideLogDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *guideLogDo {
-	return g.withDO(g.DO.Scopes(funcs...))
-}
-
-func (g guideLogDo) Unscoped() *guideLogDo {
-	return g.withDO(g.DO.Unscoped())
-}
-
-func (g guideLogDo) Create(values ...*model.GuideLog) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return g.DO.Create(values)
-}
-
-func (g guideLogDo) CreateInBatches(values []*model.GuideLog, batchSize int) error {
-	return g.DO.CreateInBatches(values, batchSize)
-}
-
-// Save : !!! underlying implementation is different with GORM
-// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
-func (g guideLogDo) Save(values ...*model.GuideLog) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return g.DO.Save(values)
-}
-
-func (g guideLogDo) First() (*model.GuideLog, error) {
-	if result, err := g.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.GuideLog), nil
-	}
-}
-
-func (g guideLogDo) Take() (*model.GuideLog, error) {
-	if result, err := g.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.GuideLog), nil
-	}
-}
-
-func (g guideLogDo) Last() (*model.GuideLog, error) {
-	if result, err := g.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.GuideLog), nil
-	}
-}
-
-func (g guideLogDo) Find() ([]*model.GuideLog, error) {
-	result, err := g.DO.Find()
-	return result.([]*model.GuideLog), err
-}
-
-func (g guideLogDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.GuideLog, err error) {
-	buf := make([]*model.GuideLog, 0, batchSize)
-	err = g.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
-		defer func() { results = append(results, buf...) }()
-		return fc(tx, batch)
-	})
-	return results, err
-}
-
-func (g guideLogDo) FindInBatches(result *[]*model.GuideLog, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return g.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (g guideLogDo) Attrs(attrs ...field.AssignExpr) *guideLogDo {
-	return g.withDO(g.DO.Attrs(attrs...))
-}
-
-func (g guideLogDo) Assign(attrs ...field.AssignExpr) *guideLogDo {
-	return g.withDO(g.DO.Assign(attrs...))
-}
-
-func (g guideLogDo) Joins(fields ...field.RelationField) *guideLogDo {
-	for _, _f := range fields {
-		g = *g.withDO(g.DO.Joins(_f))
-	}
-	return &g
-}
-
-func (g guideLogDo) Preload(fields ...field.RelationField) *guideLogDo {
-	for _, _f := range fields {
-		g = *g.withDO(g.DO.Preload(_f))
-	}
-	return &g
-}
-
-func (g guideLogDo) FirstOrInit() (*model.GuideLog, error) {
-	if result, err := g.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.GuideLog), nil
-	}
-}
-
-func (g guideLogDo) FirstOrCreate() (*model.GuideLog, error) {
-	if result, err := g.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.GuideLog), nil
-	}
-}
-
-func (g guideLogDo) FindByPage(offset int, limit int) (result []*model.GuideLog, count int64, err error) {
-	result, err = g.Offset(offset).Limit(limit).Find()
-	if err != nil {
-		return
-	}
-
-	if size := len(result); 0 < limit && 0 < size && size < limit {
-		count = int64(size + offset)
-		return
-	}
-
-	count, err = g.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (g guideLogDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = g.Count()
-	if err != nil {
-		return
-	}
-
-	err = g.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (g guideLogDo) Scan(result interface{}) (err error) {
-	return g.DO.Scan(result)
-}
-
-func (g guideLogDo) Delete(models ...*model.GuideLog) (result gen.ResultInfo, err error) {
-	return g.DO.Delete(models)
-}
-
-func (g *guideLogDo) withDO(do gen.Dao) *guideLogDo {
-	g.DO = *do.(*gen.DO)
-	return g
-}

orm/query/login_log.gen.go

@@ -1,359 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package query
-
-import (
-	"context"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-
-	"sparkteam-dash/orm/model"
-)
-
-func newLoginLog(db *gorm.DB, opts ...gen.DOOption) loginLog {
-	_loginLog := loginLog{}
-
-	_loginLog.loginLogDo.UseDB(db, opts...)
-	_loginLog.loginLogDo.UseModel(&model.LoginLog{})
-
-	tableName := _loginLog.loginLogDo.TableName()
-	_loginLog.ALL = field.NewAsterisk(tableName)
-	_loginLog.ID = field.NewInt64(tableName, "id")
-	_loginLog.PlayerID = field.NewInt64(tableName, "player_id")
-	_loginLog.EventType = field.NewString(tableName, "event_type")
-	_loginLog.Duration = field.NewInt32(tableName, "duration")
-	_loginLog.IsNew = field.NewInt32(tableName, "is_new")
-	_loginLog.EventID = field.NewString(tableName, "event_id")
-	_loginLog.EventTime = field.NewTime(tableName, "event_time")
-	_loginLog.EventDay = field.NewTime(tableName, "event_day")
-	_loginLog.Channel = field.NewString(tableName, "channel")
-
-	_loginLog.fillFieldMap()
-
-	return _loginLog
-}
-
-type loginLog struct {
-	loginLogDo loginLogDo
-
-	ALL       field.Asterisk
-	ID        field.Int64
-	PlayerID  field.Int64
-	EventType field.String
-	Duration  field.Int32 // 事件完成时长 单位毫秒
-	IsNew     field.Int32
-	EventID   field.String // 客户端生成的唯一id 玩家登录成功之后更新玩家id用
-	EventTime field.Time
-	EventDay  field.Time
-	Channel   field.String
-
-	fieldMap map[string]field.Expr
-}
-
-func (l loginLog) Table(newTableName string) *loginLog {
-	l.loginLogDo.UseTable(newTableName)
-	return l.updateTableName(newTableName)
-}
-
-func (l loginLog) As(alias string) *loginLog {
-	l.loginLogDo.DO = *(l.loginLogDo.As(alias).(*gen.DO))
-	return l.updateTableName(alias)
-}
-
-func (l *loginLog) updateTableName(table string) *loginLog {
-	l.ALL = field.NewAsterisk(table)
-	l.ID = field.NewInt64(table, "id")
-	l.PlayerID = field.NewInt64(table, "player_id")
-	l.EventType = field.NewString(table, "event_type")
-	l.Duration = field.NewInt32(table, "duration")
-	l.IsNew = field.NewInt32(table, "is_new")
-	l.EventID = field.NewString(table, "event_id")
-	l.EventTime = field.NewTime(table, "event_time")
-	l.EventDay = field.NewTime(table, "event_day")
-	l.Channel = field.NewString(table, "channel")
-
-	l.fillFieldMap()
-
-	return l
-}
-
-func (l *loginLog) WithContext(ctx context.Context) *loginLogDo { return l.loginLogDo.WithContext(ctx) }
-
-func (l loginLog) TableName() string { return l.loginLogDo.TableName() }
-
-func (l loginLog) Alias() string { return l.loginLogDo.Alias() }
-
-func (l loginLog) Columns(cols ...field.Expr) gen.Columns { return l.loginLogDo.Columns(cols...) }
-
-func (l *loginLog) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := l.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (l *loginLog) fillFieldMap() {
-	l.fieldMap = make(map[string]field.Expr, 9)
-	l.fieldMap["id"] = l.ID
-	l.fieldMap["player_id"] = l.PlayerID
-	l.fieldMap["event_type"] = l.EventType
-	l.fieldMap["duration"] = l.Duration
-	l.fieldMap["is_new"] = l.IsNew
-	l.fieldMap["event_id"] = l.EventID
-	l.fieldMap["event_time"] = l.EventTime
-	l.fieldMap["event_day"] = l.EventDay
-	l.fieldMap["channel"] = l.Channel
-}
-
-func (l loginLog) clone(db *gorm.DB) loginLog {
-	l.loginLogDo.ReplaceConnPool(db.Statement.ConnPool)
-	return l
-}
-
-func (l loginLog) replaceDB(db *gorm.DB) loginLog {
-	l.loginLogDo.ReplaceDB(db)
-	return l
-}
-
-type loginLogDo struct{ gen.DO }
-
-func (l loginLogDo) Debug() *loginLogDo {
-	return l.withDO(l.DO.Debug())
-}
-
-func (l loginLogDo) WithContext(ctx context.Context) *loginLogDo {
-	return l.withDO(l.DO.WithContext(ctx))
-}
-
-func (l loginLogDo) ReadDB() *loginLogDo {
-	return l.Clauses(dbresolver.Read)
-}
-
-func (l loginLogDo) WriteDB() *loginLogDo {
-	return l.Clauses(dbresolver.Write)
-}
-
-func (l loginLogDo) Session(config *gorm.Session) *loginLogDo {
-	return l.withDO(l.DO.Session(config))
-}
-
-func (l loginLogDo) Clauses(conds ...clause.Expression) *loginLogDo {
-	return l.withDO(l.DO.Clauses(conds...))
-}
-
-func (l loginLogDo) Returning(value interface{}, columns ...string) *loginLogDo {
-	return l.withDO(l.DO.Returning(value, columns...))
-}
-
-func (l loginLogDo) Not(conds ...gen.Condition) *loginLogDo {
-	return l.withDO(l.DO.Not(conds...))
-}
-
-func (l loginLogDo) Or(conds ...gen.Condition) *loginLogDo {
-	return l.withDO(l.DO.Or(conds...))
-}
-
-func (l loginLogDo) Select(conds ...field.Expr) *loginLogDo {
-	return l.withDO(l.DO.Select(conds...))
-}
-
-func (l loginLogDo) Where(conds ...gen.Condition) *loginLogDo {
-	return l.withDO(l.DO.Where(conds...))
-}
-
-func (l loginLogDo) Order(conds ...field.Expr) *loginLogDo {
-	return l.withDO(l.DO.Order(conds...))
-}
-
-func (l loginLogDo) Distinct(cols ...field.Expr) *loginLogDo {
-	return l.withDO(l.DO.Distinct(cols...))
-}
-
-func (l loginLogDo) Omit(cols ...field.Expr) *loginLogDo {
-	return l.withDO(l.DO.Omit(cols...))
-}
-
-func (l loginLogDo) Join(table schema.Tabler, on ...field.Expr) *loginLogDo {
-	return l.withDO(l.DO.Join(table, on...))
-}
-
-func (l loginLogDo) LeftJoin(table schema.Tabler, on ...field.Expr) *loginLogDo {
-	return l.withDO(l.DO.LeftJoin(table, on...))
-}
-
-func (l loginLogDo) RightJoin(table schema.Tabler, on ...field.Expr) *loginLogDo {
-	return l.withDO(l.DO.RightJoin(table, on...))
-}
-
-func (l loginLogDo) Group(cols ...field.Expr) *loginLogDo {
-	return l.withDO(l.DO.Group(cols...))
-}
-
-func (l loginLogDo) Having(conds ...gen.Condition) *loginLogDo {
-	return l.withDO(l.DO.Having(conds...))
-}
-
-func (l loginLogDo) Limit(limit int) *loginLogDo {
-	return l.withDO(l.DO.Limit(limit))
-}
-
-func (l loginLogDo) Offset(offset int) *loginLogDo {
-	return l.withDO(l.DO.Offset(offset))
-}
-
-func (l loginLogDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *loginLogDo {
-	return l.withDO(l.DO.Scopes(funcs...))
-}
-
-func (l loginLogDo) Unscoped() *loginLogDo {
-	return l.withDO(l.DO.Unscoped())
-}
-
-func (l loginLogDo) Create(values ...*model.LoginLog) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return l.DO.Create(values)
-}
-
-func (l loginLogDo) CreateInBatches(values []*model.LoginLog, batchSize int) error {
-	return l.DO.CreateInBatches(values, batchSize)
-}
-
-// Save : !!! underlying implementation is different with GORM
-// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
-func (l loginLogDo) Save(values ...*model.LoginLog) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return l.DO.Save(values)
-}
-
-func (l loginLogDo) First() (*model.LoginLog, error) {
-	if result, err := l.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.LoginLog), nil
-	}
-}
-
-func (l loginLogDo) Take() (*model.LoginLog, error) {
-	if result, err := l.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.LoginLog), nil
-	}
-}
-
-func (l loginLogDo) Last() (*model.LoginLog, error) {
-	if result, err := l.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.LoginLog), nil
-	}
-}
-
-func (l loginLogDo) Find() ([]*model.LoginLog, error) {
-	result, err := l.DO.Find()
-	return result.([]*model.LoginLog), err
-}
-
-func (l loginLogDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.LoginLog, err error) {
-	buf := make([]*model.LoginLog, 0, batchSize)
-	err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
-		defer func() { results = append(results, buf...) }()
-		return fc(tx, batch)
-	})
-	return results, err
-}
-
-func (l loginLogDo) FindInBatches(result *[]*model.LoginLog, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return l.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (l loginLogDo) Attrs(attrs ...field.AssignExpr) *loginLogDo {
-	return l.withDO(l.DO.Attrs(attrs...))
-}
-
-func (l loginLogDo) Assign(attrs ...field.AssignExpr) *loginLogDo {
-	return l.withDO(l.DO.Assign(attrs...))
-}
-
-func (l loginLogDo) Joins(fields ...field.RelationField) *loginLogDo {
-	for _, _f := range fields {
-		l = *l.withDO(l.DO.Joins(_f))
-	}
-	return &l
-}
-
-func (l loginLogDo) Preload(fields ...field.RelationField) *loginLogDo {
-	for _, _f := range fields {
-		l = *l.withDO(l.DO.Preload(_f))
-	}
-	return &l
-}
-
-func (l loginLogDo) FirstOrInit() (*model.LoginLog, error) {
-	if result, err := l.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.LoginLog), nil
-	}
-}
-
-func (l loginLogDo) FirstOrCreate() (*model.LoginLog, error) {
-	if result, err := l.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.LoginLog), nil
-	}
-}
-
-func (l loginLogDo) FindByPage(offset int, limit int) (result []*model.LoginLog, count int64, err error) {
-	result, err = l.Offset(offset).Limit(limit).Find()
-	if err != nil {
-		return
-	}
-
-	if size := len(result); 0 < limit && 0 < size && size < limit {
-		count = int64(size + offset)
-		return
-	}
-
-	count, err = l.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (l loginLogDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = l.Count()
-	if err != nil {
-		return
-	}
-
-	err = l.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (l loginLogDo) Scan(result interface{}) (err error) {
-	return l.DO.Scan(result)
-}
-
-func (l loginLogDo) Delete(models ...*model.LoginLog) (result gen.ResultInfo, err error) {
-	return l.DO.Delete(models)
-}
-
-func (l *loginLogDo) withDO(do gen.Dao) *loginLogDo {
-	l.DO = *do.(*gen.DO)
-	return l
-}

orm/query/online_duration_log.gen.go

@@ -1,355 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package query
-
-import (
-	"context"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-
-	"sparkteam-dash/orm/model"
-)
-
-func newOnlineDurationLog(db *gorm.DB, opts ...gen.DOOption) onlineDurationLog {
-	_onlineDurationLog := onlineDurationLog{}
-
-	_onlineDurationLog.onlineDurationLogDo.UseDB(db, opts...)
-	_onlineDurationLog.onlineDurationLogDo.UseModel(&model.OnlineDurationLog{})
-
-	tableName := _onlineDurationLog.onlineDurationLogDo.TableName()
-	_onlineDurationLog.ALL = field.NewAsterisk(tableName)
-	_onlineDurationLog.ID = field.NewInt64(tableName, "id")
-	_onlineDurationLog.PlayerID = field.NewInt64(tableName, "player_id")
-	_onlineDurationLog.LoginAt = field.NewInt64(tableName, "login_at")
-	_onlineDurationLog.LogoutAt = field.NewInt64(tableName, "logout_at")
-	_onlineDurationLog.IsNew = field.NewInt32(tableName, "is_new")
-	_onlineDurationLog.IsValid = field.NewInt32(tableName, "is_valid")
-	_onlineDurationLog.Channel = field.NewString(tableName, "channel")
-
-	_onlineDurationLog.fillFieldMap()
-
-	return _onlineDurationLog
-}
-
-type onlineDurationLog struct {
-	onlineDurationLogDo onlineDurationLogDo
-
-	ALL      field.Asterisk
-	ID       field.Int64
-	PlayerID field.Int64
-	LoginAt  field.Int64
-	LogoutAt field.Int64
-	IsNew    field.Int32
-	IsValid  field.Int32 // 是否是有效用户 0否 1是
-	Channel  field.String
-
-	fieldMap map[string]field.Expr
-}
-
-func (o onlineDurationLog) Table(newTableName string) *onlineDurationLog {
-	o.onlineDurationLogDo.UseTable(newTableName)
-	return o.updateTableName(newTableName)
-}
-
-func (o onlineDurationLog) As(alias string) *onlineDurationLog {
-	o.onlineDurationLogDo.DO = *(o.onlineDurationLogDo.As(alias).(*gen.DO))
-	return o.updateTableName(alias)
-}
-
-func (o *onlineDurationLog) updateTableName(table string) *onlineDurationLog {
-	o.ALL = field.NewAsterisk(table)
-	o.ID = field.NewInt64(table, "id")
-	o.PlayerID = field.NewInt64(table, "player_id")
-	o.LoginAt = field.NewInt64(table, "login_at")
-	o.LogoutAt = field.NewInt64(table, "logout_at")
-	o.IsNew = field.NewInt32(table, "is_new")
-	o.IsValid = field.NewInt32(table, "is_valid")
-	o.Channel = field.NewString(table, "channel")
-
-	o.fillFieldMap()
-
-	return o
-}
-
-func (o *onlineDurationLog) WithContext(ctx context.Context) *onlineDurationLogDo {
-	return o.onlineDurationLogDo.WithContext(ctx)
-}
-
-func (o onlineDurationLog) TableName() string { return o.onlineDurationLogDo.TableName() }
-
-func (o onlineDurationLog) Alias() string { return o.onlineDurationLogDo.Alias() }
-
-func (o onlineDurationLog) Columns(cols ...field.Expr) gen.Columns {
-	return o.onlineDurationLogDo.Columns(cols...)
-}
-
-func (o *onlineDurationLog) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := o.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (o *onlineDurationLog) fillFieldMap() {
-	o.fieldMap = make(map[string]field.Expr, 7)
-	o.fieldMap["id"] = o.ID
-	o.fieldMap["player_id"] = o.PlayerID
-	o.fieldMap["login_at"] = o.LoginAt
-	o.fieldMap["logout_at"] = o.LogoutAt
-	o.fieldMap["is_new"] = o.IsNew
-	o.fieldMap["is_valid"] = o.IsValid
-	o.fieldMap["channel"] = o.Channel
-}
-
-func (o onlineDurationLog) clone(db *gorm.DB) onlineDurationLog {
-	o.onlineDurationLogDo.ReplaceConnPool(db.Statement.ConnPool)
-	return o
-}
-
-func (o onlineDurationLog) replaceDB(db *gorm.DB) onlineDurationLog {
-	o.onlineDurationLogDo.ReplaceDB(db)
-	return o
-}
-
-type onlineDurationLogDo struct{ gen.DO }
-
-func (o onlineDurationLogDo) Debug() *onlineDurationLogDo {
-	return o.withDO(o.DO.Debug())
-}
-
-func (o onlineDurationLogDo) WithContext(ctx context.Context) *onlineDurationLogDo {
-	return o.withDO(o.DO.WithContext(ctx))
-}
-
-func (o onlineDurationLogDo) ReadDB() *onlineDurationLogDo {
-	return o.Clauses(dbresolver.Read)
-}
-
-func (o onlineDurationLogDo) WriteDB() *onlineDurationLogDo {
-	return o.Clauses(dbresolver.Write)
-}
-
-func (o onlineDurationLogDo) Session(config *gorm.Session) *onlineDurationLogDo {
-	return o.withDO(o.DO.Session(config))
-}
-
-func (o onlineDurationLogDo) Clauses(conds ...clause.Expression) *onlineDurationLogDo {
-	return o.withDO(o.DO.Clauses(conds...))
-}
-
-func (o onlineDurationLogDo) Returning(value interface{}, columns ...string) *onlineDurationLogDo {
-	return o.withDO(o.DO.Returning(value, columns...))
-}
-
-func (o onlineDurationLogDo) Not(conds ...gen.Condition) *onlineDurationLogDo {
-	return o.withDO(o.DO.Not(conds...))
-}
-
-func (o onlineDurationLogDo) Or(conds ...gen.Condition) *onlineDurationLogDo {
-	return o.withDO(o.DO.Or(conds...))
-}
-
-func (o onlineDurationLogDo) Select(conds ...field.Expr) *onlineDurationLogDo {
-	return o.withDO(o.DO.Select(conds...))
-}
-
-func (o onlineDurationLogDo) Where(conds ...gen.Condition) *onlineDurationLogDo {
-	return o.withDO(o.DO.Where(conds...))
-}
-
-func (o onlineDurationLogDo) Order(conds ...field.Expr) *onlineDurationLogDo {
-	return o.withDO(o.DO.Order(conds...))
-}
-
-func (o onlineDurationLogDo) Distinct(cols ...field.Expr) *onlineDurationLogDo {
-	return o.withDO(o.DO.Distinct(cols...))
-}
-
-func (o onlineDurationLogDo) Omit(cols ...field.Expr) *onlineDurationLogDo {
-	return o.withDO(o.DO.Omit(cols...))
-}
-
-func (o onlineDurationLogDo) Join(table schema.Tabler, on ...field.Expr) *onlineDurationLogDo {
-	return o.withDO(o.DO.Join(table, on...))
-}
-
-func (o onlineDurationLogDo) LeftJoin(table schema.Tabler, on ...field.Expr) *onlineDurationLogDo {
-	return o.withDO(o.DO.LeftJoin(table, on...))
-}
-
-func (o onlineDurationLogDo) RightJoin(table schema.Tabler, on ...field.Expr) *onlineDurationLogDo {
-	return o.withDO(o.DO.RightJoin(table, on...))
-}
-
-func (o onlineDurationLogDo) Group(cols ...field.Expr) *onlineDurationLogDo {
-	return o.withDO(o.DO.Group(cols...))
-}
-
-func (o onlineDurationLogDo) Having(conds ...gen.Condition) *onlineDurationLogDo {
-	return o.withDO(o.DO.Having(conds...))
-}
-
-func (o onlineDurationLogDo) Limit(limit int) *onlineDurationLogDo {
-	return o.withDO(o.DO.Limit(limit))
-}
-
-func (o onlineDurationLogDo) Offset(offset int) *onlineDurationLogDo {
-	return o.withDO(o.DO.Offset(offset))
-}
-
-func (o onlineDurationLogDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *onlineDurationLogDo {
-	return o.withDO(o.DO.Scopes(funcs...))
-}
-
-func (o onlineDurationLogDo) Unscoped() *onlineDurationLogDo {
-	return o.withDO(o.DO.Unscoped())
-}
-
-func (o onlineDurationLogDo) Create(values ...*model.OnlineDurationLog) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return o.DO.Create(values)
-}
-
-func (o onlineDurationLogDo) CreateInBatches(values []*model.OnlineDurationLog, batchSize int) error {
-	return o.DO.CreateInBatches(values, batchSize)
-}
-
-// Save : !!! underlying implementation is different with GORM
-// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
-func (o onlineDurationLogDo) Save(values ...*model.OnlineDurationLog) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return o.DO.Save(values)
-}
-
-func (o onlineDurationLogDo) First() (*model.OnlineDurationLog, error) {
-	if result, err := o.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.OnlineDurationLog), nil
-	}
-}
-
-func (o onlineDurationLogDo) Take() (*model.OnlineDurationLog, error) {
-	if result, err := o.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.OnlineDurationLog), nil
-	}
-}
-
-func (o onlineDurationLogDo) Last() (*model.OnlineDurationLog, error) {
-	if result, err := o.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.OnlineDurationLog), nil
-	}
-}
-
-func (o onlineDurationLogDo) Find() ([]*model.OnlineDurationLog, error) {
-	result, err := o.DO.Find()
-	return result.([]*model.OnlineDurationLog), err
-}
-
-func (o onlineDurationLogDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.OnlineDurationLog, err error) {
-	buf := make([]*model.OnlineDurationLog, 0, batchSize)
-	err = o.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
-		defer func() { results = append(results, buf...) }()
-		return fc(tx, batch)
-	})
-	return results, err
-}
-
-func (o onlineDurationLogDo) FindInBatches(result *[]*model.OnlineDurationLog, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return o.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (o onlineDurationLogDo) Attrs(attrs ...field.AssignExpr) *onlineDurationLogDo {
-	return o.withDO(o.DO.Attrs(attrs...))
-}
-
-func (o onlineDurationLogDo) Assign(attrs ...field.AssignExpr) *onlineDurationLogDo {
-	return o.withDO(o.DO.Assign(attrs...))
-}
-
-func (o onlineDurationLogDo) Joins(fields ...field.RelationField) *onlineDurationLogDo {
-	for _, _f := range fields {
-		o = *o.withDO(o.DO.Joins(_f))
-	}
-	return &o
-}
-
-func (o onlineDurationLogDo) Preload(fields ...field.RelationField) *onlineDurationLogDo {
-	for _, _f := range fields {
-		o = *o.withDO(o.DO.Preload(_f))
-	}
-	return &o
-}
-
-func (o onlineDurationLogDo) FirstOrInit() (*model.OnlineDurationLog, error) {
-	if result, err := o.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.OnlineDurationLog), nil
-	}
-}
-
-func (o onlineDurationLogDo) FirstOrCreate() (*model.OnlineDurationLog, error) {
-	if result, err := o.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.OnlineDurationLog), nil
-	}
-}
-
-func (o onlineDurationLogDo) FindByPage(offset int, limit int) (result []*model.OnlineDurationLog, count int64, err error) {
-	result, err = o.Offset(offset).Limit(limit).Find()
-	if err != nil {
-		return
-	}
-
-	if size := len(result); 0 < limit && 0 < size && size < limit {
-		count = int64(size + offset)
-		return
-	}
-
-	count, err = o.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (o onlineDurationLogDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = o.Count()
-	if err != nil {
-		return
-	}
-
-	err = o.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (o onlineDurationLogDo) Scan(result interface{}) (err error) {
-	return o.DO.Scan(result)
-}
-
-func (o onlineDurationLogDo) Delete(models ...*model.OnlineDurationLog) (result gen.ResultInfo, err error) {
-	return o.DO.Delete(models)
-}
-
-func (o *onlineDurationLogDo) withDO(do gen.Dao) *onlineDurationLogDo {
-	o.DO = *do.(*gen.DO)
-	return o
-}

pkg/batchtask/batch_task.go

@@ -3,10 +3,10 @@ package batchtask
 import (
 	"context"
 	"fmt"
-	"github.com/goccy/go-json"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	"log"
+	"sparkteam-dash/orm/model"
 	"sparkteam-dash/pkg/config"
 	"sparkteam-dash/pkg/db"
 	"sync"
@@ -138,7 +138,6 @@ func (bw *BatchWriter) process() {
 
 		case <-ticker.C:
 			// 定时刷新所有表的数据
-			fmt.Println(time.Now())
 			if len(batchByTable) > 0 {
 				bw.flushAllBatches(batchByTable)
 				batchByTable = make(map[string][]interface{})
@@ -167,29 +166,22 @@ func (bw *BatchWriter) flushAllBatches(batches map[string][]interface{}) {
 		return
 	}
 
-	// 使用事务处理所有表的数据
-	err := db.LogEngine().Transaction(func(tx *gorm.DB) error {
-		for tableName, batch := range batches {
-			if len(batch) == 0 {
-				continue
-			}
-			data := make([]map[string]interface{}, 0, len(batch))
-			dataByte, _ := json.Marshal(batch)
-			_ = json.Unmarshal(dataByte, &data)
-
-			// 按表名进行批量插入
-			if err := tx.Table(tableName).Clauses(clause.OnConflict{UpdateAll: true}).CreateInBatches(data, bw.batchSize).Error; err != nil {
-				return fmt.Errorf("table %s: %w", tableName, err)
-			}
+	var err error
+	for tableName, batch := range batches {
+		if len(batch) == 0 {
+			continue
+		}
 
-			// 更新表级别统计
-			atomic.AddInt64(&bw.metrics.TotalProcessed, int64(len(batch)))
-			bw.mu.Lock()
-			bw.metrics.TableMetrics[tableName] += int64(len(batch))
-			bw.mu.Unlock()
+		if err = bw.createInBatches(tableName, batch); err != nil {
+			continue
 		}
-		return nil
-	})
+
+		// 更新表级别统计
+		atomic.AddInt64(&bw.metrics.TotalProcessed, int64(len(batch)))
+		bw.mu.Lock()
+		bw.metrics.TableMetrics[tableName] += int64(len(batch))
+		bw.mu.Unlock()
+	}
 
 	if err != nil {
 		atomic.AddInt64(&bw.metrics.TotalErrors, 1)
@@ -205,6 +197,54 @@ func (bw *BatchWriter) flushAllBatches(batches map[string][]interface{}) {
 	}
 }
 
+func (bw *BatchWriter) createInBatches(tableName string, batch []interface{}) error {
+	switch tableName {
+	case "login_log":
+		data := make([]*model.LoginLog, 0, len(batch))
+		for _, item := range batch {
+			data = append(data, item.(*model.LoginLog))
+		}
+		if err := db.LogEngine().Table(tableName).Clauses(clause.OnConflict{UpdateAll: true}).CreateInBatches(data, bw.batchSize).Error; err != nil {
+			return fmt.Errorf("table %s: %w", tableName, err)
+		}
+	case "ad_log":
+		data := make([]*model.AdLog, 0, len(batch))
+		for _, item := range batch {
+			data = append(data, item.(*model.AdLog))
+		}
+		if err := db.LogEngine().Table(tableName).Clauses(clause.OnConflict{UpdateAll: true}).CreateInBatches(data, bw.batchSize).Error; err != nil {
+			return fmt.Errorf("table %s: %w", tableName, err)
+		}
+	case "guild_log":
+		data := make([]*model.GuideLog, 0, len(batch))
+		for _, item := range batch {
+			data = append(data, item.(*model.GuideLog))
+		}
+		if err := db.LogEngine().Table(tableName).Clauses(clause.OnConflict{UpdateAll: true}).CreateInBatches(data, bw.batchSize).Error; err != nil {
+			return fmt.Errorf("table %s: %w", tableName, err)
+		}
+	case "battle_log":
+		data := make([]*model.BattleLog, 0, len(batch))
+		for _, item := range batch {
+			data = append(data, item.(*model.BattleLog))
+		}
+		if err := db.LogEngine().Table(tableName).Clauses(clause.OnConflict{UpdateAll: true}).CreateInBatches(data, bw.batchSize).Error; err != nil {
+			return fmt.Errorf("table %s: %w", tableName, err)
+		}
+	case "online_duration_log":
+		data := make([]*model.OnlineDurationLog, 0, len(batch))
+		for _, item := range batch {
+			data = append(data, item.(*model.OnlineDurationLog))
+		}
+		if err := db.LogEngine().Table(tableName).Clauses(clause.OnConflict{UpdateAll: true}).CreateInBatches(data, bw.batchSize).Error; err != nil {
+			return fmt.Errorf("table %s: %w", tableName, err)
+		}
+	default:
+		return nil
+	}
+	return nil
+}
+
 // hasTableReachedBatchSize 检查是否有表达到批次大小
 func (bw *BatchWriter) hasTableReachedBatchSize(batches map[string][]interface{}) bool {
 	for _, batch := range batches {