feat: 添加短信验证码发送功能及相关数据库模型

backend_v1/app/http/admin/provider.gen.go

@@ -69,15 +69,15 @@ func Provide(opts ...opt.Option) error {
 		users *users,
 	) (contracts.HttpRoute, error) {
 		obj := &Routes{
-			auth:        auth,
-			medias:      medias,
-			middlewares: middlewares,
-			orders:      orders,
-			posts:       posts,
+			auth:         auth,
+			medias:       medias,
+			middlewares:  middlewares,
+			orders:       orders,
+			posts:        posts,
 			smsCodeSends: smsCodeSends,
-			statistics:  statistics,
-			uploads:     uploads,
-			users:       users,
+			statistics:   statistics,
+			uploads:      uploads,
+			users:        users,
 		}
 		if err := obj.Prepare(); err != nil {
 			return nil, err

backend_v1/app/http/admin/routes.gen.go

@@ -26,14 +26,14 @@ type Routes struct {
 	log         *log.Entry `inject:"false"`
 	middlewares *middlewares.Middlewares
 	// Controller instances
-	auth       *auth
-	medias     *medias
-	orders     *orders
-	posts      *posts
+	auth         *auth
+	medias       *medias
+	orders       *orders
+	posts        *posts
 	smsCodeSends *smsCodeSends
-	statistics *statistics
-	uploads    *uploads
-	users      *users
+	statistics   *statistics
+	uploads      *uploads
+	users        *users
 }
 
 // Prepare initializes the routes provider with logging configuration.

backend_v1/app/http/admin/sms_code_sends.go

@@ -58,4 +58,3 @@ func (ctl *smsCodeSends) List(ctx fiber.Ctx, query *dto.SmsCodeSendListQuery) (*
 		Items:      items,
 	}, nil
 }
-

backend_v1/app/http/dto/sms_code_send.go

@@ -7,4 +7,3 @@ type SmsCodeSendListQuery struct {
 
 	Phone *string `query:"phone"`
 }
-

backend_v1/app/services/db.go

@@ -3,4 +3,3 @@ package services
 import "gorm.io/gorm"
 
 func DB() *gorm.DB { return _db }
-

backend_v1/database/models/query.gen.go

@@ -16,12 +16,13 @@ import (
 )
 
 var (
-	Q             = new(Query)
-	MediumQuery   *mediumQuery
-	OrderQuery    *orderQuery
-	PostQuery     *postQuery
-	UserQuery     *userQuery
-	UserPostQuery *userPostQuery
+	Q                = new(Query)
+	MediumQuery      *mediumQuery
+	OrderQuery       *orderQuery
+	PostQuery        *postQuery
+	SmsCodeSendQuery *smsCodeSendQuery
+	UserQuery        *userQuery
+	UserPostQuery    *userPostQuery
 )
 
 func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
@@ -29,41 +30,45 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	MediumQuery = &Q.Medium
 	OrderQuery = &Q.Order
 	PostQuery = &Q.Post
+	SmsCodeSendQuery = &Q.SmsCodeSend
 	UserQuery = &Q.User
 	UserPostQuery = &Q.UserPost
 }
 
 func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 	return &Query{
-		db:       db,
-		Medium:   newMedium(db, opts...),
-		Order:    newOrder(db, opts...),
-		Post:     newPost(db, opts...),
-		User:     newUser(db, opts...),
-		UserPost: newUserPost(db, opts...),
+		db:          db,
+		Medium:      newMedium(db, opts...),
+		Order:       newOrder(db, opts...),
+		Post:        newPost(db, opts...),
+		SmsCodeSend: newSmsCodeSend(db, opts...),
+		User:        newUser(db, opts...),
+		UserPost:    newUserPost(db, opts...),
 	}
 }
 
 type Query struct {
 	db *gorm.DB
 
-	Medium   mediumQuery
-	Order    orderQuery
-	Post     postQuery
-	User     userQuery
-	UserPost userPostQuery
+	Medium      mediumQuery
+	Order       orderQuery
+	Post        postQuery
+	SmsCodeSend smsCodeSendQuery
+	User        userQuery
+	UserPost    userPostQuery
 }
 
 func (q *Query) Available() bool { return q.db != nil }
 
 func (q *Query) clone(db *gorm.DB) *Query {
 	return &Query{
-		db:       db,
-		Medium:   q.Medium.clone(db),
-		Order:    q.Order.clone(db),
-		Post:     q.Post.clone(db),
-		User:     q.User.clone(db),
-		UserPost: q.UserPost.clone(db),
+		db:          db,
+		Medium:      q.Medium.clone(db),
+		Order:       q.Order.clone(db),
+		Post:        q.Post.clone(db),
+		SmsCodeSend: q.SmsCodeSend.clone(db),
+		User:        q.User.clone(db),
+		UserPost:    q.UserPost.clone(db),
 	}
 }
 
