From d9737d4ee39d8e95ba11c63b4101549e35ad3fbc Mon Sep 17 00:00:00 2001 From: Rogee Date: Tue, 23 Dec 2025 23:51:51 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E6=B7=BB=E5=8A=A0=E7=9F=AD=E4=BF=A1?= =?UTF-8?q?=E9=AA=8C=E8=AF=81=E7=A0=81=E5=8F=91=E9=80=81=E5=8A=9F=E8=83=BD?= =?UTF-8?q?=E5=8F=8A=E7=9B=B8=E5=85=B3=E6=95=B0=E6=8D=AE=E5=BA=93=E6=A8=A1?= =?UTF-8?q?=E5=9E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend_v1/app/http/admin/provider.gen.go | 16 +- backend_v1/app/http/admin/routes.gen.go | 14 +- backend_v1/app/http/admin/sms_code_sends.go | 1 - backend_v1/app/http/dto/sms_code_send.go | 1 - backend_v1/app/services/db.go | 1 - backend_v1/database/models/query.gen.go | 86 ++-- backend_v1/database/models/sms_code_send.go | 1 - .../database/models/sms_code_sends.gen.go | 57 +++ .../models/sms_code_sends.query.gen.go | 477 ++++++++++++++++++ 9 files changed, 596 insertions(+), 58 deletions(-) create mode 100644 backend_v1/database/models/sms_code_sends.gen.go create mode 100644 backend_v1/database/models/sms_code_sends.query.gen.go diff --git a/backend_v1/app/http/admin/provider.gen.go b/backend_v1/app/http/admin/provider.gen.go index 53f02b6..05d8e42 100755 --- a/backend_v1/app/http/admin/provider.gen.go +++ b/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 diff --git a/backend_v1/app/http/admin/routes.gen.go b/backend_v1/app/http/admin/routes.gen.go index 3bd9def..6c7862e 100644 --- a/backend_v1/app/http/admin/routes.gen.go +++ b/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. diff --git a/backend_v1/app/http/admin/sms_code_sends.go b/backend_v1/app/http/admin/sms_code_sends.go index 8d7c427..cf6edfa 100644 --- a/backend_v1/app/http/admin/sms_code_sends.go +++ b/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 } - diff --git a/backend_v1/app/http/dto/sms_code_send.go b/backend_v1/app/http/dto/sms_code_send.go index 0a84b89..f28923f 100644 --- a/backend_v1/app/http/dto/sms_code_send.go +++ b/backend_v1/app/http/dto/sms_code_send.go @@ -7,4 +7,3 @@ type SmsCodeSendListQuery struct { Phone *string `query:"phone"` } - diff --git a/backend_v1/app/services/db.go b/backend_v1/app/services/db.go index c08edec..f9d2f25 100644 --- a/backend_v1/app/services/db.go +++ b/backend_v1/app/services/db.go @@ -3,4 +3,3 @@ package services import "gorm.io/gorm" func DB() *gorm.DB { return _db } - diff --git a/backend_v1/database/models/query.gen.go b/backend_v1/database/models/query.gen.go index 9e4edd1..75ca829 100644 --- a/backend_v1/database/models/query.gen.go +++ b/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), } } diff --git a/backend_v1/database/models/sms_code_send.go b/backend_v1/database/models/sms_code_send.go index 8cc2150..98e1f87 100644 --- a/backend_v1/database/models/sms_code_send.go +++ b/backend_v1/database/models/sms_code_send.go @@ -14,4 +14,3 @@ type SmsCodeSend struct { } func (*SmsCodeSend) TableName() string { return TableNameSmsCodeSend } - diff --git a/backend_v1/database/models/sms_code_sends.gen.go b/backend_v1/database/models/sms_code_sends.gen.go new file mode 100644 index 0000000..3ec25df --- /dev/null +++ b/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 +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 +} diff --git a/backend_v1/database/models/sms_code_sends.query.gen.go b/backend_v1/database/models/sms_code_sends.query.gen.go new file mode 100644 index 0000000..278c117 --- /dev/null +++ b/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 +}