diff --git a/hack/gorm-gen/gorm.go b/hack/gorm-gen/gorm.go index 5076ea9..fe7e4c9 100644 --- a/hack/gorm-gen/gorm.go +++ b/hack/gorm-gen/gorm.go @@ -1,35 +1,25 @@ package main import ( - "leafdev.top/Leaf/api-platform/internal/entity" - "gorm.io/gen" + "leafdev.top/Leaf/api-platform/internal/entity" ) -// Dynamic SQL -//type Querier interface { -// // SELECT * FROM @@table WHERE name = @name{{if role !=""}} AND role = @role{{end}} -// FilterWithNameAndRole(name, role string) ([]gen.T, error) -//} - func main() { - //app, err := cmd.CreateApp() - //if err != nil { - // panic(err) - //} g := gen.NewGenerator(gen.Config{ OutPath: "../../internal/dao", Mode: gen.WithoutContext | gen.WithDefaultQuery | gen.WithQueryInterface, // generate mode }) - //g.UseDB(app.GORM) - g.ApplyBasic( + entity.Packages{}, entity.Api{}, + entity.ApiDocument{}, + entity.Order{}, + entity.OrderItem{}, + entity.UserPackage{}, + entity.PromoCode{}, ) - // Generate Type Safe API with Dynamic SQL defined on Querier interface for `model.Api` and `model.Company` - //g.ApplyInterface(func(Querier) {}, model.Api{}, model.Company{}) - g.Execute() } diff --git a/internal/dao/api_documents.gen.go b/internal/dao/api_documents.gen.go new file mode 100644 index 0000000..edb031e --- /dev/null +++ b/internal/dao/api_documents.gen.go @@ -0,0 +1,478 @@ +// 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 dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "leafdev.top/Leaf/api-platform/internal/entity" +) + +func newApiDocument(db *gorm.DB, opts ...gen.DOOption) apiDocument { + _apiDocument := apiDocument{} + + _apiDocument.apiDocumentDo.UseDB(db, opts...) + _apiDocument.apiDocumentDo.UseModel(&entity.ApiDocument{}) + + tableName := _apiDocument.apiDocumentDo.TableName() + _apiDocument.ALL = field.NewAsterisk(tableName) + _apiDocument.Id = field.NewUint(tableName, "id") + _apiDocument.CreatedAt = field.NewTime(tableName, "created_at") + _apiDocument.UpdatedAt = field.NewTime(tableName, "updated_at") + _apiDocument.ApiId = field.NewUint(tableName, "api_id") + _apiDocument.OpenAPIUrl = field.NewString(tableName, "openapi_url") + _apiDocument.Content = field.NewString(tableName, "content") + _apiDocument.Api = apiDocumentBelongsToApi{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Api", "entity.Api"), + } + + _apiDocument.fillFieldMap() + + return _apiDocument +} + +type apiDocument struct { + apiDocumentDo + + ALL field.Asterisk + Id field.Uint + CreatedAt field.Time + UpdatedAt field.Time + ApiId field.Uint + OpenAPIUrl field.String + Content field.String + Api apiDocumentBelongsToApi + + fieldMap map[string]field.Expr +} + +func (a apiDocument) Table(newTableName string) *apiDocument { + a.apiDocumentDo.UseTable(newTableName) + return a.updateTableName(newTableName) +} + +func (a apiDocument) As(alias string) *apiDocument { + a.apiDocumentDo.DO = *(a.apiDocumentDo.As(alias).(*gen.DO)) + return a.updateTableName(alias) +} + +func (a *apiDocument) updateTableName(table string) *apiDocument { + a.ALL = field.NewAsterisk(table) + a.Id = field.NewUint(table, "id") + a.CreatedAt = field.NewTime(table, "created_at") + a.UpdatedAt = field.NewTime(table, "updated_at") + a.ApiId = field.NewUint(table, "api_id") + a.OpenAPIUrl = field.NewString(table, "openapi_url") + a.Content = field.NewString(table, "content") + + a.fillFieldMap() + + return a +} + +func (a *apiDocument) 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 *apiDocument) fillFieldMap() { + a.fieldMap = make(map[string]field.Expr, 7) + a.fieldMap["id"] = a.Id + a.fieldMap["created_at"] = a.CreatedAt + a.fieldMap["updated_at"] = a.UpdatedAt + a.fieldMap["api_id"] = a.ApiId + a.fieldMap["openapi_url"] = a.OpenAPIUrl + a.fieldMap["content"] = a.Content + +} + +func (a apiDocument) clone(db *gorm.DB) apiDocument { + a.apiDocumentDo.ReplaceConnPool(db.Statement.ConnPool) + return a +} + +func (a apiDocument) replaceDB(db *gorm.DB) apiDocument { + a.apiDocumentDo.ReplaceDB(db) + return a +} + +type apiDocumentBelongsToApi struct { + db *gorm.DB + + field.RelationField +} + +func (a apiDocumentBelongsToApi) Where(conds ...field.Expr) *apiDocumentBelongsToApi { + 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 apiDocumentBelongsToApi) WithContext(ctx context.Context) *apiDocumentBelongsToApi { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a apiDocumentBelongsToApi) Session(session *gorm.Session) *apiDocumentBelongsToApi { + a.db = a.db.Session(session) + return &a +} + +func (a apiDocumentBelongsToApi) Model(m *entity.ApiDocument) *apiDocumentBelongsToApiTx { + return &apiDocumentBelongsToApiTx{a.db.Model(m).Association(a.Name())} +} + +type apiDocumentBelongsToApiTx struct{ tx *gorm.Association } + +func (a apiDocumentBelongsToApiTx) Find() (result *entity.Api, err error) { + return result, a.tx.Find(&result) +} + +func (a apiDocumentBelongsToApiTx) Append(values ...*entity.Api) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a apiDocumentBelongsToApiTx) Replace(values ...*entity.Api) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a apiDocumentBelongsToApiTx) Delete(values ...*entity.Api) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a apiDocumentBelongsToApiTx) Clear() error { + return a.tx.Clear() +} + +func (a apiDocumentBelongsToApiTx) Count() int64 { + return a.tx.Count() +} + +type apiDocumentDo struct{ gen.DO } + +type IApiDocumentDo interface { + gen.SubQuery + Debug() IApiDocumentDo + WithContext(ctx context.Context) IApiDocumentDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IApiDocumentDo + WriteDB() IApiDocumentDo + As(alias string) gen.Dao + Session(config *gorm.Session) IApiDocumentDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IApiDocumentDo + Not(conds ...gen.Condition) IApiDocumentDo + Or(conds ...gen.Condition) IApiDocumentDo + Select(conds ...field.Expr) IApiDocumentDo + Where(conds ...gen.Condition) IApiDocumentDo + Order(conds ...field.Expr) IApiDocumentDo + Distinct(cols ...field.Expr) IApiDocumentDo + Omit(cols ...field.Expr) IApiDocumentDo + Join(table schema.Tabler, on ...field.Expr) IApiDocumentDo + LeftJoin(table schema.Tabler, on ...field.Expr) IApiDocumentDo + RightJoin(table schema.Tabler, on ...field.Expr) IApiDocumentDo + Group(cols ...field.Expr) IApiDocumentDo + Having(conds ...gen.Condition) IApiDocumentDo + Limit(limit int) IApiDocumentDo + Offset(offset int) IApiDocumentDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IApiDocumentDo + Unscoped() IApiDocumentDo + Create(values ...*entity.ApiDocument) error + CreateInBatches(values []*entity.ApiDocument, batchSize int) error + Save(values ...*entity.ApiDocument) error + First() (*entity.ApiDocument, error) + Take() (*entity.ApiDocument, error) + Last() (*entity.ApiDocument, error) + Find() ([]*entity.ApiDocument, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.ApiDocument, err error) + FindInBatches(result *[]*entity.ApiDocument, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*entity.ApiDocument) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IApiDocumentDo + Assign(attrs ...field.AssignExpr) IApiDocumentDo + Joins(fields ...field.RelationField) IApiDocumentDo + Preload(fields ...field.RelationField) IApiDocumentDo + FirstOrInit() (*entity.ApiDocument, error) + FirstOrCreate() (*entity.ApiDocument, error) + FindByPage(offset int, limit int) (result []*entity.ApiDocument, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IApiDocumentDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (a apiDocumentDo) Debug() IApiDocumentDo { + return a.withDO(a.DO.Debug()) +} + +func (a apiDocumentDo) WithContext(ctx context.Context) IApiDocumentDo { + return a.withDO(a.DO.WithContext(ctx)) +} + +func (a apiDocumentDo) ReadDB() IApiDocumentDo { + return a.Clauses(dbresolver.Read) +} + +func (a apiDocumentDo) WriteDB() IApiDocumentDo { + return a.Clauses(dbresolver.Write) +} + +func (a apiDocumentDo) Session(config *gorm.Session) IApiDocumentDo { + return a.withDO(a.DO.Session(config)) +} + +func (a apiDocumentDo) Clauses(conds ...clause.Expression) IApiDocumentDo { + return a.withDO(a.DO.Clauses(conds...)) +} + +func (a apiDocumentDo) Returning(value interface{}, columns ...string) IApiDocumentDo { + return a.withDO(a.DO.Returning(value, columns...)) +} + +func (a apiDocumentDo) Not(conds ...gen.Condition) IApiDocumentDo { + return a.withDO(a.DO.Not(conds...)) +} + +func (a apiDocumentDo) Or(conds ...gen.Condition) IApiDocumentDo { + return a.withDO(a.DO.Or(conds...)) +} + +func (a apiDocumentDo) Select(conds ...field.Expr) IApiDocumentDo { + return a.withDO(a.DO.Select(conds...)) +} + +func (a apiDocumentDo) Where(conds ...gen.Condition) IApiDocumentDo { + return a.withDO(a.DO.Where(conds...)) +} + +func (a apiDocumentDo) Order(conds ...field.Expr) IApiDocumentDo { + return a.withDO(a.DO.Order(conds...)) +} + +func (a apiDocumentDo) Distinct(cols ...field.Expr) IApiDocumentDo { + return a.withDO(a.DO.Distinct(cols...)) +} + +func (a apiDocumentDo) Omit(cols ...field.Expr) IApiDocumentDo { + return a.withDO(a.DO.Omit(cols...)) +} + +func (a apiDocumentDo) Join(table schema.Tabler, on ...field.Expr) IApiDocumentDo { + return a.withDO(a.DO.Join(table, on...)) +} + +func (a apiDocumentDo) LeftJoin(table schema.Tabler, on ...field.Expr) IApiDocumentDo { + return a.withDO(a.DO.LeftJoin(table, on...)) +} + +func (a apiDocumentDo) RightJoin(table schema.Tabler, on ...field.Expr) IApiDocumentDo { + return a.withDO(a.DO.RightJoin(table, on...)) +} + +func (a apiDocumentDo) Group(cols ...field.Expr) IApiDocumentDo { + return a.withDO(a.DO.Group(cols...)) +} + +func (a apiDocumentDo) Having(conds ...gen.Condition) IApiDocumentDo { + return a.withDO(a.DO.Having(conds...)) +} + +func (a apiDocumentDo) Limit(limit int) IApiDocumentDo { + return a.withDO(a.DO.Limit(limit)) +} + +func (a apiDocumentDo) Offset(offset int) IApiDocumentDo { + return a.withDO(a.DO.Offset(offset)) +} + +func (a apiDocumentDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IApiDocumentDo { + return a.withDO(a.DO.Scopes(funcs...)) +} + +func (a apiDocumentDo) Unscoped() IApiDocumentDo { + return a.withDO(a.DO.Unscoped()) +} + +func (a apiDocumentDo) Create(values ...*entity.ApiDocument) error { + if len(values) == 0 { + return nil + } + return a.DO.Create(values) +} + +func (a apiDocumentDo) CreateInBatches(values []*entity.ApiDocument, 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 apiDocumentDo) Save(values ...*entity.ApiDocument) error { + if len(values) == 0 { + return nil + } + return a.DO.Save(values) +} + +func (a apiDocumentDo) First() (*entity.ApiDocument, error) { + if result, err := a.DO.First(); err != nil { + return nil, err + } else { + return result.(*entity.ApiDocument), nil + } +} + +func (a apiDocumentDo) Take() (*entity.ApiDocument, error) { + if result, err := a.DO.Take(); err != nil { + return nil, err + } else { + return result.(*entity.ApiDocument), nil + } +} + +func (a apiDocumentDo) Last() (*entity.ApiDocument, error) { + if result, err := a.DO.Last(); err != nil { + return nil, err + } else { + return result.(*entity.ApiDocument), nil + } +} + +func (a apiDocumentDo) Find() ([]*entity.ApiDocument, error) { + result, err := a.DO.Find() + return result.([]*entity.ApiDocument), err +} + +func (a apiDocumentDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.ApiDocument, err error) { + buf := make([]*entity.ApiDocument, 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 apiDocumentDo) FindInBatches(result *[]*entity.ApiDocument, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return a.DO.FindInBatches(result, batchSize, fc) +} + +func (a apiDocumentDo) Attrs(attrs ...field.AssignExpr) IApiDocumentDo { + return a.withDO(a.DO.Attrs(attrs...)) +} + +func (a apiDocumentDo) Assign(attrs ...field.AssignExpr) IApiDocumentDo { + return a.withDO(a.DO.Assign(attrs...)) +} + +func (a apiDocumentDo) Joins(fields ...field.RelationField) IApiDocumentDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Joins(_f)) + } + return &a +} + +func (a apiDocumentDo) Preload(fields ...field.RelationField) IApiDocumentDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Preload(_f)) + } + return &a +} + +func (a apiDocumentDo) FirstOrInit() (*entity.ApiDocument, error) { + if result, err := a.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*entity.ApiDocument), nil + } +} + +func (a apiDocumentDo) FirstOrCreate() (*entity.ApiDocument, error) { + if result, err := a.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*entity.ApiDocument), nil + } +} + +func (a apiDocumentDo) FindByPage(offset int, limit int) (result []*entity.ApiDocument, 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 apiDocumentDo) 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 apiDocumentDo) Scan(result interface{}) (err error) { + return a.DO.Scan(result) +} + +func (a apiDocumentDo) Delete(models ...*entity.ApiDocument) (result gen.ResultInfo, err error) { + return a.DO.Delete(models) +} + +func (a *apiDocumentDo) withDO(do gen.Dao) *apiDocumentDo { + a.DO = *do.(*gen.DO) + return a +} diff --git a/internal/dao/apis.gen.go b/internal/dao/apis.gen.go new file mode 100644 index 0000000..b5d1768 --- /dev/null +++ b/internal/dao/apis.gen.go @@ -0,0 +1,424 @@ +// 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 dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "leafdev.top/Leaf/api-platform/internal/entity" +) + +func newApi(db *gorm.DB, opts ...gen.DOOption) api { + _api := api{} + + _api.apiDo.UseDB(db, opts...) + _api.apiDo.UseModel(&entity.Api{}) + + tableName := _api.apiDo.TableName() + _api.ALL = field.NewAsterisk(tableName) + _api.Id = field.NewUint(tableName, "id") + _api.CreatedAt = field.NewTime(tableName, "created_at") + _api.UpdatedAt = field.NewTime(tableName, "updated_at") + _api.Name = field.NewString(tableName, "name") + _api.Description = field.NewString(tableName, "description") + _api.BackendUrl = field.NewString(tableName, "backend_url") + _api.AuthToken = field.NewString(tableName, "auth_token") + _api.OwnershipVerifiedAt = field.NewTime(tableName, "ownership_verified_at") + _api.OwnershipVerificationToken = field.NewString(tableName, "ownership_verification_token") + _api.UserId = field.NewString(tableName, "user_id") + _api.Status = field.NewString(tableName, "status") + _api.DeletedAt = field.NewField(tableName, "deleted_at") + + _api.fillFieldMap() + + return _api +} + +type api struct { + apiDo + + ALL field.Asterisk + Id field.Uint + CreatedAt field.Time + UpdatedAt field.Time + Name field.String + Description field.String + BackendUrl field.String + AuthToken field.String + OwnershipVerifiedAt field.Time + OwnershipVerificationToken field.String + UserId field.String + Status field.String + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (a api) Table(newTableName string) *api { + a.apiDo.UseTable(newTableName) + return a.updateTableName(newTableName) +} + +func (a api) As(alias string) *api { + a.apiDo.DO = *(a.apiDo.As(alias).(*gen.DO)) + return a.updateTableName(alias) +} + +func (a *api) updateTableName(table string) *api { + a.ALL = field.NewAsterisk(table) + a.Id = field.NewUint(table, "id") + a.CreatedAt = field.NewTime(table, "created_at") + a.UpdatedAt = field.NewTime(table, "updated_at") + a.Name = field.NewString(table, "name") + a.Description = field.NewString(table, "description") + a.BackendUrl = field.NewString(table, "backend_url") + a.AuthToken = field.NewString(table, "auth_token") + a.OwnershipVerifiedAt = field.NewTime(table, "ownership_verified_at") + a.OwnershipVerificationToken = field.NewString(table, "ownership_verification_token") + a.UserId = field.NewString(table, "user_id") + a.Status = field.NewString(table, "status") + a.DeletedAt = field.NewField(table, "deleted_at") + + a.fillFieldMap() + + return a +} + +func (a *api) 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 *api) fillFieldMap() { + a.fieldMap = make(map[string]field.Expr, 12) + a.fieldMap["id"] = a.Id + a.fieldMap["created_at"] = a.CreatedAt + a.fieldMap["updated_at"] = a.UpdatedAt + a.fieldMap["name"] = a.Name + a.fieldMap["description"] = a.Description + a.fieldMap["backend_url"] = a.BackendUrl + a.fieldMap["auth_token"] = a.AuthToken + a.fieldMap["ownership_verified_at"] = a.OwnershipVerifiedAt + a.fieldMap["ownership_verification_token"] = a.OwnershipVerificationToken + a.fieldMap["user_id"] = a.UserId + a.fieldMap["status"] = a.Status + a.fieldMap["deleted_at"] = a.DeletedAt +} + +func (a api) clone(db *gorm.DB) api { + a.apiDo.ReplaceConnPool(db.Statement.ConnPool) + return a +} + +func (a api) replaceDB(db *gorm.DB) api { + a.apiDo.ReplaceDB(db) + return a +} + +type apiDo struct{ gen.DO } + +type IApiDo interface { + gen.SubQuery + Debug() IApiDo + WithContext(ctx context.Context) IApiDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IApiDo + WriteDB() IApiDo + As(alias string) gen.Dao + Session(config *gorm.Session) IApiDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IApiDo + Not(conds ...gen.Condition) IApiDo + Or(conds ...gen.Condition) IApiDo + Select(conds ...field.Expr) IApiDo + Where(conds ...gen.Condition) IApiDo + Order(conds ...field.Expr) IApiDo + Distinct(cols ...field.Expr) IApiDo + Omit(cols ...field.Expr) IApiDo + Join(table schema.Tabler, on ...field.Expr) IApiDo + LeftJoin(table schema.Tabler, on ...field.Expr) IApiDo + RightJoin(table schema.Tabler, on ...field.Expr) IApiDo + Group(cols ...field.Expr) IApiDo + Having(conds ...gen.Condition) IApiDo + Limit(limit int) IApiDo + Offset(offset int) IApiDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IApiDo + Unscoped() IApiDo + Create(values ...*entity.Api) error + CreateInBatches(values []*entity.Api, batchSize int) error + Save(values ...*entity.Api) error + First() (*entity.Api, error) + Take() (*entity.Api, error) + Last() (*entity.Api, error) + Find() ([]*entity.Api, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Api, err error) + FindInBatches(result *[]*entity.Api, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*entity.Api) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IApiDo + Assign(attrs ...field.AssignExpr) IApiDo + Joins(fields ...field.RelationField) IApiDo + Preload(fields ...field.RelationField) IApiDo + FirstOrInit() (*entity.Api, error) + FirstOrCreate() (*entity.Api, error) + FindByPage(offset int, limit int) (result []*entity.Api, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IApiDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (a apiDo) Debug() IApiDo { + return a.withDO(a.DO.Debug()) +} + +func (a apiDo) WithContext(ctx context.Context) IApiDo { + return a.withDO(a.DO.WithContext(ctx)) +} + +func (a apiDo) ReadDB() IApiDo { + return a.Clauses(dbresolver.Read) +} + +func (a apiDo) WriteDB() IApiDo { + return a.Clauses(dbresolver.Write) +} + +func (a apiDo) Session(config *gorm.Session) IApiDo { + return a.withDO(a.DO.Session(config)) +} + +func (a apiDo) Clauses(conds ...clause.Expression) IApiDo { + return a.withDO(a.DO.Clauses(conds...)) +} + +func (a apiDo) Returning(value interface{}, columns ...string) IApiDo { + return a.withDO(a.DO.Returning(value, columns...)) +} + +func (a apiDo) Not(conds ...gen.Condition) IApiDo { + return a.withDO(a.DO.Not(conds...)) +} + +func (a apiDo) Or(conds ...gen.Condition) IApiDo { + return a.withDO(a.DO.Or(conds...)) +} + +func (a apiDo) Select(conds ...field.Expr) IApiDo { + return a.withDO(a.DO.Select(conds...)) +} + +func (a apiDo) Where(conds ...gen.Condition) IApiDo { + return a.withDO(a.DO.Where(conds...)) +} + +func (a apiDo) Order(conds ...field.Expr) IApiDo { + return a.withDO(a.DO.Order(conds...)) +} + +func (a apiDo) Distinct(cols ...field.Expr) IApiDo { + return a.withDO(a.DO.Distinct(cols...)) +} + +func (a apiDo) Omit(cols ...field.Expr) IApiDo { + return a.withDO(a.DO.Omit(cols...)) +} + +func (a apiDo) Join(table schema.Tabler, on ...field.Expr) IApiDo { + return a.withDO(a.DO.Join(table, on...)) +} + +func (a apiDo) LeftJoin(table schema.Tabler, on ...field.Expr) IApiDo { + return a.withDO(a.DO.LeftJoin(table, on...)) +} + +func (a apiDo) RightJoin(table schema.Tabler, on ...field.Expr) IApiDo { + return a.withDO(a.DO.RightJoin(table, on...)) +} + +func (a apiDo) Group(cols ...field.Expr) IApiDo { + return a.withDO(a.DO.Group(cols...)) +} + +func (a apiDo) Having(conds ...gen.Condition) IApiDo { + return a.withDO(a.DO.Having(conds...)) +} + +func (a apiDo) Limit(limit int) IApiDo { + return a.withDO(a.DO.Limit(limit)) +} + +func (a apiDo) Offset(offset int) IApiDo { + return a.withDO(a.DO.Offset(offset)) +} + +func (a apiDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IApiDo { + return a.withDO(a.DO.Scopes(funcs...)) +} + +func (a apiDo) Unscoped() IApiDo { + return a.withDO(a.DO.Unscoped()) +} + +func (a apiDo) Create(values ...*entity.Api) error { + if len(values) == 0 { + return nil + } + return a.DO.Create(values) +} + +func (a apiDo) CreateInBatches(values []*entity.Api, 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 apiDo) Save(values ...*entity.Api) error { + if len(values) == 0 { + return nil + } + return a.DO.Save(values) +} + +func (a apiDo) First() (*entity.Api, error) { + if result, err := a.DO.First(); err != nil { + return nil, err + } else { + return result.(*entity.Api), nil + } +} + +func (a apiDo) Take() (*entity.Api, error) { + if result, err := a.DO.Take(); err != nil { + return nil, err + } else { + return result.(*entity.Api), nil + } +} + +func (a apiDo) Last() (*entity.Api, error) { + if result, err := a.DO.Last(); err != nil { + return nil, err + } else { + return result.(*entity.Api), nil + } +} + +func (a apiDo) Find() ([]*entity.Api, error) { + result, err := a.DO.Find() + return result.([]*entity.Api), err +} + +func (a apiDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Api, err error) { + buf := make([]*entity.Api, 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 apiDo) FindInBatches(result *[]*entity.Api, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return a.DO.FindInBatches(result, batchSize, fc) +} + +func (a apiDo) Attrs(attrs ...field.AssignExpr) IApiDo { + return a.withDO(a.DO.Attrs(attrs...)) +} + +func (a apiDo) Assign(attrs ...field.AssignExpr) IApiDo { + return a.withDO(a.DO.Assign(attrs...)) +} + +func (a apiDo) Joins(fields ...field.RelationField) IApiDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Joins(_f)) + } + return &a +} + +func (a apiDo) Preload(fields ...field.RelationField) IApiDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Preload(_f)) + } + return &a +} + +func (a apiDo) FirstOrInit() (*entity.Api, error) { + if result, err := a.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*entity.Api), nil + } +} + +func (a apiDo) FirstOrCreate() (*entity.Api, error) { + if result, err := a.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*entity.Api), nil + } +} + +func (a apiDo) FindByPage(offset int, limit int) (result []*entity.Api, 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 apiDo) 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 apiDo) Scan(result interface{}) (err error) { + return a.DO.Scan(result) +} + +func (a apiDo) Delete(models ...*entity.Api) (result gen.ResultInfo, err error) { + return a.DO.Delete(models) +} + +func (a *apiDo) withDO(do gen.Dao) *apiDo { + a.DO = *do.(*gen.DO) + return a +} diff --git a/internal/dao/gen.go b/internal/dao/gen.go index 13df407..2df2931 100644 --- a/internal/dao/gen.go +++ b/internal/dao/gen.go @@ -16,34 +16,64 @@ import ( ) var ( - Q = new(Query) - User *user + Q = new(Query) + Api *api + ApiDocument *apiDocument + Order *order + OrderItem *orderItem + Packages *packages + PromoCode *promoCode + UserPackage *userPackage ) func SetDefault(db *gorm.DB, opts ...gen.DOOption) { *Q = *Use(db, opts...) - User = &Q.User + Api = &Q.Api + ApiDocument = &Q.ApiDocument + Order = &Q.Order + OrderItem = &Q.OrderItem + Packages = &Q.Packages + PromoCode = &Q.PromoCode + UserPackage = &Q.UserPackage } func Use(db *gorm.DB, opts ...gen.DOOption) *Query { return &Query{ - db: db, - User: newUser(db, opts...), + db: db, + Api: newApi(db, opts...), + ApiDocument: newApiDocument(db, opts...), + Order: newOrder(db, opts...), + OrderItem: newOrderItem(db, opts...), + Packages: newPackages(db, opts...), + PromoCode: newPromoCode(db, opts...), + UserPackage: newUserPackage(db, opts...), } } type Query struct { db *gorm.DB - User user + Api api + ApiDocument apiDocument + Order order + OrderItem orderItem + Packages packages + PromoCode promoCode + UserPackage userPackage } func (q *Query) Available() bool { return q.db != nil } func (q *Query) clone(db *gorm.DB) *Query { return &Query{ - db: db, - User: q.User.clone(db), + db: db, + Api: q.Api.clone(db), + ApiDocument: q.ApiDocument.clone(db), + Order: q.Order.clone(db), + OrderItem: q.OrderItem.clone(db), + Packages: q.Packages.clone(db), + PromoCode: q.PromoCode.clone(db), + UserPackage: q.UserPackage.clone(db), } } @@ -57,18 +87,36 @@ func (q *Query) WriteDB() *Query { func (q *Query) ReplaceDB(db *gorm.DB) *Query { return &Query{ - db: db, - User: q.User.replaceDB(db), + db: db, + Api: q.Api.replaceDB(db), + ApiDocument: q.ApiDocument.replaceDB(db), + Order: q.Order.replaceDB(db), + OrderItem: q.OrderItem.replaceDB(db), + Packages: q.Packages.replaceDB(db), + PromoCode: q.PromoCode.replaceDB(db), + UserPackage: q.UserPackage.replaceDB(db), } } type queryCtx struct { - User IUserDo + Api IApiDo + ApiDocument IApiDocumentDo + Order IOrderDo + OrderItem IOrderItemDo + Packages IPackagesDo + PromoCode IPromoCodeDo + UserPackage IUserPackageDo } func (q *Query) WithContext(ctx context.Context) *queryCtx { return &queryCtx{ - User: q.User.WithContext(ctx), + Api: q.Api.WithContext(ctx), + ApiDocument: q.ApiDocument.WithContext(ctx), + Order: q.Order.WithContext(ctx), + OrderItem: q.OrderItem.WithContext(ctx), + Packages: q.Packages.WithContext(ctx), + PromoCode: q.PromoCode.WithContext(ctx), + UserPackage: q.UserPackage.WithContext(ctx), } } diff --git a/internal/dao/order_items.gen.go b/internal/dao/order_items.gen.go new file mode 100644 index 0000000..b8d8baa --- /dev/null +++ b/internal/dao/order_items.gen.go @@ -0,0 +1,571 @@ +// 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 dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "leafdev.top/Leaf/api-platform/internal/entity" +) + +func newOrderItem(db *gorm.DB, opts ...gen.DOOption) orderItem { + _orderItem := orderItem{} + + _orderItem.orderItemDo.UseDB(db, opts...) + _orderItem.orderItemDo.UseModel(&entity.OrderItem{}) + + tableName := _orderItem.orderItemDo.TableName() + _orderItem.ALL = field.NewAsterisk(tableName) + _orderItem.Id = field.NewUint(tableName, "id") + _orderItem.CreatedAt = field.NewTime(tableName, "created_at") + _orderItem.UpdatedAt = field.NewTime(tableName, "updated_at") + _orderItem.OrderId = field.NewUint(tableName, "order_id") + _orderItem.PackageId = field.NewUint(tableName, "package_id") + _orderItem.Order = orderItemBelongsToOrder{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Order", "entity.Order"), + PromoCode: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Order.PromoCode", "entity.PromoCode"), + }, + } + + _orderItem.Package = orderItemBelongsToPackage{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Package", "entity.Packages"), + Api: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Package.Api", "entity.Api"), + }, + } + + _orderItem.fillFieldMap() + + return _orderItem +} + +type orderItem struct { + orderItemDo + + ALL field.Asterisk + Id field.Uint + CreatedAt field.Time + UpdatedAt field.Time + OrderId field.Uint + PackageId field.Uint + Order orderItemBelongsToOrder + + Package orderItemBelongsToPackage + + fieldMap map[string]field.Expr +} + +func (o orderItem) Table(newTableName string) *orderItem { + o.orderItemDo.UseTable(newTableName) + return o.updateTableName(newTableName) +} + +func (o orderItem) As(alias string) *orderItem { + o.orderItemDo.DO = *(o.orderItemDo.As(alias).(*gen.DO)) + return o.updateTableName(alias) +} + +func (o *orderItem) updateTableName(table string) *orderItem { + o.ALL = field.NewAsterisk(table) + o.Id = field.NewUint(table, "id") + o.CreatedAt = field.NewTime(table, "created_at") + o.UpdatedAt = field.NewTime(table, "updated_at") + o.OrderId = field.NewUint(table, "order_id") + o.PackageId = field.NewUint(table, "package_id") + + o.fillFieldMap() + + return o +} + +func (o *orderItem) 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 *orderItem) fillFieldMap() { + o.fieldMap = make(map[string]field.Expr, 7) + o.fieldMap["id"] = o.Id + o.fieldMap["created_at"] = o.CreatedAt + o.fieldMap["updated_at"] = o.UpdatedAt + o.fieldMap["order_id"] = o.OrderId + o.fieldMap["package_id"] = o.PackageId + +} + +func (o orderItem) clone(db *gorm.DB) orderItem { + o.orderItemDo.ReplaceConnPool(db.Statement.ConnPool) + return o +} + +func (o orderItem) replaceDB(db *gorm.DB) orderItem { + o.orderItemDo.ReplaceDB(db) + return o +} + +type orderItemBelongsToOrder struct { + db *gorm.DB + + field.RelationField + + PromoCode struct { + field.RelationField + } +} + +func (a orderItemBelongsToOrder) Where(conds ...field.Expr) *orderItemBelongsToOrder { + 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 orderItemBelongsToOrder) WithContext(ctx context.Context) *orderItemBelongsToOrder { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a orderItemBelongsToOrder) Session(session *gorm.Session) *orderItemBelongsToOrder { + a.db = a.db.Session(session) + return &a +} + +func (a orderItemBelongsToOrder) Model(m *entity.OrderItem) *orderItemBelongsToOrderTx { + return &orderItemBelongsToOrderTx{a.db.Model(m).Association(a.Name())} +} + +type orderItemBelongsToOrderTx struct{ tx *gorm.Association } + +func (a orderItemBelongsToOrderTx) Find() (result *entity.Order, err error) { + return result, a.tx.Find(&result) +} + +func (a orderItemBelongsToOrderTx) Append(values ...*entity.Order) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a orderItemBelongsToOrderTx) Replace(values ...*entity.Order) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a orderItemBelongsToOrderTx) Delete(values ...*entity.Order) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a orderItemBelongsToOrderTx) Clear() error { + return a.tx.Clear() +} + +func (a orderItemBelongsToOrderTx) Count() int64 { + return a.tx.Count() +} + +type orderItemBelongsToPackage struct { + db *gorm.DB + + field.RelationField + + Api struct { + field.RelationField + } +} + +func (a orderItemBelongsToPackage) Where(conds ...field.Expr) *orderItemBelongsToPackage { + 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 orderItemBelongsToPackage) WithContext(ctx context.Context) *orderItemBelongsToPackage { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a orderItemBelongsToPackage) Session(session *gorm.Session) *orderItemBelongsToPackage { + a.db = a.db.Session(session) + return &a +} + +func (a orderItemBelongsToPackage) Model(m *entity.OrderItem) *orderItemBelongsToPackageTx { + return &orderItemBelongsToPackageTx{a.db.Model(m).Association(a.Name())} +} + +type orderItemBelongsToPackageTx struct{ tx *gorm.Association } + +func (a orderItemBelongsToPackageTx) Find() (result *entity.Packages, err error) { + return result, a.tx.Find(&result) +} + +func (a orderItemBelongsToPackageTx) Append(values ...*entity.Packages) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a orderItemBelongsToPackageTx) Replace(values ...*entity.Packages) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a orderItemBelongsToPackageTx) Delete(values ...*entity.Packages) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a orderItemBelongsToPackageTx) Clear() error { + return a.tx.Clear() +} + +func (a orderItemBelongsToPackageTx) Count() int64 { + return a.tx.Count() +} + +type orderItemDo struct{ gen.DO } + +type IOrderItemDo interface { + gen.SubQuery + Debug() IOrderItemDo + WithContext(ctx context.Context) IOrderItemDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IOrderItemDo + WriteDB() IOrderItemDo + As(alias string) gen.Dao + Session(config *gorm.Session) IOrderItemDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IOrderItemDo + Not(conds ...gen.Condition) IOrderItemDo + Or(conds ...gen.Condition) IOrderItemDo + Select(conds ...field.Expr) IOrderItemDo + Where(conds ...gen.Condition) IOrderItemDo + Order(conds ...field.Expr) IOrderItemDo + Distinct(cols ...field.Expr) IOrderItemDo + Omit(cols ...field.Expr) IOrderItemDo + Join(table schema.Tabler, on ...field.Expr) IOrderItemDo + LeftJoin(table schema.Tabler, on ...field.Expr) IOrderItemDo + RightJoin(table schema.Tabler, on ...field.Expr) IOrderItemDo + Group(cols ...field.Expr) IOrderItemDo + Having(conds ...gen.Condition) IOrderItemDo + Limit(limit int) IOrderItemDo + Offset(offset int) IOrderItemDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IOrderItemDo + Unscoped() IOrderItemDo + Create(values ...*entity.OrderItem) error + CreateInBatches(values []*entity.OrderItem, batchSize int) error + Save(values ...*entity.OrderItem) error + First() (*entity.OrderItem, error) + Take() (*entity.OrderItem, error) + Last() (*entity.OrderItem, error) + Find() ([]*entity.OrderItem, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.OrderItem, err error) + FindInBatches(result *[]*entity.OrderItem, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*entity.OrderItem) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IOrderItemDo + Assign(attrs ...field.AssignExpr) IOrderItemDo + Joins(fields ...field.RelationField) IOrderItemDo + Preload(fields ...field.RelationField) IOrderItemDo + FirstOrInit() (*entity.OrderItem, error) + FirstOrCreate() (*entity.OrderItem, error) + FindByPage(offset int, limit int) (result []*entity.OrderItem, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IOrderItemDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (o orderItemDo) Debug() IOrderItemDo { + return o.withDO(o.DO.Debug()) +} + +func (o orderItemDo) WithContext(ctx context.Context) IOrderItemDo { + return o.withDO(o.DO.WithContext(ctx)) +} + +func (o orderItemDo) ReadDB() IOrderItemDo { + return o.Clauses(dbresolver.Read) +} + +func (o orderItemDo) WriteDB() IOrderItemDo { + return o.Clauses(dbresolver.Write) +} + +func (o orderItemDo) Session(config *gorm.Session) IOrderItemDo { + return o.withDO(o.DO.Session(config)) +} + +func (o orderItemDo) Clauses(conds ...clause.Expression) IOrderItemDo { + return o.withDO(o.DO.Clauses(conds...)) +} + +func (o orderItemDo) Returning(value interface{}, columns ...string) IOrderItemDo { + return o.withDO(o.DO.Returning(value, columns...)) +} + +func (o orderItemDo) Not(conds ...gen.Condition) IOrderItemDo { + return o.withDO(o.DO.Not(conds...)) +} + +func (o orderItemDo) Or(conds ...gen.Condition) IOrderItemDo { + return o.withDO(o.DO.Or(conds...)) +} + +func (o orderItemDo) Select(conds ...field.Expr) IOrderItemDo { + return o.withDO(o.DO.Select(conds...)) +} + +func (o orderItemDo) Where(conds ...gen.Condition) IOrderItemDo { + return o.withDO(o.DO.Where(conds...)) +} + +func (o orderItemDo) Order(conds ...field.Expr) IOrderItemDo { + return o.withDO(o.DO.Order(conds...)) +} + +func (o orderItemDo) Distinct(cols ...field.Expr) IOrderItemDo { + return o.withDO(o.DO.Distinct(cols...)) +} + +func (o orderItemDo) Omit(cols ...field.Expr) IOrderItemDo { + return o.withDO(o.DO.Omit(cols...)) +} + +func (o orderItemDo) Join(table schema.Tabler, on ...field.Expr) IOrderItemDo { + return o.withDO(o.DO.Join(table, on...)) +} + +func (o orderItemDo) LeftJoin(table schema.Tabler, on ...field.Expr) IOrderItemDo { + return o.withDO(o.DO.LeftJoin(table, on...)) +} + +func (o orderItemDo) RightJoin(table schema.Tabler, on ...field.Expr) IOrderItemDo { + return o.withDO(o.DO.RightJoin(table, on...)) +} + +func (o orderItemDo) Group(cols ...field.Expr) IOrderItemDo { + return o.withDO(o.DO.Group(cols...)) +} + +func (o orderItemDo) Having(conds ...gen.Condition) IOrderItemDo { + return o.withDO(o.DO.Having(conds...)) +} + +func (o orderItemDo) Limit(limit int) IOrderItemDo { + return o.withDO(o.DO.Limit(limit)) +} + +func (o orderItemDo) Offset(offset int) IOrderItemDo { + return o.withDO(o.DO.Offset(offset)) +} + +func (o orderItemDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IOrderItemDo { + return o.withDO(o.DO.Scopes(funcs...)) +} + +func (o orderItemDo) Unscoped() IOrderItemDo { + return o.withDO(o.DO.Unscoped()) +} + +func (o orderItemDo) Create(values ...*entity.OrderItem) error { + if len(values) == 0 { + return nil + } + return o.DO.Create(values) +} + +func (o orderItemDo) CreateInBatches(values []*entity.OrderItem, 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 orderItemDo) Save(values ...*entity.OrderItem) error { + if len(values) == 0 { + return nil + } + return o.DO.Save(values) +} + +func (o orderItemDo) First() (*entity.OrderItem, error) { + if result, err := o.DO.First(); err != nil { + return nil, err + } else { + return result.(*entity.OrderItem), nil + } +} + +func (o orderItemDo) Take() (*entity.OrderItem, error) { + if result, err := o.DO.Take(); err != nil { + return nil, err + } else { + return result.(*entity.OrderItem), nil + } +} + +func (o orderItemDo) Last() (*entity.OrderItem, error) { + if result, err := o.DO.Last(); err != nil { + return nil, err + } else { + return result.(*entity.OrderItem), nil + } +} + +func (o orderItemDo) Find() ([]*entity.OrderItem, error) { + result, err := o.DO.Find() + return result.([]*entity.OrderItem), err +} + +func (o orderItemDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.OrderItem, err error) { + buf := make([]*entity.OrderItem, 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 orderItemDo) FindInBatches(result *[]*entity.OrderItem, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return o.DO.FindInBatches(result, batchSize, fc) +} + +func (o orderItemDo) Attrs(attrs ...field.AssignExpr) IOrderItemDo { + return o.withDO(o.DO.Attrs(attrs...)) +} + +func (o orderItemDo) Assign(attrs ...field.AssignExpr) IOrderItemDo { + return o.withDO(o.DO.Assign(attrs...)) +} + +func (o orderItemDo) Joins(fields ...field.RelationField) IOrderItemDo { + for _, _f := range fields { + o = *o.withDO(o.DO.Joins(_f)) + } + return &o +} + +func (o orderItemDo) Preload(fields ...field.RelationField) IOrderItemDo { + for _, _f := range fields { + o = *o.withDO(o.DO.Preload(_f)) + } + return &o +} + +func (o orderItemDo) FirstOrInit() (*entity.OrderItem, error) { + if result, err := o.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*entity.OrderItem), nil + } +} + +func (o orderItemDo) FirstOrCreate() (*entity.OrderItem, error) { + if result, err := o.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*entity.OrderItem), nil + } +} + +func (o orderItemDo) FindByPage(offset int, limit int) (result []*entity.OrderItem, 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 orderItemDo) 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 orderItemDo) Scan(result interface{}) (err error) { + return o.DO.Scan(result) +} + +func (o orderItemDo) Delete(models ...*entity.OrderItem) (result gen.ResultInfo, err error) { + return o.DO.Delete(models) +} + +func (o *orderItemDo) withDO(do gen.Dao) *orderItemDo { + o.DO = *do.(*gen.DO) + return o +} diff --git a/internal/dao/orders.gen.go b/internal/dao/orders.gen.go new file mode 100644 index 0000000..46fc66d --- /dev/null +++ b/internal/dao/orders.gen.go @@ -0,0 +1,482 @@ +// 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 dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "leafdev.top/Leaf/api-platform/internal/entity" +) + +func newOrder(db *gorm.DB, opts ...gen.DOOption) order { + _order := order{} + + _order.orderDo.UseDB(db, opts...) + _order.orderDo.UseModel(&entity.Order{}) + + tableName := _order.orderDo.TableName() + _order.ALL = field.NewAsterisk(tableName) + _order.Id = field.NewUint(tableName, "id") + _order.CreatedAt = field.NewTime(tableName, "created_at") + _order.UpdatedAt = field.NewTime(tableName, "updated_at") + _order.UserId = field.NewString(tableName, "user_id") + _order.PromoCodeId = field.NewUint(tableName, "promo_code_id") + _order.Price = field.NewFloat64(tableName, "price") + _order.OrderDate = field.NewTime(tableName, "order_date") + _order.PromoCode = orderBelongsToPromoCode{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("PromoCode", "entity.PromoCode"), + } + + _order.fillFieldMap() + + return _order +} + +type order struct { + orderDo + + ALL field.Asterisk + Id field.Uint + CreatedAt field.Time + UpdatedAt field.Time + UserId field.String + PromoCodeId field.Uint + Price field.Float64 + OrderDate field.Time + PromoCode orderBelongsToPromoCode + + fieldMap map[string]field.Expr +} + +func (o order) Table(newTableName string) *order { + o.orderDo.UseTable(newTableName) + return o.updateTableName(newTableName) +} + +func (o order) As(alias string) *order { + o.orderDo.DO = *(o.orderDo.As(alias).(*gen.DO)) + return o.updateTableName(alias) +} + +func (o *order) updateTableName(table string) *order { + o.ALL = field.NewAsterisk(table) + o.Id = field.NewUint(table, "id") + o.CreatedAt = field.NewTime(table, "created_at") + o.UpdatedAt = field.NewTime(table, "updated_at") + o.UserId = field.NewString(table, "user_id") + o.PromoCodeId = field.NewUint(table, "promo_code_id") + o.Price = field.NewFloat64(table, "price") + o.OrderDate = field.NewTime(table, "order_date") + + o.fillFieldMap() + + return o +} + +func (o *order) 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 *order) fillFieldMap() { + o.fieldMap = make(map[string]field.Expr, 8) + o.fieldMap["id"] = o.Id + o.fieldMap["created_at"] = o.CreatedAt + o.fieldMap["updated_at"] = o.UpdatedAt + o.fieldMap["user_id"] = o.UserId + o.fieldMap["promo_code_id"] = o.PromoCodeId + o.fieldMap["price"] = o.Price + o.fieldMap["order_date"] = o.OrderDate + +} + +func (o order) clone(db *gorm.DB) order { + o.orderDo.ReplaceConnPool(db.Statement.ConnPool) + return o +} + +func (o order) replaceDB(db *gorm.DB) order { + o.orderDo.ReplaceDB(db) + return o +} + +type orderBelongsToPromoCode struct { + db *gorm.DB + + field.RelationField +} + +func (a orderBelongsToPromoCode) Where(conds ...field.Expr) *orderBelongsToPromoCode { + 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 orderBelongsToPromoCode) WithContext(ctx context.Context) *orderBelongsToPromoCode { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a orderBelongsToPromoCode) Session(session *gorm.Session) *orderBelongsToPromoCode { + a.db = a.db.Session(session) + return &a +} + +func (a orderBelongsToPromoCode) Model(m *entity.Order) *orderBelongsToPromoCodeTx { + return &orderBelongsToPromoCodeTx{a.db.Model(m).Association(a.Name())} +} + +type orderBelongsToPromoCodeTx struct{ tx *gorm.Association } + +func (a orderBelongsToPromoCodeTx) Find() (result *entity.PromoCode, err error) { + return result, a.tx.Find(&result) +} + +func (a orderBelongsToPromoCodeTx) Append(values ...*entity.PromoCode) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a orderBelongsToPromoCodeTx) Replace(values ...*entity.PromoCode) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a orderBelongsToPromoCodeTx) Delete(values ...*entity.PromoCode) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a orderBelongsToPromoCodeTx) Clear() error { + return a.tx.Clear() +} + +func (a orderBelongsToPromoCodeTx) Count() int64 { + return a.tx.Count() +} + +type orderDo struct{ gen.DO } + +type IOrderDo interface { + gen.SubQuery + Debug() IOrderDo + WithContext(ctx context.Context) IOrderDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IOrderDo + WriteDB() IOrderDo + As(alias string) gen.Dao + Session(config *gorm.Session) IOrderDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IOrderDo + Not(conds ...gen.Condition) IOrderDo + Or(conds ...gen.Condition) IOrderDo + Select(conds ...field.Expr) IOrderDo + Where(conds ...gen.Condition) IOrderDo + Order(conds ...field.Expr) IOrderDo + Distinct(cols ...field.Expr) IOrderDo + Omit(cols ...field.Expr) IOrderDo + Join(table schema.Tabler, on ...field.Expr) IOrderDo + LeftJoin(table schema.Tabler, on ...field.Expr) IOrderDo + RightJoin(table schema.Tabler, on ...field.Expr) IOrderDo + Group(cols ...field.Expr) IOrderDo + Having(conds ...gen.Condition) IOrderDo + Limit(limit int) IOrderDo + Offset(offset int) IOrderDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IOrderDo + Unscoped() IOrderDo + Create(values ...*entity.Order) error + CreateInBatches(values []*entity.Order, batchSize int) error + Save(values ...*entity.Order) error + First() (*entity.Order, error) + Take() (*entity.Order, error) + Last() (*entity.Order, error) + Find() ([]*entity.Order, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Order, err error) + FindInBatches(result *[]*entity.Order, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*entity.Order) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IOrderDo + Assign(attrs ...field.AssignExpr) IOrderDo + Joins(fields ...field.RelationField) IOrderDo + Preload(fields ...field.RelationField) IOrderDo + FirstOrInit() (*entity.Order, error) + FirstOrCreate() (*entity.Order, error) + FindByPage(offset int, limit int) (result []*entity.Order, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IOrderDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (o orderDo) Debug() IOrderDo { + return o.withDO(o.DO.Debug()) +} + +func (o orderDo) WithContext(ctx context.Context) IOrderDo { + return o.withDO(o.DO.WithContext(ctx)) +} + +func (o orderDo) ReadDB() IOrderDo { + return o.Clauses(dbresolver.Read) +} + +func (o orderDo) WriteDB() IOrderDo { + return o.Clauses(dbresolver.Write) +} + +func (o orderDo) Session(config *gorm.Session) IOrderDo { + return o.withDO(o.DO.Session(config)) +} + +func (o orderDo) Clauses(conds ...clause.Expression) IOrderDo { + return o.withDO(o.DO.Clauses(conds...)) +} + +func (o orderDo) Returning(value interface{}, columns ...string) IOrderDo { + return o.withDO(o.DO.Returning(value, columns...)) +} + +func (o orderDo) Not(conds ...gen.Condition) IOrderDo { + return o.withDO(o.DO.Not(conds...)) +} + +func (o orderDo) Or(conds ...gen.Condition) IOrderDo { + return o.withDO(o.DO.Or(conds...)) +} + +func (o orderDo) Select(conds ...field.Expr) IOrderDo { + return o.withDO(o.DO.Select(conds...)) +} + +func (o orderDo) Where(conds ...gen.Condition) IOrderDo { + return o.withDO(o.DO.Where(conds...)) +} + +func (o orderDo) Order(conds ...field.Expr) IOrderDo { + return o.withDO(o.DO.Order(conds...)) +} + +func (o orderDo) Distinct(cols ...field.Expr) IOrderDo { + return o.withDO(o.DO.Distinct(cols...)) +} + +func (o orderDo) Omit(cols ...field.Expr) IOrderDo { + return o.withDO(o.DO.Omit(cols...)) +} + +func (o orderDo) Join(table schema.Tabler, on ...field.Expr) IOrderDo { + return o.withDO(o.DO.Join(table, on...)) +} + +func (o orderDo) LeftJoin(table schema.Tabler, on ...field.Expr) IOrderDo { + return o.withDO(o.DO.LeftJoin(table, on...)) +} + +func (o orderDo) RightJoin(table schema.Tabler, on ...field.Expr) IOrderDo { + return o.withDO(o.DO.RightJoin(table, on...)) +} + +func (o orderDo) Group(cols ...field.Expr) IOrderDo { + return o.withDO(o.DO.Group(cols...)) +} + +func (o orderDo) Having(conds ...gen.Condition) IOrderDo { + return o.withDO(o.DO.Having(conds...)) +} + +func (o orderDo) Limit(limit int) IOrderDo { + return o.withDO(o.DO.Limit(limit)) +} + +func (o orderDo) Offset(offset int) IOrderDo { + return o.withDO(o.DO.Offset(offset)) +} + +func (o orderDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IOrderDo { + return o.withDO(o.DO.Scopes(funcs...)) +} + +func (o orderDo) Unscoped() IOrderDo { + return o.withDO(o.DO.Unscoped()) +} + +func (o orderDo) Create(values ...*entity.Order) error { + if len(values) == 0 { + return nil + } + return o.DO.Create(values) +} + +func (o orderDo) CreateInBatches(values []*entity.Order, 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 orderDo) Save(values ...*entity.Order) error { + if len(values) == 0 { + return nil + } + return o.DO.Save(values) +} + +func (o orderDo) First() (*entity.Order, error) { + if result, err := o.DO.First(); err != nil { + return nil, err + } else { + return result.(*entity.Order), nil + } +} + +func (o orderDo) Take() (*entity.Order, error) { + if result, err := o.DO.Take(); err != nil { + return nil, err + } else { + return result.(*entity.Order), nil + } +} + +func (o orderDo) Last() (*entity.Order, error) { + if result, err := o.DO.Last(); err != nil { + return nil, err + } else { + return result.(*entity.Order), nil + } +} + +func (o orderDo) Find() ([]*entity.Order, error) { + result, err := o.DO.Find() + return result.([]*entity.Order), err +} + +func (o orderDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Order, err error) { + buf := make([]*entity.Order, 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 orderDo) FindInBatches(result *[]*entity.Order, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return o.DO.FindInBatches(result, batchSize, fc) +} + +func (o orderDo) Attrs(attrs ...field.AssignExpr) IOrderDo { + return o.withDO(o.DO.Attrs(attrs...)) +} + +func (o orderDo) Assign(attrs ...field.AssignExpr) IOrderDo { + return o.withDO(o.DO.Assign(attrs...)) +} + +func (o orderDo) Joins(fields ...field.RelationField) IOrderDo { + for _, _f := range fields { + o = *o.withDO(o.DO.Joins(_f)) + } + return &o +} + +func (o orderDo) Preload(fields ...field.RelationField) IOrderDo { + for _, _f := range fields { + o = *o.withDO(o.DO.Preload(_f)) + } + return &o +} + +func (o orderDo) FirstOrInit() (*entity.Order, error) { + if result, err := o.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*entity.Order), nil + } +} + +func (o orderDo) FirstOrCreate() (*entity.Order, error) { + if result, err := o.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*entity.Order), nil + } +} + +func (o orderDo) FindByPage(offset int, limit int) (result []*entity.Order, 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 orderDo) 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 orderDo) Scan(result interface{}) (err error) { + return o.DO.Scan(result) +} + +func (o orderDo) Delete(models ...*entity.Order) (result gen.ResultInfo, err error) { + return o.DO.Delete(models) +} + +func (o *orderDo) withDO(do gen.Dao) *orderDo { + o.DO = *do.(*gen.DO) + return o +} diff --git a/internal/dao/packages.gen.go b/internal/dao/packages.gen.go new file mode 100644 index 0000000..253dac1 --- /dev/null +++ b/internal/dao/packages.gen.go @@ -0,0 +1,510 @@ +// 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 dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "leafdev.top/Leaf/api-platform/internal/entity" +) + +func newPackages(db *gorm.DB, opts ...gen.DOOption) packages { + _packages := packages{} + + _packages.packagesDo.UseDB(db, opts...) + _packages.packagesDo.UseModel(&entity.Packages{}) + + tableName := _packages.packagesDo.TableName() + _packages.ALL = field.NewAsterisk(tableName) + _packages.Id = field.NewUint(tableName, "id") + _packages.CreatedAt = field.NewTime(tableName, "created_at") + _packages.UpdatedAt = field.NewTime(tableName, "updated_at") + _packages.Name = field.NewString(tableName, "name") + _packages.Description = field.NewString(tableName, "description") + _packages.ApiId = field.NewUint(tableName, "api_id") + _packages.Price = field.NewFloat64(tableName, "price") + _packages.IsHidden = field.NewBool(tableName, "is_hidden") + _packages.IsPublished = field.NewBool(tableName, "is_published") + _packages.CallLimit = field.NewInt64(tableName, "call_limit") + _packages.Duration = field.NewInt64(tableName, "duration") + _packages.IsTrial = field.NewBool(tableName, "is_trial") + _packages.PurchaseLimit = field.NewInt64(tableName, "purchase_limit") + _packages.DeletedAt = field.NewField(tableName, "deleted_at") + _packages.Api = packagesBelongsToApi{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Api", "entity.Api"), + } + + _packages.fillFieldMap() + + return _packages +} + +type packages struct { + packagesDo + + ALL field.Asterisk + Id field.Uint + CreatedAt field.Time + UpdatedAt field.Time + Name field.String + Description field.String + ApiId field.Uint + Price field.Float64 + IsHidden field.Bool + IsPublished field.Bool + CallLimit field.Int64 + Duration field.Int64 + IsTrial field.Bool + PurchaseLimit field.Int64 + DeletedAt field.Field + Api packagesBelongsToApi + + fieldMap map[string]field.Expr +} + +func (p packages) Table(newTableName string) *packages { + p.packagesDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p packages) As(alias string) *packages { + p.packagesDo.DO = *(p.packagesDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *packages) updateTableName(table string) *packages { + p.ALL = field.NewAsterisk(table) + p.Id = field.NewUint(table, "id") + p.CreatedAt = field.NewTime(table, "created_at") + p.UpdatedAt = field.NewTime(table, "updated_at") + p.Name = field.NewString(table, "name") + p.Description = field.NewString(table, "description") + p.ApiId = field.NewUint(table, "api_id") + p.Price = field.NewFloat64(table, "price") + p.IsHidden = field.NewBool(table, "is_hidden") + p.IsPublished = field.NewBool(table, "is_published") + p.CallLimit = field.NewInt64(table, "call_limit") + p.Duration = field.NewInt64(table, "duration") + p.IsTrial = field.NewBool(table, "is_trial") + p.PurchaseLimit = field.NewInt64(table, "purchase_limit") + p.DeletedAt = field.NewField(table, "deleted_at") + + p.fillFieldMap() + + return p +} + +func (p *packages) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *packages) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 15) + p.fieldMap["id"] = p.Id + p.fieldMap["created_at"] = p.CreatedAt + p.fieldMap["updated_at"] = p.UpdatedAt + p.fieldMap["name"] = p.Name + p.fieldMap["description"] = p.Description + p.fieldMap["api_id"] = p.ApiId + p.fieldMap["price"] = p.Price + p.fieldMap["is_hidden"] = p.IsHidden + p.fieldMap["is_published"] = p.IsPublished + p.fieldMap["call_limit"] = p.CallLimit + p.fieldMap["duration"] = p.Duration + p.fieldMap["is_trial"] = p.IsTrial + p.fieldMap["purchase_limit"] = p.PurchaseLimit + p.fieldMap["deleted_at"] = p.DeletedAt + +} + +func (p packages) clone(db *gorm.DB) packages { + p.packagesDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p packages) replaceDB(db *gorm.DB) packages { + p.packagesDo.ReplaceDB(db) + return p +} + +type packagesBelongsToApi struct { + db *gorm.DB + + field.RelationField +} + +func (a packagesBelongsToApi) Where(conds ...field.Expr) *packagesBelongsToApi { + 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 packagesBelongsToApi) WithContext(ctx context.Context) *packagesBelongsToApi { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a packagesBelongsToApi) Session(session *gorm.Session) *packagesBelongsToApi { + a.db = a.db.Session(session) + return &a +} + +func (a packagesBelongsToApi) Model(m *entity.Packages) *packagesBelongsToApiTx { + return &packagesBelongsToApiTx{a.db.Model(m).Association(a.Name())} +} + +type packagesBelongsToApiTx struct{ tx *gorm.Association } + +func (a packagesBelongsToApiTx) Find() (result *entity.Api, err error) { + return result, a.tx.Find(&result) +} + +func (a packagesBelongsToApiTx) Append(values ...*entity.Api) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a packagesBelongsToApiTx) Replace(values ...*entity.Api) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a packagesBelongsToApiTx) Delete(values ...*entity.Api) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a packagesBelongsToApiTx) Clear() error { + return a.tx.Clear() +} + +func (a packagesBelongsToApiTx) Count() int64 { + return a.tx.Count() +} + +type packagesDo struct{ gen.DO } + +type IPackagesDo interface { + gen.SubQuery + Debug() IPackagesDo + WithContext(ctx context.Context) IPackagesDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IPackagesDo + WriteDB() IPackagesDo + As(alias string) gen.Dao + Session(config *gorm.Session) IPackagesDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IPackagesDo + Not(conds ...gen.Condition) IPackagesDo + Or(conds ...gen.Condition) IPackagesDo + Select(conds ...field.Expr) IPackagesDo + Where(conds ...gen.Condition) IPackagesDo + Order(conds ...field.Expr) IPackagesDo + Distinct(cols ...field.Expr) IPackagesDo + Omit(cols ...field.Expr) IPackagesDo + Join(table schema.Tabler, on ...field.Expr) IPackagesDo + LeftJoin(table schema.Tabler, on ...field.Expr) IPackagesDo + RightJoin(table schema.Tabler, on ...field.Expr) IPackagesDo + Group(cols ...field.Expr) IPackagesDo + Having(conds ...gen.Condition) IPackagesDo + Limit(limit int) IPackagesDo + Offset(offset int) IPackagesDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IPackagesDo + Unscoped() IPackagesDo + Create(values ...*entity.Packages) error + CreateInBatches(values []*entity.Packages, batchSize int) error + Save(values ...*entity.Packages) error + First() (*entity.Packages, error) + Take() (*entity.Packages, error) + Last() (*entity.Packages, error) + Find() ([]*entity.Packages, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Packages, err error) + FindInBatches(result *[]*entity.Packages, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*entity.Packages) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IPackagesDo + Assign(attrs ...field.AssignExpr) IPackagesDo + Joins(fields ...field.RelationField) IPackagesDo + Preload(fields ...field.RelationField) IPackagesDo + FirstOrInit() (*entity.Packages, error) + FirstOrCreate() (*entity.Packages, error) + FindByPage(offset int, limit int) (result []*entity.Packages, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IPackagesDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p packagesDo) Debug() IPackagesDo { + return p.withDO(p.DO.Debug()) +} + +func (p packagesDo) WithContext(ctx context.Context) IPackagesDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p packagesDo) ReadDB() IPackagesDo { + return p.Clauses(dbresolver.Read) +} + +func (p packagesDo) WriteDB() IPackagesDo { + return p.Clauses(dbresolver.Write) +} + +func (p packagesDo) Session(config *gorm.Session) IPackagesDo { + return p.withDO(p.DO.Session(config)) +} + +func (p packagesDo) Clauses(conds ...clause.Expression) IPackagesDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p packagesDo) Returning(value interface{}, columns ...string) IPackagesDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p packagesDo) Not(conds ...gen.Condition) IPackagesDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p packagesDo) Or(conds ...gen.Condition) IPackagesDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p packagesDo) Select(conds ...field.Expr) IPackagesDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p packagesDo) Where(conds ...gen.Condition) IPackagesDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p packagesDo) Order(conds ...field.Expr) IPackagesDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p packagesDo) Distinct(cols ...field.Expr) IPackagesDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p packagesDo) Omit(cols ...field.Expr) IPackagesDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p packagesDo) Join(table schema.Tabler, on ...field.Expr) IPackagesDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p packagesDo) LeftJoin(table schema.Tabler, on ...field.Expr) IPackagesDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p packagesDo) RightJoin(table schema.Tabler, on ...field.Expr) IPackagesDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p packagesDo) Group(cols ...field.Expr) IPackagesDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p packagesDo) Having(conds ...gen.Condition) IPackagesDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p packagesDo) Limit(limit int) IPackagesDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p packagesDo) Offset(offset int) IPackagesDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p packagesDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IPackagesDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p packagesDo) Unscoped() IPackagesDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p packagesDo) Create(values ...*entity.Packages) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p packagesDo) CreateInBatches(values []*entity.Packages, batchSize int) error { + return p.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 (p packagesDo) Save(values ...*entity.Packages) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p packagesDo) First() (*entity.Packages, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*entity.Packages), nil + } +} + +func (p packagesDo) Take() (*entity.Packages, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*entity.Packages), nil + } +} + +func (p packagesDo) Last() (*entity.Packages, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*entity.Packages), nil + } +} + +func (p packagesDo) Find() ([]*entity.Packages, error) { + result, err := p.DO.Find() + return result.([]*entity.Packages), err +} + +func (p packagesDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Packages, err error) { + buf := make([]*entity.Packages, 0, batchSize) + err = p.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 (p packagesDo) FindInBatches(result *[]*entity.Packages, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p packagesDo) Attrs(attrs ...field.AssignExpr) IPackagesDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p packagesDo) Assign(attrs ...field.AssignExpr) IPackagesDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p packagesDo) Joins(fields ...field.RelationField) IPackagesDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p packagesDo) Preload(fields ...field.RelationField) IPackagesDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p packagesDo) FirstOrInit() (*entity.Packages, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*entity.Packages), nil + } +} + +func (p packagesDo) FirstOrCreate() (*entity.Packages, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*entity.Packages), nil + } +} + +func (p packagesDo) FindByPage(offset int, limit int) (result []*entity.Packages, count int64, err error) { + result, err = p.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 = p.Offset(-1).Limit(-1).Count() + return +} + +func (p packagesDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p packagesDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p packagesDo) Delete(models ...*entity.Packages) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *packagesDo) withDO(do gen.Dao) *packagesDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/internal/dao/promo_codes.gen.go b/internal/dao/promo_codes.gen.go new file mode 100644 index 0000000..1bdec54 --- /dev/null +++ b/internal/dao/promo_codes.gen.go @@ -0,0 +1,412 @@ +// 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 dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "leafdev.top/Leaf/api-platform/internal/entity" +) + +func newPromoCode(db *gorm.DB, opts ...gen.DOOption) promoCode { + _promoCode := promoCode{} + + _promoCode.promoCodeDo.UseDB(db, opts...) + _promoCode.promoCodeDo.UseModel(&entity.PromoCode{}) + + tableName := _promoCode.promoCodeDo.TableName() + _promoCode.ALL = field.NewAsterisk(tableName) + _promoCode.Id = field.NewUint(tableName, "id") + _promoCode.CreatedAt = field.NewTime(tableName, "created_at") + _promoCode.UpdatedAt = field.NewTime(tableName, "updated_at") + _promoCode.Code = field.NewString(tableName, "code") + _promoCode.DiscountType = field.NewString(tableName, "discount_type") + _promoCode.DiscountValue = field.NewFloat64(tableName, "discount_value") + _promoCode.ExpirationDate = field.NewTime(tableName, "expiration_date") + _promoCode.IsActive = field.NewBool(tableName, "is_active") + _promoCode.DeletedAt = field.NewField(tableName, "deleted_at") + + _promoCode.fillFieldMap() + + return _promoCode +} + +type promoCode struct { + promoCodeDo + + ALL field.Asterisk + Id field.Uint + CreatedAt field.Time + UpdatedAt field.Time + Code field.String + DiscountType field.String + DiscountValue field.Float64 + ExpirationDate field.Time + IsActive field.Bool + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (p promoCode) Table(newTableName string) *promoCode { + p.promoCodeDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p promoCode) As(alias string) *promoCode { + p.promoCodeDo.DO = *(p.promoCodeDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *promoCode) updateTableName(table string) *promoCode { + p.ALL = field.NewAsterisk(table) + p.Id = field.NewUint(table, "id") + p.CreatedAt = field.NewTime(table, "created_at") + p.UpdatedAt = field.NewTime(table, "updated_at") + p.Code = field.NewString(table, "code") + p.DiscountType = field.NewString(table, "discount_type") + p.DiscountValue = field.NewFloat64(table, "discount_value") + p.ExpirationDate = field.NewTime(table, "expiration_date") + p.IsActive = field.NewBool(table, "is_active") + p.DeletedAt = field.NewField(table, "deleted_at") + + p.fillFieldMap() + + return p +} + +func (p *promoCode) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *promoCode) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 9) + p.fieldMap["id"] = p.Id + p.fieldMap["created_at"] = p.CreatedAt + p.fieldMap["updated_at"] = p.UpdatedAt + p.fieldMap["code"] = p.Code + p.fieldMap["discount_type"] = p.DiscountType + p.fieldMap["discount_value"] = p.DiscountValue + p.fieldMap["expiration_date"] = p.ExpirationDate + p.fieldMap["is_active"] = p.IsActive + p.fieldMap["deleted_at"] = p.DeletedAt +} + +func (p promoCode) clone(db *gorm.DB) promoCode { + p.promoCodeDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p promoCode) replaceDB(db *gorm.DB) promoCode { + p.promoCodeDo.ReplaceDB(db) + return p +} + +type promoCodeDo struct{ gen.DO } + +type IPromoCodeDo interface { + gen.SubQuery + Debug() IPromoCodeDo + WithContext(ctx context.Context) IPromoCodeDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IPromoCodeDo + WriteDB() IPromoCodeDo + As(alias string) gen.Dao + Session(config *gorm.Session) IPromoCodeDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IPromoCodeDo + Not(conds ...gen.Condition) IPromoCodeDo + Or(conds ...gen.Condition) IPromoCodeDo + Select(conds ...field.Expr) IPromoCodeDo + Where(conds ...gen.Condition) IPromoCodeDo + Order(conds ...field.Expr) IPromoCodeDo + Distinct(cols ...field.Expr) IPromoCodeDo + Omit(cols ...field.Expr) IPromoCodeDo + Join(table schema.Tabler, on ...field.Expr) IPromoCodeDo + LeftJoin(table schema.Tabler, on ...field.Expr) IPromoCodeDo + RightJoin(table schema.Tabler, on ...field.Expr) IPromoCodeDo + Group(cols ...field.Expr) IPromoCodeDo + Having(conds ...gen.Condition) IPromoCodeDo + Limit(limit int) IPromoCodeDo + Offset(offset int) IPromoCodeDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IPromoCodeDo + Unscoped() IPromoCodeDo + Create(values ...*entity.PromoCode) error + CreateInBatches(values []*entity.PromoCode, batchSize int) error + Save(values ...*entity.PromoCode) error + First() (*entity.PromoCode, error) + Take() (*entity.PromoCode, error) + Last() (*entity.PromoCode, error) + Find() ([]*entity.PromoCode, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.PromoCode, err error) + FindInBatches(result *[]*entity.PromoCode, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*entity.PromoCode) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IPromoCodeDo + Assign(attrs ...field.AssignExpr) IPromoCodeDo + Joins(fields ...field.RelationField) IPromoCodeDo + Preload(fields ...field.RelationField) IPromoCodeDo + FirstOrInit() (*entity.PromoCode, error) + FirstOrCreate() (*entity.PromoCode, error) + FindByPage(offset int, limit int) (result []*entity.PromoCode, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IPromoCodeDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p promoCodeDo) Debug() IPromoCodeDo { + return p.withDO(p.DO.Debug()) +} + +func (p promoCodeDo) WithContext(ctx context.Context) IPromoCodeDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p promoCodeDo) ReadDB() IPromoCodeDo { + return p.Clauses(dbresolver.Read) +} + +func (p promoCodeDo) WriteDB() IPromoCodeDo { + return p.Clauses(dbresolver.Write) +} + +func (p promoCodeDo) Session(config *gorm.Session) IPromoCodeDo { + return p.withDO(p.DO.Session(config)) +} + +func (p promoCodeDo) Clauses(conds ...clause.Expression) IPromoCodeDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p promoCodeDo) Returning(value interface{}, columns ...string) IPromoCodeDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p promoCodeDo) Not(conds ...gen.Condition) IPromoCodeDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p promoCodeDo) Or(conds ...gen.Condition) IPromoCodeDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p promoCodeDo) Select(conds ...field.Expr) IPromoCodeDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p promoCodeDo) Where(conds ...gen.Condition) IPromoCodeDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p promoCodeDo) Order(conds ...field.Expr) IPromoCodeDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p promoCodeDo) Distinct(cols ...field.Expr) IPromoCodeDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p promoCodeDo) Omit(cols ...field.Expr) IPromoCodeDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p promoCodeDo) Join(table schema.Tabler, on ...field.Expr) IPromoCodeDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p promoCodeDo) LeftJoin(table schema.Tabler, on ...field.Expr) IPromoCodeDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p promoCodeDo) RightJoin(table schema.Tabler, on ...field.Expr) IPromoCodeDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p promoCodeDo) Group(cols ...field.Expr) IPromoCodeDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p promoCodeDo) Having(conds ...gen.Condition) IPromoCodeDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p promoCodeDo) Limit(limit int) IPromoCodeDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p promoCodeDo) Offset(offset int) IPromoCodeDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p promoCodeDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IPromoCodeDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p promoCodeDo) Unscoped() IPromoCodeDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p promoCodeDo) Create(values ...*entity.PromoCode) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p promoCodeDo) CreateInBatches(values []*entity.PromoCode, batchSize int) error { + return p.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 (p promoCodeDo) Save(values ...*entity.PromoCode) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p promoCodeDo) First() (*entity.PromoCode, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*entity.PromoCode), nil + } +} + +func (p promoCodeDo) Take() (*entity.PromoCode, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*entity.PromoCode), nil + } +} + +func (p promoCodeDo) Last() (*entity.PromoCode, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*entity.PromoCode), nil + } +} + +func (p promoCodeDo) Find() ([]*entity.PromoCode, error) { + result, err := p.DO.Find() + return result.([]*entity.PromoCode), err +} + +func (p promoCodeDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.PromoCode, err error) { + buf := make([]*entity.PromoCode, 0, batchSize) + err = p.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 (p promoCodeDo) FindInBatches(result *[]*entity.PromoCode, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p promoCodeDo) Attrs(attrs ...field.AssignExpr) IPromoCodeDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p promoCodeDo) Assign(attrs ...field.AssignExpr) IPromoCodeDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p promoCodeDo) Joins(fields ...field.RelationField) IPromoCodeDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p promoCodeDo) Preload(fields ...field.RelationField) IPromoCodeDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p promoCodeDo) FirstOrInit() (*entity.PromoCode, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*entity.PromoCode), nil + } +} + +func (p promoCodeDo) FirstOrCreate() (*entity.PromoCode, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*entity.PromoCode), nil + } +} + +func (p promoCodeDo) FindByPage(offset int, limit int) (result []*entity.PromoCode, count int64, err error) { + result, err = p.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 = p.Offset(-1).Limit(-1).Count() + return +} + +func (p promoCodeDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p promoCodeDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p promoCodeDo) Delete(models ...*entity.PromoCode) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *promoCodeDo) withDO(do gen.Dao) *promoCodeDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/internal/dao/user_packages.gen.go b/internal/dao/user_packages.gen.go new file mode 100644 index 0000000..8d7550c --- /dev/null +++ b/internal/dao/user_packages.gen.go @@ -0,0 +1,499 @@ +// 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 dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "leafdev.top/Leaf/api-platform/internal/entity" +) + +func newUserPackage(db *gorm.DB, opts ...gen.DOOption) userPackage { + _userPackage := userPackage{} + + _userPackage.userPackageDo.UseDB(db, opts...) + _userPackage.userPackageDo.UseModel(&entity.UserPackage{}) + + tableName := _userPackage.userPackageDo.TableName() + _userPackage.ALL = field.NewAsterisk(tableName) + _userPackage.Id = field.NewUint(tableName, "id") + _userPackage.CreatedAt = field.NewTime(tableName, "created_at") + _userPackage.UpdatedAt = field.NewTime(tableName, "updated_at") + _userPackage.UserId = field.NewString(tableName, "user_id") + _userPackage.PackageId = field.NewUint(tableName, "package_id") + _userPackage.CallsLeft = field.NewInt64(tableName, "calls_left") + _userPackage.IsActive = field.NewBool(tableName, "is_active") + _userPackage.ExpirationAt = field.NewTime(tableName, "expiration_at") + _userPackage.PurchaseAt = field.NewTime(tableName, "purchase_at") + _userPackage.Package = userPackageBelongsToPackage{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Package", "entity.Packages"), + Api: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Package.Api", "entity.Api"), + }, + } + + _userPackage.fillFieldMap() + + return _userPackage +} + +type userPackage struct { + userPackageDo + + ALL field.Asterisk + Id field.Uint + CreatedAt field.Time + UpdatedAt field.Time + UserId field.String + PackageId field.Uint + CallsLeft field.Int64 + IsActive field.Bool + ExpirationAt field.Time + PurchaseAt field.Time + Package userPackageBelongsToPackage + + fieldMap map[string]field.Expr +} + +func (u userPackage) Table(newTableName string) *userPackage { + u.userPackageDo.UseTable(newTableName) + return u.updateTableName(newTableName) +} + +func (u userPackage) As(alias string) *userPackage { + u.userPackageDo.DO = *(u.userPackageDo.As(alias).(*gen.DO)) + return u.updateTableName(alias) +} + +func (u *userPackage) updateTableName(table string) *userPackage { + u.ALL = field.NewAsterisk(table) + u.Id = field.NewUint(table, "id") + u.CreatedAt = field.NewTime(table, "created_at") + u.UpdatedAt = field.NewTime(table, "updated_at") + u.UserId = field.NewString(table, "user_id") + u.PackageId = field.NewUint(table, "package_id") + u.CallsLeft = field.NewInt64(table, "calls_left") + u.IsActive = field.NewBool(table, "is_active") + u.ExpirationAt = field.NewTime(table, "expiration_at") + u.PurchaseAt = field.NewTime(table, "purchase_at") + + u.fillFieldMap() + + return u +} + +func (u *userPackage) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := u.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (u *userPackage) fillFieldMap() { + u.fieldMap = make(map[string]field.Expr, 10) + u.fieldMap["id"] = u.Id + u.fieldMap["created_at"] = u.CreatedAt + u.fieldMap["updated_at"] = u.UpdatedAt + u.fieldMap["user_id"] = u.UserId + u.fieldMap["package_id"] = u.PackageId + u.fieldMap["calls_left"] = u.CallsLeft + u.fieldMap["is_active"] = u.IsActive + u.fieldMap["expiration_at"] = u.ExpirationAt + u.fieldMap["purchase_at"] = u.PurchaseAt + +} + +func (u userPackage) clone(db *gorm.DB) userPackage { + u.userPackageDo.ReplaceConnPool(db.Statement.ConnPool) + return u +} + +func (u userPackage) replaceDB(db *gorm.DB) userPackage { + u.userPackageDo.ReplaceDB(db) + return u +} + +type userPackageBelongsToPackage struct { + db *gorm.DB + + field.RelationField + + Api struct { + field.RelationField + } +} + +func (a userPackageBelongsToPackage) Where(conds ...field.Expr) *userPackageBelongsToPackage { + 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 userPackageBelongsToPackage) WithContext(ctx context.Context) *userPackageBelongsToPackage { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a userPackageBelongsToPackage) Session(session *gorm.Session) *userPackageBelongsToPackage { + a.db = a.db.Session(session) + return &a +} + +func (a userPackageBelongsToPackage) Model(m *entity.UserPackage) *userPackageBelongsToPackageTx { + return &userPackageBelongsToPackageTx{a.db.Model(m).Association(a.Name())} +} + +type userPackageBelongsToPackageTx struct{ tx *gorm.Association } + +func (a userPackageBelongsToPackageTx) Find() (result *entity.Packages, err error) { + return result, a.tx.Find(&result) +} + +func (a userPackageBelongsToPackageTx) Append(values ...*entity.Packages) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a userPackageBelongsToPackageTx) Replace(values ...*entity.Packages) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a userPackageBelongsToPackageTx) Delete(values ...*entity.Packages) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a userPackageBelongsToPackageTx) Clear() error { + return a.tx.Clear() +} + +func (a userPackageBelongsToPackageTx) Count() int64 { + return a.tx.Count() +} + +type userPackageDo struct{ gen.DO } + +type IUserPackageDo interface { + gen.SubQuery + Debug() IUserPackageDo + WithContext(ctx context.Context) IUserPackageDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IUserPackageDo + WriteDB() IUserPackageDo + As(alias string) gen.Dao + Session(config *gorm.Session) IUserPackageDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IUserPackageDo + Not(conds ...gen.Condition) IUserPackageDo + Or(conds ...gen.Condition) IUserPackageDo + Select(conds ...field.Expr) IUserPackageDo + Where(conds ...gen.Condition) IUserPackageDo + Order(conds ...field.Expr) IUserPackageDo + Distinct(cols ...field.Expr) IUserPackageDo + Omit(cols ...field.Expr) IUserPackageDo + Join(table schema.Tabler, on ...field.Expr) IUserPackageDo + LeftJoin(table schema.Tabler, on ...field.Expr) IUserPackageDo + RightJoin(table schema.Tabler, on ...field.Expr) IUserPackageDo + Group(cols ...field.Expr) IUserPackageDo + Having(conds ...gen.Condition) IUserPackageDo + Limit(limit int) IUserPackageDo + Offset(offset int) IUserPackageDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IUserPackageDo + Unscoped() IUserPackageDo + Create(values ...*entity.UserPackage) error + CreateInBatches(values []*entity.UserPackage, batchSize int) error + Save(values ...*entity.UserPackage) error + First() (*entity.UserPackage, error) + Take() (*entity.UserPackage, error) + Last() (*entity.UserPackage, error) + Find() ([]*entity.UserPackage, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserPackage, err error) + FindInBatches(result *[]*entity.UserPackage, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*entity.UserPackage) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IUserPackageDo + Assign(attrs ...field.AssignExpr) IUserPackageDo + Joins(fields ...field.RelationField) IUserPackageDo + Preload(fields ...field.RelationField) IUserPackageDo + FirstOrInit() (*entity.UserPackage, error) + FirstOrCreate() (*entity.UserPackage, error) + FindByPage(offset int, limit int) (result []*entity.UserPackage, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IUserPackageDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (u userPackageDo) Debug() IUserPackageDo { + return u.withDO(u.DO.Debug()) +} + +func (u userPackageDo) WithContext(ctx context.Context) IUserPackageDo { + return u.withDO(u.DO.WithContext(ctx)) +} + +func (u userPackageDo) ReadDB() IUserPackageDo { + return u.Clauses(dbresolver.Read) +} + +func (u userPackageDo) WriteDB() IUserPackageDo { + return u.Clauses(dbresolver.Write) +} + +func (u userPackageDo) Session(config *gorm.Session) IUserPackageDo { + return u.withDO(u.DO.Session(config)) +} + +func (u userPackageDo) Clauses(conds ...clause.Expression) IUserPackageDo { + return u.withDO(u.DO.Clauses(conds...)) +} + +func (u userPackageDo) Returning(value interface{}, columns ...string) IUserPackageDo { + return u.withDO(u.DO.Returning(value, columns...)) +} + +func (u userPackageDo) Not(conds ...gen.Condition) IUserPackageDo { + return u.withDO(u.DO.Not(conds...)) +} + +func (u userPackageDo) Or(conds ...gen.Condition) IUserPackageDo { + return u.withDO(u.DO.Or(conds...)) +} + +func (u userPackageDo) Select(conds ...field.Expr) IUserPackageDo { + return u.withDO(u.DO.Select(conds...)) +} + +func (u userPackageDo) Where(conds ...gen.Condition) IUserPackageDo { + return u.withDO(u.DO.Where(conds...)) +} + +func (u userPackageDo) Order(conds ...field.Expr) IUserPackageDo { + return u.withDO(u.DO.Order(conds...)) +} + +func (u userPackageDo) Distinct(cols ...field.Expr) IUserPackageDo { + return u.withDO(u.DO.Distinct(cols...)) +} + +func (u userPackageDo) Omit(cols ...field.Expr) IUserPackageDo { + return u.withDO(u.DO.Omit(cols...)) +} + +func (u userPackageDo) Join(table schema.Tabler, on ...field.Expr) IUserPackageDo { + return u.withDO(u.DO.Join(table, on...)) +} + +func (u userPackageDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserPackageDo { + return u.withDO(u.DO.LeftJoin(table, on...)) +} + +func (u userPackageDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserPackageDo { + return u.withDO(u.DO.RightJoin(table, on...)) +} + +func (u userPackageDo) Group(cols ...field.Expr) IUserPackageDo { + return u.withDO(u.DO.Group(cols...)) +} + +func (u userPackageDo) Having(conds ...gen.Condition) IUserPackageDo { + return u.withDO(u.DO.Having(conds...)) +} + +func (u userPackageDo) Limit(limit int) IUserPackageDo { + return u.withDO(u.DO.Limit(limit)) +} + +func (u userPackageDo) Offset(offset int) IUserPackageDo { + return u.withDO(u.DO.Offset(offset)) +} + +func (u userPackageDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserPackageDo { + return u.withDO(u.DO.Scopes(funcs...)) +} + +func (u userPackageDo) Unscoped() IUserPackageDo { + return u.withDO(u.DO.Unscoped()) +} + +func (u userPackageDo) Create(values ...*entity.UserPackage) error { + if len(values) == 0 { + return nil + } + return u.DO.Create(values) +} + +func (u userPackageDo) CreateInBatches(values []*entity.UserPackage, batchSize int) error { + return u.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 (u userPackageDo) Save(values ...*entity.UserPackage) error { + if len(values) == 0 { + return nil + } + return u.DO.Save(values) +} + +func (u userPackageDo) First() (*entity.UserPackage, error) { + if result, err := u.DO.First(); err != nil { + return nil, err + } else { + return result.(*entity.UserPackage), nil + } +} + +func (u userPackageDo) Take() (*entity.UserPackage, error) { + if result, err := u.DO.Take(); err != nil { + return nil, err + } else { + return result.(*entity.UserPackage), nil + } +} + +func (u userPackageDo) Last() (*entity.UserPackage, error) { + if result, err := u.DO.Last(); err != nil { + return nil, err + } else { + return result.(*entity.UserPackage), nil + } +} + +func (u userPackageDo) Find() ([]*entity.UserPackage, error) { + result, err := u.DO.Find() + return result.([]*entity.UserPackage), err +} + +func (u userPackageDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserPackage, err error) { + buf := make([]*entity.UserPackage, 0, batchSize) + err = u.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 (u userPackageDo) FindInBatches(result *[]*entity.UserPackage, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return u.DO.FindInBatches(result, batchSize, fc) +} + +func (u userPackageDo) Attrs(attrs ...field.AssignExpr) IUserPackageDo { + return u.withDO(u.DO.Attrs(attrs...)) +} + +func (u userPackageDo) Assign(attrs ...field.AssignExpr) IUserPackageDo { + return u.withDO(u.DO.Assign(attrs...)) +} + +func (u userPackageDo) Joins(fields ...field.RelationField) IUserPackageDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Joins(_f)) + } + return &u +} + +func (u userPackageDo) Preload(fields ...field.RelationField) IUserPackageDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Preload(_f)) + } + return &u +} + +func (u userPackageDo) FirstOrInit() (*entity.UserPackage, error) { + if result, err := u.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*entity.UserPackage), nil + } +} + +func (u userPackageDo) FirstOrCreate() (*entity.UserPackage, error) { + if result, err := u.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*entity.UserPackage), nil + } +} + +func (u userPackageDo) FindByPage(offset int, limit int) (result []*entity.UserPackage, count int64, err error) { + result, err = u.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 = u.Offset(-1).Limit(-1).Count() + return +} + +func (u userPackageDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = u.Count() + if err != nil { + return + } + + err = u.Offset(offset).Limit(limit).Scan(result) + return +} + +func (u userPackageDo) Scan(result interface{}) (err error) { + return u.DO.Scan(result) +} + +func (u userPackageDo) Delete(models ...*entity.UserPackage) (result gen.ResultInfo, err error) { + return u.DO.Delete(models) +} + +func (u *userPackageDo) withDO(do gen.Dao) *userPackageDo { + u.DO = *do.(*gen.DO) + return u +} diff --git a/internal/dao/users.gen.go b/internal/dao/users.gen.go deleted file mode 100644 index 6ae6b95..0000000 --- a/internal/dao/users.gen.go +++ /dev/null @@ -1,392 +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 dao - -import ( - "context" - - "gorm.io/gorm" - "gorm.io/gorm/clause" - "gorm.io/gorm/schema" - - "gorm.io/gen" - "gorm.io/gen/field" - - "gorm.io/plugin/dbresolver" - - "leafdev.top/Leaf/api-platform/internal/entity" -) - -func newUser(db *gorm.DB, opts ...gen.DOOption) user { - _user := user{} - - _user.userDo.UseDB(db, opts...) - _user.userDo.UseModel(&entity.Api{}) - - tableName := _user.userDo.TableName() - _user.ALL = field.NewAsterisk(tableName) - _user.Id = field.NewUint(tableName, "id") - _user.CreatedAt = field.NewTime(tableName, "created_at") - _user.UpdatedAt = field.NewTime(tableName, "updated_at") - _user.Name = field.NewString(tableName, "name") - - _user.fillFieldMap() - - return _user -} - -type user struct { - userDo - - ALL field.Asterisk - Id field.Uint - CreatedAt field.Time - UpdatedAt field.Time - Name field.String - - fieldMap map[string]field.Expr -} - -func (u user) Table(newTableName string) *user { - u.userDo.UseTable(newTableName) - return u.updateTableName(newTableName) -} - -func (u user) As(alias string) *user { - u.userDo.DO = *(u.userDo.As(alias).(*gen.DO)) - return u.updateTableName(alias) -} - -func (u *user) updateTableName(table string) *user { - u.ALL = field.NewAsterisk(table) - u.Id = field.NewUint(table, "id") - u.CreatedAt = field.NewTime(table, "created_at") - u.UpdatedAt = field.NewTime(table, "updated_at") - u.Name = field.NewString(table, "name") - - u.fillFieldMap() - - return u -} - -func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) { - _f, ok := u.fieldMap[fieldName] - if !ok || _f == nil { - return nil, false - } - _oe, ok := _f.(field.OrderExpr) - return _oe, ok -} - -func (u *user) fillFieldMap() { - u.fieldMap = make(map[string]field.Expr, 4) - u.fieldMap["id"] = u.Id - u.fieldMap["created_at"] = u.CreatedAt - u.fieldMap["updated_at"] = u.UpdatedAt - u.fieldMap["name"] = u.Name -} - -func (u user) clone(db *gorm.DB) user { - u.userDo.ReplaceConnPool(db.Statement.ConnPool) - return u -} - -func (u user) replaceDB(db *gorm.DB) user { - u.userDo.ReplaceDB(db) - return u -} - -type userDo struct{ gen.DO } - -type IUserDo interface { - gen.SubQuery - Debug() IUserDo - WithContext(ctx context.Context) IUserDo - WithResult(fc func(tx gen.Dao)) gen.ResultInfo - ReplaceDB(db *gorm.DB) - ReadDB() IUserDo - WriteDB() IUserDo - As(alias string) gen.Dao - Session(config *gorm.Session) IUserDo - Columns(cols ...field.Expr) gen.Columns - Clauses(conds ...clause.Expression) IUserDo - Not(conds ...gen.Condition) IUserDo - Or(conds ...gen.Condition) IUserDo - Select(conds ...field.Expr) IUserDo - Where(conds ...gen.Condition) IUserDo - Order(conds ...field.Expr) IUserDo - Distinct(cols ...field.Expr) IUserDo - Omit(cols ...field.Expr) IUserDo - Join(table schema.Tabler, on ...field.Expr) IUserDo - LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo - RightJoin(table schema.Tabler, on ...field.Expr) IUserDo - Group(cols ...field.Expr) IUserDo - Having(conds ...gen.Condition) IUserDo - Limit(limit int) IUserDo - Offset(offset int) IUserDo - Count() (count int64, err error) - Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo - Unscoped() IUserDo - Create(values ...*entity.Api) error - CreateInBatches(values []*entity.Api, batchSize int) error - Save(values ...*entity.Api) error - First() (*entity.Api, error) - Take() (*entity.Api, error) - Last() (*entity.Api, error) - Find() ([]*entity.Api, error) - FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Api, err error) - FindInBatches(result *[]*entity.Api, batchSize int, fc func(tx gen.Dao, batch int) error) error - Pluck(column field.Expr, dest interface{}) error - Delete(...*entity.Api) (info gen.ResultInfo, err error) - Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) - UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) - Updates(value interface{}) (info gen.ResultInfo, err error) - UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) - UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) - UpdateColumns(value interface{}) (info gen.ResultInfo, err error) - UpdateFrom(q gen.SubQuery) gen.Dao - Attrs(attrs ...field.AssignExpr) IUserDo - Assign(attrs ...field.AssignExpr) IUserDo - Joins(fields ...field.RelationField) IUserDo - Preload(fields ...field.RelationField) IUserDo - FirstOrInit() (*entity.Api, error) - FirstOrCreate() (*entity.Api, error) - FindByPage(offset int, limit int) (result []*entity.Api, count int64, err error) - ScanByPage(result interface{}, offset int, limit int) (count int64, err error) - Scan(result interface{}) (err error) - Returning(value interface{}, columns ...string) IUserDo - UnderlyingDB() *gorm.DB - schema.Tabler -} - -func (u userDo) Debug() IUserDo { - return u.withDO(u.DO.Debug()) -} - -func (u userDo) WithContext(ctx context.Context) IUserDo { - return u.withDO(u.DO.WithContext(ctx)) -} - -func (u userDo) ReadDB() IUserDo { - return u.Clauses(dbresolver.Read) -} - -func (u userDo) WriteDB() IUserDo { - return u.Clauses(dbresolver.Write) -} - -func (u userDo) Session(config *gorm.Session) IUserDo { - return u.withDO(u.DO.Session(config)) -} - -func (u userDo) Clauses(conds ...clause.Expression) IUserDo { - return u.withDO(u.DO.Clauses(conds...)) -} - -func (u userDo) Returning(value interface{}, columns ...string) IUserDo { - return u.withDO(u.DO.Returning(value, columns...)) -} - -func (u userDo) Not(conds ...gen.Condition) IUserDo { - return u.withDO(u.DO.Not(conds...)) -} - -func (u userDo) Or(conds ...gen.Condition) IUserDo { - return u.withDO(u.DO.Or(conds...)) -} - -func (u userDo) Select(conds ...field.Expr) IUserDo { - return u.withDO(u.DO.Select(conds...)) -} - -func (u userDo) Where(conds ...gen.Condition) IUserDo { - return u.withDO(u.DO.Where(conds...)) -} - -func (u userDo) Order(conds ...field.Expr) IUserDo { - return u.withDO(u.DO.Order(conds...)) -} - -func (u userDo) Distinct(cols ...field.Expr) IUserDo { - return u.withDO(u.DO.Distinct(cols...)) -} - -func (u userDo) Omit(cols ...field.Expr) IUserDo { - return u.withDO(u.DO.Omit(cols...)) -} - -func (u userDo) Join(table schema.Tabler, on ...field.Expr) IUserDo { - return u.withDO(u.DO.Join(table, on...)) -} - -func (u userDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo { - return u.withDO(u.DO.LeftJoin(table, on...)) -} - -func (u userDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserDo { - return u.withDO(u.DO.RightJoin(table, on...)) -} - -func (u userDo) Group(cols ...field.Expr) IUserDo { - return u.withDO(u.DO.Group(cols...)) -} - -func (u userDo) Having(conds ...gen.Condition) IUserDo { - return u.withDO(u.DO.Having(conds...)) -} - -func (u userDo) Limit(limit int) IUserDo { - return u.withDO(u.DO.Limit(limit)) -} - -func (u userDo) Offset(offset int) IUserDo { - return u.withDO(u.DO.Offset(offset)) -} - -func (u userDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo { - return u.withDO(u.DO.Scopes(funcs...)) -} - -func (u userDo) Unscoped() IUserDo { - return u.withDO(u.DO.Unscoped()) -} - -func (u userDo) Create(values ...*entity.Api) error { - if len(values) == 0 { - return nil - } - return u.DO.Create(values) -} - -func (u userDo) CreateInBatches(values []*entity.Api, batchSize int) error { - return u.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 (u userDo) Save(values ...*entity.Api) error { - if len(values) == 0 { - return nil - } - return u.DO.Save(values) -} - -func (u userDo) First() (*entity.Api, error) { - if result, err := u.DO.First(); err != nil { - return nil, err - } else { - return result.(*entity.Api), nil - } -} - -func (u userDo) Take() (*entity.Api, error) { - if result, err := u.DO.Take(); err != nil { - return nil, err - } else { - return result.(*entity.Api), nil - } -} - -func (u userDo) Last() (*entity.Api, error) { - if result, err := u.DO.Last(); err != nil { - return nil, err - } else { - return result.(*entity.Api), nil - } -} - -func (u userDo) Find() ([]*entity.Api, error) { - result, err := u.DO.Find() - return result.([]*entity.Api), err -} - -func (u userDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Api, err error) { - buf := make([]*entity.Api, 0, batchSize) - err = u.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 (u userDo) FindInBatches(result *[]*entity.Api, batchSize int, fc func(tx gen.Dao, batch int) error) error { - return u.DO.FindInBatches(result, batchSize, fc) -} - -func (u userDo) Attrs(attrs ...field.AssignExpr) IUserDo { - return u.withDO(u.DO.Attrs(attrs...)) -} - -func (u userDo) Assign(attrs ...field.AssignExpr) IUserDo { - return u.withDO(u.DO.Assign(attrs...)) -} - -func (u userDo) Joins(fields ...field.RelationField) IUserDo { - for _, _f := range fields { - u = *u.withDO(u.DO.Joins(_f)) - } - return &u -} - -func (u userDo) Preload(fields ...field.RelationField) IUserDo { - for _, _f := range fields { - u = *u.withDO(u.DO.Preload(_f)) - } - return &u -} - -func (u userDo) FirstOrInit() (*entity.Api, error) { - if result, err := u.DO.FirstOrInit(); err != nil { - return nil, err - } else { - return result.(*entity.Api), nil - } -} - -func (u userDo) FirstOrCreate() (*entity.Api, error) { - if result, err := u.DO.FirstOrCreate(); err != nil { - return nil, err - } else { - return result.(*entity.Api), nil - } -} - -func (u userDo) FindByPage(offset int, limit int) (result []*entity.Api, count int64, err error) { - result, err = u.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 = u.Offset(-1).Limit(-1).Count() - return -} - -func (u userDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { - count, err = u.Count() - if err != nil { - return - } - - err = u.Offset(offset).Limit(limit).Scan(result) - return -} - -func (u userDo) Scan(result interface{}) (err error) { - return u.DO.Scan(result) -} - -func (u userDo) Delete(models ...*entity.Api) (result gen.ResultInfo, err error) { - return u.DO.Delete(models) -} - -func (u *userDo) withDO(do gen.Dao) *userDo { - u.DO = *do.(*gen.DO) - return u -} diff --git a/internal/entity/Order.go b/internal/entity/Order.go index 5b8a8e0..b687c7c 100644 --- a/internal/entity/Order.go +++ b/internal/entity/Order.go @@ -23,7 +23,7 @@ type OrderItem struct { OrderId schema.EntityId `json:"order_id"` PackageId schema.EntityId `json:"package_id"` Order *Order - Package *Package + Package *Packages } func (u *OrderItem) TableName() string { diff --git a/internal/entity/Package.go b/internal/entity/Package.go index 4437034..46f55d4 100644 --- a/internal/entity/Package.go +++ b/internal/entity/Package.go @@ -6,7 +6,8 @@ import ( "time" ) -type Package struct { +// Packages 其实不应该加 s，但是 gorm gen 生成的代码中，package 是关键字，所以只能加 s +type Packages struct { Model Name string `json:"name"` Description string `json:"description"` @@ -22,7 +23,7 @@ type Package struct { DeletedAt *gorm.DeletedAt `json:"deleted_at"` } -func (u *Package) TableName() string { +func (u *Packages) TableName() string { return "packages" } @@ -30,7 +31,7 @@ type UserPackage struct { Model UserId schema.UserId `json:"user_id"` PackageId schema.EntityId `json:"package_id"` - Package *Package `json:"api_package"` + Package *Packages `json:"api_package"` CallsLeft int64 `json:"calls_left"` IsActive bool `json:"is_active"` ExpirationAt *time.Time `json:"expiration_at"`