恢复余额功能 & 管理员修改余额功能

2026-03-30 14:59:35 +08:00
parent 22cb2d50d3
commit 4481c581e9
27 changed files with 1246 additions and 204 deletions
--- a/web/queries/balance_activity.gen.go
+++ b/web/queries/balance_activity.gen.go
@@ -0,0 +1,871 @@
+// 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 queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newBalanceActivity(db *gorm.DB, opts ...gen.DOOption) balanceActivity {
+	_balanceActivity := balanceActivity{}
+
+	_balanceActivity.balanceActivityDo.UseDB(db, opts...)
+	_balanceActivity.balanceActivityDo.UseModel(&models.BalanceActivity{})
+
+	tableName := _balanceActivity.balanceActivityDo.TableName()
+	_balanceActivity.ALL = field.NewAsterisk(tableName)
+	_balanceActivity.ID = field.NewInt32(tableName, "id")
+	_balanceActivity.UserID = field.NewInt32(tableName, "user_id")
+	_balanceActivity.BillID = field.NewInt32(tableName, "bill_id")
+	_balanceActivity.AdminID = field.NewInt32(tableName, "admin_id")
+	_balanceActivity.Amount = field.NewString(tableName, "amount")
+	_balanceActivity.BalancePrev = field.NewString(tableName, "balance_prev")
+	_balanceActivity.BalanceCurr = field.NewString(tableName, "balance_curr")
+	_balanceActivity.Remark = field.NewString(tableName, "remark")
+	_balanceActivity.CreatedAt = field.NewTime(tableName, "created_at")
+	_balanceActivity.Admin = balanceActivityHasOneAdmin{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Admin", "models.User"),
+		Admin: struct {
+			field.RelationField
+			Roles struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}
+		}{
+			RelationField: field.NewRelation("Admin.Admin", "models.Admin"),
+			Roles: struct {
+				field.RelationField
+				Permissions struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("Admin.Admin.Roles", "models.AdminRole"),
+				Permissions: struct {
+					field.RelationField
+					Parent struct {
+						field.RelationField
+					}
+					Children struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("Admin.Admin.Roles.Permissions", "models.Permission"),
+					Parent: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Admin.Admin.Roles.Permissions.Parent", "models.Permission"),
+					},
+					Children: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Admin.Admin.Roles.Permissions.Children", "models.Permission"),
+					},
+				},
+			},
+		},
+		Discount: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Admin.Discount", "models.ProductDiscount"),
+		},
+		Roles: struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Admin.Roles", "models.UserRole"),
+			Permissions: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Admin.Roles.Permissions", "models.Permission"),
+			},
+		},
+	}
+
+	_balanceActivity.User = balanceActivityBelongsToUser{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("User", "models.User"),
+	}
+
+	_balanceActivity.Bill = balanceActivityBelongsToBill{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Bill", "models.Bill"),
+		User: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Bill.User", "models.User"),
+		},
+		Trade: struct {
+			field.RelationField
+			User struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Bill.Trade", "models.Trade"),
+			User: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Bill.Trade.User", "models.User"),
+			},
+		},
+		Resource: struct {
+			field.RelationField
+			User struct {
+				field.RelationField
+			}
+			Short struct {
+				field.RelationField
+				Sku struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}
+			}
+			Long struct {
+				field.RelationField
+				Sku struct {
+					field.RelationField
+				}
+			}
+			Product struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Bill.Resource", "models.Resource"),
+			User: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Bill.Resource.User", "models.User"),
+			},
+			Short: struct {
+				field.RelationField
+				Sku struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}
+			}{
+				RelationField: field.NewRelation("Bill.Resource.Short", "models.ResourceShort"),
+				Sku: struct {
+					field.RelationField
+					Product struct {
+						field.RelationField
+					}
+					Discount struct {
+						field.RelationField
+					}
+				}{
+					RelationField: field.NewRelation("Bill.Resource.Short.Sku", "models.ProductSku"),
+					Product: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Bill.Resource.Short.Sku.Product", "models.Product"),
+					},
+					Discount: struct {
+						field.RelationField
+					}{
+						RelationField: field.NewRelation("Bill.Resource.Short.Sku.Discount", "models.ProductDiscount"),
+					},
+				},
+			},
+			Long: struct {
+				field.RelationField
+				Sku struct {
+					field.RelationField
+				}
+			}{
+				RelationField: field.NewRelation("Bill.Resource.Long", "models.ResourceLong"),
+				Sku: struct {
+					field.RelationField
+				}{
+					RelationField: field.NewRelation("Bill.Resource.Long.Sku", "models.ProductSku"),
+				},
+			},
+			Product: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Bill.Resource.Product", "models.Product"),
+			},
+		},
+		Refund: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Bill.Refund", "models.Refund"),
+		},
+	}
+
+	_balanceActivity.fillFieldMap()
+
+	return _balanceActivity
+}
+
+type balanceActivity struct {
+	balanceActivityDo
+
+	ALL         field.Asterisk
+	ID          field.Int32
+	UserID      field.Int32
+	BillID      field.Int32
+	AdminID     field.Int32
+	Amount      field.String
+	BalancePrev field.String
+	BalanceCurr field.String
+	Remark      field.String
+	CreatedAt   field.Time
+	Admin       balanceActivityHasOneAdmin
+
+	User balanceActivityBelongsToUser
+
+	Bill balanceActivityBelongsToBill
+
+	fieldMap map[string]field.Expr
+}
+
+func (b balanceActivity) Table(newTableName string) *balanceActivity {
+	b.balanceActivityDo.UseTable(newTableName)
+	return b.updateTableName(newTableName)
+}
+
+func (b balanceActivity) As(alias string) *balanceActivity {
+	b.balanceActivityDo.DO = *(b.balanceActivityDo.As(alias).(*gen.DO))
+	return b.updateTableName(alias)
+}
+
+func (b *balanceActivity) updateTableName(table string) *balanceActivity {
+	b.ALL = field.NewAsterisk(table)
+	b.ID = field.NewInt32(table, "id")
+	b.UserID = field.NewInt32(table, "user_id")
+	b.BillID = field.NewInt32(table, "bill_id")
+	b.AdminID = field.NewInt32(table, "admin_id")
+	b.Amount = field.NewString(table, "amount")
+	b.BalancePrev = field.NewString(table, "balance_prev")
+	b.BalanceCurr = field.NewString(table, "balance_curr")
+	b.Remark = field.NewString(table, "remark")
+	b.CreatedAt = field.NewTime(table, "created_at")
+
+	b.fillFieldMap()
+
+	return b
+}
+
+func (b *balanceActivity) 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 *balanceActivity) fillFieldMap() {
+	b.fieldMap = make(map[string]field.Expr, 12)
+	b.fieldMap["id"] = b.ID
+	b.fieldMap["user_id"] = b.UserID
+	b.fieldMap["bill_id"] = b.BillID
+	b.fieldMap["admin_id"] = b.AdminID
+	b.fieldMap["amount"] = b.Amount
+	b.fieldMap["balance_prev"] = b.BalancePrev
+	b.fieldMap["balance_curr"] = b.BalanceCurr
+	b.fieldMap["remark"] = b.Remark
+	b.fieldMap["created_at"] = b.CreatedAt
+
+}
+
+func (b balanceActivity) clone(db *gorm.DB) balanceActivity {
+	b.balanceActivityDo.ReplaceConnPool(db.Statement.ConnPool)
+	b.Admin.db = db.Session(&gorm.Session{Initialized: true})
+	b.Admin.db.Statement.ConnPool = db.Statement.ConnPool
+	b.User.db = db.Session(&gorm.Session{Initialized: true})
+	b.User.db.Statement.ConnPool = db.Statement.ConnPool
+	b.Bill.db = db.Session(&gorm.Session{Initialized: true})
+	b.Bill.db.Statement.ConnPool = db.Statement.ConnPool
+	return b
+}
+
+func (b balanceActivity) replaceDB(db *gorm.DB) balanceActivity {
+	b.balanceActivityDo.ReplaceDB(db)
+	b.Admin.db = db.Session(&gorm.Session{})
+	b.User.db = db.Session(&gorm.Session{})
+	b.Bill.db = db.Session(&gorm.Session{})
+	return b
+}
+
+type balanceActivityHasOneAdmin struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Admin struct {
+		field.RelationField
+		Roles struct {
+			field.RelationField
+			Permissions struct {
+				field.RelationField
+				Parent struct {
+					field.RelationField
+				}
+				Children struct {
+					field.RelationField
+				}
+			}
+		}
+	}
+	Discount struct {
+		field.RelationField
+	}
+	Roles struct {
+		field.RelationField
+		Permissions struct {
+			field.RelationField
+		}
+	}
+}
+
+func (a balanceActivityHasOneAdmin) Where(conds ...field.Expr) *balanceActivityHasOneAdmin {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a balanceActivityHasOneAdmin) WithContext(ctx context.Context) *balanceActivityHasOneAdmin {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a balanceActivityHasOneAdmin) Session(session *gorm.Session) *balanceActivityHasOneAdmin {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a balanceActivityHasOneAdmin) Model(m *models.BalanceActivity) *balanceActivityHasOneAdminTx {
+	return &balanceActivityHasOneAdminTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a balanceActivityHasOneAdmin) Unscoped() *balanceActivityHasOneAdmin {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type balanceActivityHasOneAdminTx struct{ tx *gorm.Association }
+
+func (a balanceActivityHasOneAdminTx) Find() (result *models.User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a balanceActivityHasOneAdminTx) Append(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a balanceActivityHasOneAdminTx) Replace(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a balanceActivityHasOneAdminTx) Delete(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a balanceActivityHasOneAdminTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a balanceActivityHasOneAdminTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a balanceActivityHasOneAdminTx) Unscoped() *balanceActivityHasOneAdminTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type balanceActivityBelongsToUser struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a balanceActivityBelongsToUser) Where(conds ...field.Expr) *balanceActivityBelongsToUser {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a balanceActivityBelongsToUser) WithContext(ctx context.Context) *balanceActivityBelongsToUser {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a balanceActivityBelongsToUser) Session(session *gorm.Session) *balanceActivityBelongsToUser {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a balanceActivityBelongsToUser) Model(m *models.BalanceActivity) *balanceActivityBelongsToUserTx {
+	return &balanceActivityBelongsToUserTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a balanceActivityBelongsToUser) Unscoped() *balanceActivityBelongsToUser {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type balanceActivityBelongsToUserTx struct{ tx *gorm.Association }
+
+func (a balanceActivityBelongsToUserTx) Find() (result *models.User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a balanceActivityBelongsToUserTx) Append(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a balanceActivityBelongsToUserTx) Replace(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a balanceActivityBelongsToUserTx) Delete(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a balanceActivityBelongsToUserTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a balanceActivityBelongsToUserTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a balanceActivityBelongsToUserTx) Unscoped() *balanceActivityBelongsToUserTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type balanceActivityBelongsToBill struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	User struct {
+		field.RelationField
+	}
+	Trade struct {
+		field.RelationField
+		User struct {
+			field.RelationField
+		}
+	}
+	Resource struct {
+		field.RelationField
+		User struct {
+			field.RelationField
+		}
+		Short struct {
+			field.RelationField
+			Sku struct {
+				field.RelationField
+				Product struct {
+					field.RelationField
+				}
+				Discount struct {
+					field.RelationField
+				}
+			}
+		}
+		Long struct {
+			field.RelationField
+			Sku struct {
+				field.RelationField
+			}
+		}
+		Product struct {
+			field.RelationField
+		}
+	}
+	Refund struct {
+		field.RelationField
+	}
+}
+
+func (a balanceActivityBelongsToBill) Where(conds ...field.Expr) *balanceActivityBelongsToBill {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a balanceActivityBelongsToBill) WithContext(ctx context.Context) *balanceActivityBelongsToBill {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a balanceActivityBelongsToBill) Session(session *gorm.Session) *balanceActivityBelongsToBill {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a balanceActivityBelongsToBill) Model(m *models.BalanceActivity) *balanceActivityBelongsToBillTx {
+	return &balanceActivityBelongsToBillTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a balanceActivityBelongsToBill) Unscoped() *balanceActivityBelongsToBill {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type balanceActivityBelongsToBillTx struct{ tx *gorm.Association }
+
+func (a balanceActivityBelongsToBillTx) Find() (result *models.Bill, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a balanceActivityBelongsToBillTx) Append(values ...*models.Bill) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a balanceActivityBelongsToBillTx) Replace(values ...*models.Bill) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a balanceActivityBelongsToBillTx) Delete(values ...*models.Bill) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a balanceActivityBelongsToBillTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a balanceActivityBelongsToBillTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a balanceActivityBelongsToBillTx) Unscoped() *balanceActivityBelongsToBillTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type balanceActivityDo struct{ gen.DO }
+
+func (b balanceActivityDo) Debug() *balanceActivityDo {
+	return b.withDO(b.DO.Debug())
+}
+
+func (b balanceActivityDo) WithContext(ctx context.Context) *balanceActivityDo {
+	return b.withDO(b.DO.WithContext(ctx))
+}
+
+func (b balanceActivityDo) ReadDB() *balanceActivityDo {
+	return b.Clauses(dbresolver.Read)
+}
+
+func (b balanceActivityDo) WriteDB() *balanceActivityDo {
+	return b.Clauses(dbresolver.Write)
+}
+
+func (b balanceActivityDo) Session(config *gorm.Session) *balanceActivityDo {
+	return b.withDO(b.DO.Session(config))
+}
+
+func (b balanceActivityDo) Clauses(conds ...clause.Expression) *balanceActivityDo {
+	return b.withDO(b.DO.Clauses(conds...))
+}
+
+func (b balanceActivityDo) Returning(value interface{}, columns ...string) *balanceActivityDo {
+	return b.withDO(b.DO.Returning(value, columns...))
+}
+
+func (b balanceActivityDo) Not(conds ...gen.Condition) *balanceActivityDo {
+	return b.withDO(b.DO.Not(conds...))
+}
+
+func (b balanceActivityDo) Or(conds ...gen.Condition) *balanceActivityDo {
+	return b.withDO(b.DO.Or(conds...))
+}
+
+func (b balanceActivityDo) Select(conds ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Select(conds...))
+}
+
+func (b balanceActivityDo) Where(conds ...gen.Condition) *balanceActivityDo {
+	return b.withDO(b.DO.Where(conds...))
+}
+
+func (b balanceActivityDo) Order(conds ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Order(conds...))
+}
+
+func (b balanceActivityDo) Distinct(cols ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Distinct(cols...))
+}
+
+func (b balanceActivityDo) Omit(cols ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Omit(cols...))
+}
+
+func (b balanceActivityDo) Join(table schema.Tabler, on ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Join(table, on...))
+}
+
+func (b balanceActivityDo) LeftJoin(table schema.Tabler, on ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.LeftJoin(table, on...))
+}
+
+func (b balanceActivityDo) RightJoin(table schema.Tabler, on ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.RightJoin(table, on...))
+}
+
+func (b balanceActivityDo) Group(cols ...field.Expr) *balanceActivityDo {
+	return b.withDO(b.DO.Group(cols...))
+}
+
+func (b balanceActivityDo) Having(conds ...gen.Condition) *balanceActivityDo {
+	return b.withDO(b.DO.Having(conds...))
+}
+
+func (b balanceActivityDo) Limit(limit int) *balanceActivityDo {
+	return b.withDO(b.DO.Limit(limit))
+}
+
+func (b balanceActivityDo) Offset(offset int) *balanceActivityDo {
+	return b.withDO(b.DO.Offset(offset))
+}
+
+func (b balanceActivityDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *balanceActivityDo {
+	return b.withDO(b.DO.Scopes(funcs...))
+}
+
+func (b balanceActivityDo) Unscoped() *balanceActivityDo {
+	return b.withDO(b.DO.Unscoped())
+}
+
+func (b balanceActivityDo) Create(values ...*models.BalanceActivity) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return b.DO.Create(values)
+}
+
+func (b balanceActivityDo) CreateInBatches(values []*models.BalanceActivity, 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 balanceActivityDo) Save(values ...*models.BalanceActivity) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return b.DO.Save(values)
+}
+
+func (b balanceActivityDo) First() (*models.BalanceActivity, error) {
+	if result, err := b.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) Take() (*models.BalanceActivity, error) {
+	if result, err := b.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) Last() (*models.BalanceActivity, error) {
+	if result, err := b.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) Find() ([]*models.BalanceActivity, error) {
+	result, err := b.DO.Find()
+	return result.([]*models.BalanceActivity), err
+}
+
+func (b balanceActivityDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.BalanceActivity, err error) {
+	buf := make([]*models.BalanceActivity, 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 balanceActivityDo) FindInBatches(result *[]*models.BalanceActivity, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return b.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (b balanceActivityDo) Attrs(attrs ...field.AssignExpr) *balanceActivityDo {
+	return b.withDO(b.DO.Attrs(attrs...))
+}
+
+func (b balanceActivityDo) Assign(attrs ...field.AssignExpr) *balanceActivityDo {
+	return b.withDO(b.DO.Assign(attrs...))
+}
+
+func (b balanceActivityDo) Joins(fields ...field.RelationField) *balanceActivityDo {
+	for _, _f := range fields {
+		b = *b.withDO(b.DO.Joins(_f))
+	}
+	return &b
+}
+
+func (b balanceActivityDo) Preload(fields ...field.RelationField) *balanceActivityDo {
+	for _, _f := range fields {
+		b = *b.withDO(b.DO.Preload(_f))
+	}
+	return &b
+}
+
+func (b balanceActivityDo) FirstOrInit() (*models.BalanceActivity, error) {
+	if result, err := b.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) FirstOrCreate() (*models.BalanceActivity, error) {
+	if result, err := b.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.BalanceActivity), nil
+	}
+}
+
+func (b balanceActivityDo) FindByPage(offset int, limit int) (result []*models.BalanceActivity, 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 balanceActivityDo) 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 balanceActivityDo) Scan(result interface{}) (err error) {
+	return b.DO.Scan(result)
+}
+
+func (b balanceActivityDo) Delete(models ...*models.BalanceActivity) (result gen.ResultInfo, err error) {
+	return b.DO.Delete(models)
+}
+
+func (b *balanceActivityDo) withDO(do gen.Dao) *balanceActivityDo {
+	b.DO = *do.(*gen.DO)
+	return b
+}
--- a/web/queries/gen.go
+++ b/web/queries/gen.go
@@ -20,6 +20,7 @@ var (
 	Admin                   *admin
 	AdminRole               *adminRole
 	Announcement            *announcement
+	BalanceActivity         *balanceActivity
 	Bill                    *bill
 	Channel                 *channel
 	Client                  *client
@@ -57,6 +58,7 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	Admin = &Q.Admin
 	AdminRole = &Q.AdminRole
 	Announcement = &Q.Announcement
+	BalanceActivity = &Q.BalanceActivity
 	Bill = &Q.Bill
 	Channel = &Q.Channel
 	Client = &Q.Client
@@ -95,6 +97,7 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 		Admin:                   newAdmin(db, opts...),
 		AdminRole:               newAdminRole(db, opts...),
 		Announcement:            newAnnouncement(db, opts...),
+		BalanceActivity:         newBalanceActivity(db, opts...),
 		Bill:                    newBill(db, opts...),
 		Channel:                 newChannel(db, opts...),
 		Client:                  newClient(db, opts...),
@@ -134,6 +137,7 @@ type Query struct {
 	Admin                   admin
 	AdminRole               adminRole
 	Announcement            announcement
+	BalanceActivity         balanceActivity
 	Bill                    bill
 	Channel                 channel
 	Client                  client
@@ -174,6 +178,7 @@ func (q *Query) clone(db *gorm.DB) *Query {
 		Admin:                   q.Admin.clone(db),
 		AdminRole:               q.AdminRole.clone(db),
 		Announcement:            q.Announcement.clone(db),
+		BalanceActivity:         q.BalanceActivity.clone(db),
 		Bill:                    q.Bill.clone(db),
 		Channel:                 q.Channel.clone(db),
 		Client:                  q.Client.clone(db),
@@ -221,6 +226,7 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 		Admin:                   q.Admin.replaceDB(db),
 		AdminRole:               q.AdminRole.replaceDB(db),
 		Announcement:            q.Announcement.replaceDB(db),
+		BalanceActivity:         q.BalanceActivity.replaceDB(db),
 		Bill:                    q.Bill.replaceDB(db),
 		Channel:                 q.Channel.replaceDB(db),
 		Client:                  q.Client.replaceDB(db),
@@ -258,6 +264,7 @@ type queryCtx struct {
 	Admin                   *adminDo
 	AdminRole               *adminRoleDo
 	Announcement            *announcementDo
+	BalanceActivity         *balanceActivityDo
 	Bill                    *billDo
 	Channel                 *channelDo
 	Client                  *clientDo
@@ -295,6 +302,7 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx {
 		Admin:                   q.Admin.WithContext(ctx),
 		AdminRole:               q.AdminRole.WithContext(ctx),
 		Announcement:            q.Announcement.WithContext(ctx),
+		BalanceActivity:         q.BalanceActivity.WithContext(ctx),
 		Bill:                    q.Bill.WithContext(ctx),
 		Channel:                 q.Channel.WithContext(ctx),
 		Client:                  q.Client.WithContext(ctx),