@@ -77,30 +82,33 @@ func (q *Query) WriteDB() *Query {
 
 func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 	return &Query{
-		db:       db,
-		Medium:   q.Medium.replaceDB(db),
-		Order:    q.Order.replaceDB(db),
-		Post:     q.Post.replaceDB(db),
-		User:     q.User.replaceDB(db),
-		UserPost: q.UserPost.replaceDB(db),
+		db:          db,
+		Medium:      q.Medium.replaceDB(db),
+		Order:       q.Order.replaceDB(db),
+		Post:        q.Post.replaceDB(db),
+		SmsCodeSend: q.SmsCodeSend.replaceDB(db),
+		User:        q.User.replaceDB(db),
+		UserPost:    q.UserPost.replaceDB(db),
 	}
 }
 
 type queryCtx struct {
-	Medium   *mediumQueryDo
-	Order    *orderQueryDo
-	Post     *postQueryDo
-	User     *userQueryDo
-	UserPost *userPostQueryDo
+	Medium      *mediumQueryDo
+	Order       *orderQueryDo
+	Post        *postQueryDo
+	SmsCodeSend *smsCodeSendQueryDo
+	User        *userQueryDo
+	UserPost    *userPostQueryDo
 }
 
 func (q *Query) WithContext(ctx context.Context) *queryCtx {
 	return &queryCtx{
-		Medium:   q.Medium.WithContext(ctx),
-		Order:    q.Order.WithContext(ctx),
-		Post:     q.Post.WithContext(ctx),
-		User:     q.User.WithContext(ctx),
-		UserPost: q.UserPost.WithContext(ctx),
+		Medium:      q.Medium.WithContext(ctx),
+		Order:       q.Order.WithContext(ctx),
+		Post:        q.Post.WithContext(ctx),
+		SmsCodeSend: q.SmsCodeSend.WithContext(ctx),
+		User:        q.User.WithContext(ctx),
+		UserPost:    q.UserPost.WithContext(ctx),
 	}
 }
 

backend_v1/database/models/sms_code_send.go

@@ -14,4 +14,3 @@ type SmsCodeSend struct {
 }
 
 func (*SmsCodeSend) TableName() string { return TableNameSmsCodeSend }
-

backend_v1/database/models/sms_code_sends.gen.go

@@ -0,0 +1,57 @@
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"time"
+
+	"go.ipao.vip/gen"
+)
+
+const TableNameSmsCodeSend = "sms_code_sends"
+
+// SmsCodeSend mapped from table <sms_code_sends>
+type SmsCodeSend struct {
+	ID        int64     `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"`
+	Phone     string    `gorm:"column:phone;type:character varying(20);not null" json:"phone"`
+	Code      string    `gorm:"column:code;type:character varying(20);not null" json:"code"`
+	SentAt    time.Time `gorm:"column:sent_at;type:timestamp without time zone;not null;default:now()" json:"sent_at"`
+	ExpiresAt time.Time `gorm:"column:expires_at;type:timestamp without time zone;not null" json:"expires_at"`
+}
+
+// Quick operations without importing query package
+// Update applies changed fields to the database using the default DB.
+func (m *SmsCodeSend) Update(ctx context.Context) (gen.ResultInfo, error) {
+	return Q.SmsCodeSend.WithContext(ctx).Updates(m)
+}
+
+// Save upserts the model using the default DB.
+func (m *SmsCodeSend) Save(ctx context.Context) error { return Q.SmsCodeSend.WithContext(ctx).Save(m) }
+
+// Create inserts the model using the default DB.
+func (m *SmsCodeSend) Create(ctx context.Context) error {
+	return Q.SmsCodeSend.WithContext(ctx).Create(m)
+}
+
+// Delete removes the row represented by the model using the default DB.
+func (m *SmsCodeSend) Delete(ctx context.Context) (gen.ResultInfo, error) {
+	return Q.SmsCodeSend.WithContext(ctx).Delete(m)
+}
+
+// ForceDelete permanently deletes the row (ignores soft delete) using the default DB.
+func (m *SmsCodeSend) ForceDelete(ctx context.Context) (gen.ResultInfo, error) {
+	return Q.SmsCodeSend.WithContext(ctx).Unscoped().Delete(m)
+}
+
+// Reload reloads the model from database by its primary key and overwrites current fields.
+func (m *SmsCodeSend) Reload(ctx context.Context) error {
+	fresh, err := Q.SmsCodeSend.WithContext(ctx).GetByID(m.ID)
+	if err != nil {
+		return err
+	}
+	*m = *fresh
+	return nil
+}

backend_v1/database/models/sms_code_sends.query.gen.go

@@ -0,0 +1,477 @@
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"go.ipao.vip/gen"
+	"go.ipao.vip/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+)
+
+func newSmsCodeSend(db *gorm.DB, opts ...gen.DOOption) smsCodeSendQuery {
+	_smsCodeSendQuery := smsCodeSendQuery{}
+
+	_smsCodeSendQuery.smsCodeSendQueryDo.UseDB(db, opts...)
+	_smsCodeSendQuery.smsCodeSendQueryDo.UseModel(&SmsCodeSend{})
+
+	tableName := _smsCodeSendQuery.smsCodeSendQueryDo.TableName()
+	_smsCodeSendQuery.ALL = field.NewAsterisk(tableName)
+	_smsCodeSendQuery.ID = field.NewInt64(tableName, "id")
+	_smsCodeSendQuery.Phone = field.NewString(tableName, "phone")
+	_smsCodeSendQuery.Code = field.NewString(tableName, "code")
+	_smsCodeSendQuery.SentAt = field.NewTime(tableName, "sent_at")
+	_smsCodeSendQuery.ExpiresAt = field.NewTime(tableName, "expires_at")
+
+	_smsCodeSendQuery.fillFieldMap()
+
+	return _smsCodeSendQuery
+}
+
+type smsCodeSendQuery struct {
+	smsCodeSendQueryDo smsCodeSendQueryDo
+
+	ALL       field.Asterisk
+	ID        field.Int64
+	Phone     field.String
+	Code      field.String
+	SentAt    field.Time
+	ExpiresAt field.Time
+
+	fieldMap map[string]field.Expr
+}
+
+func (s smsCodeSendQuery) Table(newTableName string) *smsCodeSendQuery {
+	s.smsCodeSendQueryDo.UseTable(newTableName)
+	return s.updateTableName(newTableName)
+}
+
+func (s smsCodeSendQuery) As(alias string) *smsCodeSendQuery {
+	s.smsCodeSendQueryDo.DO = *(s.smsCodeSendQueryDo.As(alias).(*gen.DO))
+	return s.updateTableName(alias)
+}
+
+func (s *smsCodeSendQuery) updateTableName(table string) *smsCodeSendQuery {
+	s.ALL = field.NewAsterisk(table)
+	s.ID = field.NewInt64(table, "id")
+	s.Phone = field.NewString(table, "phone")
+	s.Code = field.NewString(table, "code")
+	s.SentAt = field.NewTime(table, "sent_at")
+	s.ExpiresAt = field.NewTime(table, "expires_at")
+
+	s.fillFieldMap()
+
+	return s
+}
+
+func (s *smsCodeSendQuery) QueryContext(ctx context.Context) (*smsCodeSendQuery, *smsCodeSendQueryDo) {
+	return s, s.smsCodeSendQueryDo.WithContext(ctx)
+}
+
+func (s *smsCodeSendQuery) WithContext(ctx context.Context) *smsCodeSendQueryDo {
+	return s.smsCodeSendQueryDo.WithContext(ctx)
+}
+
+func (s smsCodeSendQuery) TableName() string { return s.smsCodeSendQueryDo.TableName() }
+
+func (s smsCodeSendQuery) Alias() string { return s.smsCodeSendQueryDo.Alias() }
+
+func (s smsCodeSendQuery) Columns(cols ...field.Expr) gen.Columns {
+	return s.smsCodeSendQueryDo.Columns(cols...)
+}
+
+func (s *smsCodeSendQuery) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := s.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (s *smsCodeSendQuery) fillFieldMap() {
+	s.fieldMap = make(map[string]field.Expr, 5)
+	s.fieldMap["id"] = s.ID
+	s.fieldMap["phone"] = s.Phone
+	s.fieldMap["code"] = s.Code
+	s.fieldMap["sent_at"] = s.SentAt
+	s.fieldMap["expires_at"] = s.ExpiresAt
+}
+
+func (s smsCodeSendQuery) clone(db *gorm.DB) smsCodeSendQuery {
+	s.smsCodeSendQueryDo.ReplaceConnPool(db.Statement.ConnPool)
+	return s
+}
+
+func (s smsCodeSendQuery) replaceDB(db *gorm.DB) smsCodeSendQuery {
+	s.smsCodeSendQueryDo.ReplaceDB(db)
+	return s
+}
+
+type smsCodeSendQueryDo struct{ gen.DO }
+
+func (s smsCodeSendQueryDo) Debug() *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Debug())
+}
+
+func (s smsCodeSendQueryDo) WithContext(ctx context.Context) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.WithContext(ctx))
+}
+
+func (s smsCodeSendQueryDo) ReadDB() *smsCodeSendQueryDo {
+	return s.Clauses(dbresolver.Read)
+}
+
+func (s smsCodeSendQueryDo) WriteDB() *smsCodeSendQueryDo {
+	return s.Clauses(dbresolver.Write)
+}
+
+func (s smsCodeSendQueryDo) Session(config *gorm.Session) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Session(config))
+}
+
+func (s smsCodeSendQueryDo) Clauses(conds ...clause.Expression) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Clauses(conds...))
+}
+
+func (s smsCodeSendQueryDo) Returning(value interface{}, columns ...string) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Returning(value, columns...))
+}
+
+func (s smsCodeSendQueryDo) Not(conds ...gen.Condition) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Not(conds...))
+}
+
+func (s smsCodeSendQueryDo) Or(conds ...gen.Condition) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Or(conds...))
+}
+
+func (s smsCodeSendQueryDo) Select(conds ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Select(conds...))
+}
+
+func (s smsCodeSendQueryDo) Where(conds ...gen.Condition) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Where(conds...))
+}
+
+func (s smsCodeSendQueryDo) Order(conds ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Order(conds...))
+}
+
+func (s smsCodeSendQueryDo) Distinct(cols ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Distinct(cols...))
+}
+
+func (s smsCodeSendQueryDo) Omit(cols ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Omit(cols...))
+}
+
+func (s smsCodeSendQueryDo) Join(table schema.Tabler, on ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Join(table, on...))
+}
+
+func (s smsCodeSendQueryDo) LeftJoin(table schema.Tabler, on ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.LeftJoin(table, on...))
+}
+
+func (s smsCodeSendQueryDo) RightJoin(table schema.Tabler, on ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.RightJoin(table, on...))
+}
+
+func (s smsCodeSendQueryDo) Group(cols ...field.Expr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Group(cols...))
+}
+
+func (s smsCodeSendQueryDo) Having(conds ...gen.Condition) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Having(conds...))
+}
+
+func (s smsCodeSendQueryDo) Limit(limit int) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Limit(limit))
+}
+
+func (s smsCodeSendQueryDo) Offset(offset int) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Offset(offset))
+}
+
+func (s smsCodeSendQueryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Scopes(funcs...))
+}
+
+func (s smsCodeSendQueryDo) Unscoped() *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Unscoped())
+}
+
+func (s smsCodeSendQueryDo) Create(values ...*SmsCodeSend) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return s.DO.Create(values)
+}
+
+func (s smsCodeSendQueryDo) CreateInBatches(values []*SmsCodeSend, batchSize int) error {
+	return s.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 (s smsCodeSendQueryDo) Save(values ...*SmsCodeSend) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return s.DO.Save(values)
+}
+
+func (s smsCodeSendQueryDo) First() (*SmsCodeSend, error) {
+	if result, err := s.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) Take() (*SmsCodeSend, error) {
+	if result, err := s.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) Last() (*SmsCodeSend, error) {
+	if result, err := s.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) Find() ([]*SmsCodeSend, error) {
+	result, err := s.DO.Find()
+	return result.([]*SmsCodeSend), err
+}
+
+func (s smsCodeSendQueryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*SmsCodeSend, err error) {
+	buf := make([]*SmsCodeSend, 0, batchSize)
+	err = s.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 (s smsCodeSendQueryDo) FindInBatches(result *[]*SmsCodeSend, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return s.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (s smsCodeSendQueryDo) Attrs(attrs ...field.AssignExpr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Attrs(attrs...))
+}
+
+func (s smsCodeSendQueryDo) Assign(attrs ...field.AssignExpr) *smsCodeSendQueryDo {
+	return s.withDO(s.DO.Assign(attrs...))
+}
+
+func (s smsCodeSendQueryDo) Joins(fields ...field.RelationField) *smsCodeSendQueryDo {
+	for _, _f := range fields {
+		s = *s.withDO(s.DO.Joins(_f))
+	}
+	return &s
+}
+
+func (s smsCodeSendQueryDo) Preload(fields ...field.RelationField) *smsCodeSendQueryDo {
+	for _, _f := range fields {
+		s = *s.withDO(s.DO.Preload(_f))
+	}
+	return &s
+}
+
+func (s smsCodeSendQueryDo) FirstOrInit() (*SmsCodeSend, error) {
+	if result, err := s.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) FirstOrCreate() (*SmsCodeSend, error) {
+	if result, err := s.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*SmsCodeSend), nil
+	}
+}
+
+func (s smsCodeSendQueryDo) FindByPage(offset int, limit int) (result []*SmsCodeSend, count int64, err error) {
+	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (s smsCodeSendQueryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = s.Count()
+	if err != nil {
+		return
+	}
+
+	err = s.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (s smsCodeSendQueryDo) Scan(result interface{}) (err error) {
+	return s.DO.Scan(result)
+}
+
+func (s smsCodeSendQueryDo) Delete(models ...*SmsCodeSend) (result gen.ResultInfo, err error) {
+	return s.DO.Delete(models)
+}
+
+// ForceDelete performs a permanent delete (ignores soft-delete) for current scope.
+func (s smsCodeSendQueryDo) ForceDelete() (gen.ResultInfo, error) {
+	return s.Unscoped().Delete()
+}
+
+// Inc increases the given column by step for current scope.
+func (s smsCodeSendQueryDo) Inc(column field.Expr, step int64) (gen.ResultInfo, error) {
+	// column = column + step
+	e := field.NewUnsafeFieldRaw("?+?", column.RawExpr(), step)
+	return s.DO.UpdateColumn(column, e)
+}
+
+// Dec decreases the given column by step for current scope.
+func (s smsCodeSendQueryDo) Dec(column field.Expr, step int64) (gen.ResultInfo, error) {
+	// column = column - step
+	e := field.NewUnsafeFieldRaw("?-?", column.RawExpr(), step)
+	return s.DO.UpdateColumn(column, e)
+}
+
+// Sum returns SUM(column) for current scope.
+func (s smsCodeSendQueryDo) Sum(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("SUM(?)", column.RawExpr())
+	if err := s.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Avg returns AVG(column) for current scope.
+func (s smsCodeSendQueryDo) Avg(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("AVG(?)", column.RawExpr())
+	if err := s.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Min returns MIN(column) for current scope.
+func (s smsCodeSendQueryDo) Min(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("MIN(?)", column.RawExpr())
+	if err := s.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Max returns MAX(column) for current scope.
+func (s smsCodeSendQueryDo) Max(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("MAX(?)", column.RawExpr())
+	if err := s.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// PluckMap returns a map[key]value for selected key/value expressions within current scope.
+func (s smsCodeSendQueryDo) PluckMap(key, val field.Expr) (map[interface{}]interface{}, error) {
+	do := s.Select(key, val)
+	rows, err := do.DO.Rows()
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	mm := make(map[interface{}]interface{})
+	for rows.Next() {
+		var k interface{}
+		var v interface{}
+		if err := rows.Scan(&k, &v); err != nil {
+			return nil, err
+		}
+		mm[k] = v
+	}
+	return mm, rows.Err()
+}
+
+// Exists returns true if any record matches the given conditions.
+func (s smsCodeSendQueryDo) Exists(conds ...gen.Condition) (bool, error) {
+	cnt, err := s.Where(conds...).Count()
+	if err != nil {
+		return false, err
+	}
+	return cnt > 0, nil
+}
+
+// PluckIDs returns all primary key values under current scope.
+func (s smsCodeSendQueryDo) PluckIDs() ([]int64, error) {
+	ids := make([]int64, 0, 16)
+	pk := field.NewInt64(s.TableName(), "id")
+	if err := s.DO.Pluck(pk, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// GetByID finds a single record by primary key.
+func (s smsCodeSendQueryDo) GetByID(id int64) (*SmsCodeSend, error) {
+	pk := field.NewInt64(s.TableName(), "id")
+	return s.Where(pk.Eq(id)).First()
+}
+
+// GetByIDs finds records by primary key list.
+func (s smsCodeSendQueryDo) GetByIDs(ids ...int64) ([]*SmsCodeSend, error) {
+	if len(ids) == 0 {
+		return []*SmsCodeSend{}, nil
+	}
+	pk := field.NewInt64(s.TableName(), "id")
+	return s.Where(pk.In(ids...)).Find()
+}
+
+// DeleteByID deletes records by primary key.
+func (s smsCodeSendQueryDo) DeleteByID(id int64) (gen.ResultInfo, error) {
+	pk := field.NewInt64(s.TableName(), "id")
+	return s.Where(pk.Eq(id)).Delete()
+}
+
+// DeleteByIDs deletes records by a list of primary keys.
+func (s smsCodeSendQueryDo) DeleteByIDs(ids ...int64) (gen.ResultInfo, error) {
+	if len(ids) == 0 {
+		return gen.ResultInfo{RowsAffected: 0, Error: nil}, nil
+	}
+	pk := field.NewInt64(s.TableName(), "id")
+	return s.Where(pk.In(ids...)).Delete()
+}
+
+func (s *smsCodeSendQueryDo) withDO(do gen.Dao) *smsCodeSendQueryDo {
+	s.DO = *do.(*gen.DO)
+	return s
+}