支付功能动态化扩展

web/queries/gen.go

@@ -37,6 +37,8 @@ var (
 	LogsUserUsage           *logsUserUsage
 	Permission              *permission
 	Product                 *product
+	ProductSku              *productSku
+	ProductSkuUser          *productSkuUser
 	Proxy                   *proxy
 	Refund                  *refund
 	Resource                *resource
@@ -71,6 +73,8 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	LogsUserUsage = &Q.LogsUserUsage
 	Permission = &Q.Permission
 	Product = &Q.Product
+	ProductSku = &Q.ProductSku
+	ProductSkuUser = &Q.ProductSkuUser
 	Proxy = &Q.Proxy
 	Refund = &Q.Refund
 	Resource = &Q.Resource
@@ -106,6 +110,8 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 		LogsUserUsage:           newLogsUserUsage(db, opts...),
 		Permission:              newPermission(db, opts...),
 		Product:                 newProduct(db, opts...),
+		ProductSku:              newProductSku(db, opts...),
+		ProductSkuUser:          newProductSkuUser(db, opts...),
 		Proxy:                   newProxy(db, opts...),
 		Refund:                  newRefund(db, opts...),
 		Resource:                newResource(db, opts...),
@@ -142,6 +148,8 @@ type Query struct {
 	LogsUserUsage           logsUserUsage
 	Permission              permission
 	Product                 product
+	ProductSku              productSku
+	ProductSkuUser          productSkuUser
 	Proxy                   proxy
 	Refund                  refund
 	Resource                resource
@@ -179,6 +187,8 @@ func (q *Query) clone(db *gorm.DB) *Query {
 		LogsUserUsage:           q.LogsUserUsage.clone(db),
 		Permission:              q.Permission.clone(db),
 		Product:                 q.Product.clone(db),
+		ProductSku:              q.ProductSku.clone(db),
+		ProductSkuUser:          q.ProductSkuUser.clone(db),
 		Proxy:                   q.Proxy.clone(db),
 		Refund:                  q.Refund.clone(db),
 		Resource:                q.Resource.clone(db),
@@ -223,6 +233,8 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 		LogsUserUsage:           q.LogsUserUsage.replaceDB(db),
 		Permission:              q.Permission.replaceDB(db),
 		Product:                 q.Product.replaceDB(db),
+		ProductSku:              q.ProductSku.replaceDB(db),
+		ProductSkuUser:          q.ProductSkuUser.replaceDB(db),
 		Proxy:                   q.Proxy.replaceDB(db),
 		Refund:                  q.Refund.replaceDB(db),
 		Resource:                q.Resource.replaceDB(db),
@@ -257,6 +269,8 @@ type queryCtx struct {
 	LogsUserUsage           *logsUserUsageDo
 	Permission              *permissionDo
 	Product                 *productDo
+	ProductSku              *productSkuDo
+	ProductSkuUser          *productSkuUserDo
 	Proxy                   *proxyDo
 	Refund                  *refundDo
 	Resource                *resourceDo
@@ -291,6 +305,8 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx {
 		LogsUserUsage:           q.LogsUserUsage.WithContext(ctx),
 		Permission:              q.Permission.WithContext(ctx),
 		Product:                 q.Product.WithContext(ctx),
+		ProductSku:              q.ProductSku.WithContext(ctx),
+		ProductSkuUser:          q.ProductSkuUser.WithContext(ctx),
 		Proxy:                   q.Proxy.WithContext(ctx),
 		Refund:                  q.Refund.WithContext(ctx),
 		Resource:                q.Resource.WithContext(ctx),

web/queries/product_sku.gen.go

@@ -0,0 +1,442 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newProductSku(db *gorm.DB, opts ...gen.DOOption) productSku {
+	_productSku := productSku{}
+
+	_productSku.productSkuDo.UseDB(db, opts...)
+	_productSku.productSkuDo.UseModel(&models.ProductSku{})
+
+	tableName := _productSku.productSkuDo.TableName()
+	_productSku.ALL = field.NewAsterisk(tableName)
+	_productSku.ID = field.NewInt32(tableName, "id")
+	_productSku.CreatedAt = field.NewTime(tableName, "created_at")
+	_productSku.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_productSku.DeletedAt = field.NewField(tableName, "deleted_at")
+	_productSku.ProductID = field.NewInt32(tableName, "product_id")
+	_productSku.Code = field.NewString(tableName, "code")
+	_productSku.Name = field.NewString(tableName, "name")
+	_productSku.Price = field.NewField(tableName, "price")
+	_productSku.Discount = field.NewFloat32(tableName, "discount")
+	_productSku.Product = productSkuBelongsToProduct{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Product", "models.Product"),
+	}
+
+	_productSku.fillFieldMap()
+
+	return _productSku
+}
+
+type productSku struct {
+	productSkuDo
+
+	ALL       field.Asterisk
+	ID        field.Int32
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+	ProductID field.Int32
+	Code      field.String
+	Name      field.String
+	Price     field.Field
+	Discount  field.Float32
+	Product   productSkuBelongsToProduct
+
+	fieldMap map[string]field.Expr
+}
+
+func (p productSku) Table(newTableName string) *productSku {
+	p.productSkuDo.UseTable(newTableName)
+	return p.updateTableName(newTableName)
+}
+
+func (p productSku) As(alias string) *productSku {
+	p.productSkuDo.DO = *(p.productSkuDo.As(alias).(*gen.DO))
+	return p.updateTableName(alias)
+}
+
+func (p *productSku) updateTableName(table string) *productSku {
+	p.ALL = field.NewAsterisk(table)
+	p.ID = field.NewInt32(table, "id")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
+	p.DeletedAt = field.NewField(table, "deleted_at")
+	p.ProductID = field.NewInt32(table, "product_id")
+	p.Code = field.NewString(table, "code")
+	p.Name = field.NewString(table, "name")
+	p.Price = field.NewField(table, "price")
+	p.Discount = field.NewFloat32(table, "discount")
+
+	p.fillFieldMap()
+
+	return p
+}
+
+func (p *productSku) 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 *productSku) fillFieldMap() {
+	p.fieldMap = make(map[string]field.Expr, 10)
+	p.fieldMap["id"] = p.ID
+	p.fieldMap["created_at"] = p.CreatedAt
+	p.fieldMap["updated_at"] = p.UpdatedAt
+	p.fieldMap["deleted_at"] = p.DeletedAt
+	p.fieldMap["product_id"] = p.ProductID
+	p.fieldMap["code"] = p.Code
+	p.fieldMap["name"] = p.Name
+	p.fieldMap["price"] = p.Price
+	p.fieldMap["discount"] = p.Discount
+
+}
+
+func (p productSku) clone(db *gorm.DB) productSku {
+	p.productSkuDo.ReplaceConnPool(db.Statement.ConnPool)
+	p.Product.db = db.Session(&gorm.Session{Initialized: true})
+	p.Product.db.Statement.ConnPool = db.Statement.ConnPool
+	return p
+}
+
+func (p productSku) replaceDB(db *gorm.DB) productSku {
+	p.productSkuDo.ReplaceDB(db)
+	p.Product.db = db.Session(&gorm.Session{})
+	return p
+}
+
+type productSkuBelongsToProduct struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a productSkuBelongsToProduct) Where(conds ...field.Expr) *productSkuBelongsToProduct {
+	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 productSkuBelongsToProduct) WithContext(ctx context.Context) *productSkuBelongsToProduct {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuBelongsToProduct) Session(session *gorm.Session) *productSkuBelongsToProduct {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuBelongsToProduct) Model(m *models.ProductSku) *productSkuBelongsToProductTx {
+	return &productSkuBelongsToProductTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuBelongsToProduct) Unscoped() *productSkuBelongsToProduct {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuBelongsToProductTx struct{ tx *gorm.Association }
+
+func (a productSkuBelongsToProductTx) Find() (result *models.Product, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuBelongsToProductTx) Append(values ...*models.Product) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuBelongsToProductTx) Replace(values ...*models.Product) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuBelongsToProductTx) Delete(values ...*models.Product) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuBelongsToProductTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuBelongsToProductTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuBelongsToProductTx) Unscoped() *productSkuBelongsToProductTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type productSkuDo struct{ gen.DO }
+
+func (p productSkuDo) Debug() *productSkuDo {
+	return p.withDO(p.DO.Debug())
+}
+
+func (p productSkuDo) WithContext(ctx context.Context) *productSkuDo {
+	return p.withDO(p.DO.WithContext(ctx))
+}
+
+func (p productSkuDo) ReadDB() *productSkuDo {
+	return p.Clauses(dbresolver.Read)
+}
+
+func (p productSkuDo) WriteDB() *productSkuDo {
+	return p.Clauses(dbresolver.Write)
+}
+
+func (p productSkuDo) Session(config *gorm.Session) *productSkuDo {
+	return p.withDO(p.DO.Session(config))
+}
+
+func (p productSkuDo) Clauses(conds ...clause.Expression) *productSkuDo {
+	return p.withDO(p.DO.Clauses(conds...))
+}
+
+func (p productSkuDo) Returning(value interface{}, columns ...string) *productSkuDo {
+	return p.withDO(p.DO.Returning(value, columns...))
+}
+
+func (p productSkuDo) Not(conds ...gen.Condition) *productSkuDo {
+	return p.withDO(p.DO.Not(conds...))
+}
+
+func (p productSkuDo) Or(conds ...gen.Condition) *productSkuDo {
+	return p.withDO(p.DO.Or(conds...))
+}
+
+func (p productSkuDo) Select(conds ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Select(conds...))
+}
+
+func (p productSkuDo) Where(conds ...gen.Condition) *productSkuDo {
+	return p.withDO(p.DO.Where(conds...))
+}
+
+func (p productSkuDo) Order(conds ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Order(conds...))
+}
+
+func (p productSkuDo) Distinct(cols ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Distinct(cols...))
+}
+
+func (p productSkuDo) Omit(cols ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Omit(cols...))
+}
+
+func (p productSkuDo) Join(table schema.Tabler, on ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Join(table, on...))
+}
+
+func (p productSkuDo) LeftJoin(table schema.Tabler, on ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.LeftJoin(table, on...))
+}
+
+func (p productSkuDo) RightJoin(table schema.Tabler, on ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.RightJoin(table, on...))
+}
+
+func (p productSkuDo) Group(cols ...field.Expr) *productSkuDo {
+	return p.withDO(p.DO.Group(cols...))
+}
+
+func (p productSkuDo) Having(conds ...gen.Condition) *productSkuDo {
+	return p.withDO(p.DO.Having(conds...))
+}
+
+func (p productSkuDo) Limit(limit int) *productSkuDo {
+	return p.withDO(p.DO.Limit(limit))
+}
+
+func (p productSkuDo) Offset(offset int) *productSkuDo {
+	return p.withDO(p.DO.Offset(offset))
+}
+
+func (p productSkuDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *productSkuDo {
+	return p.withDO(p.DO.Scopes(funcs...))
+}
+
+func (p productSkuDo) Unscoped() *productSkuDo {
+	return p.withDO(p.DO.Unscoped())
+}
+
+func (p productSkuDo) Create(values ...*models.ProductSku) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Create(values)
+}
+
+func (p productSkuDo) CreateInBatches(values []*models.ProductSku, 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 productSkuDo) Save(values ...*models.ProductSku) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Save(values)
+}
+
+func (p productSkuDo) First() (*models.ProductSku, error) {
+	if result, err := p.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) Take() (*models.ProductSku, error) {
+	if result, err := p.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) Last() (*models.ProductSku, error) {
+	if result, err := p.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) Find() ([]*models.ProductSku, error) {
+	result, err := p.DO.Find()
+	return result.([]*models.ProductSku), err
+}
+
+func (p productSkuDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.ProductSku, err error) {
+	buf := make([]*models.ProductSku, 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 productSkuDo) FindInBatches(result *[]*models.ProductSku, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return p.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (p productSkuDo) Attrs(attrs ...field.AssignExpr) *productSkuDo {
+	return p.withDO(p.DO.Attrs(attrs...))
+}
+
+func (p productSkuDo) Assign(attrs ...field.AssignExpr) *productSkuDo {
+	return p.withDO(p.DO.Assign(attrs...))
+}
+
+func (p productSkuDo) Joins(fields ...field.RelationField) *productSkuDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Joins(_f))
+	}
+	return &p
+}
+
+func (p productSkuDo) Preload(fields ...field.RelationField) *productSkuDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Preload(_f))
+	}
+	return &p
+}
+
+func (p productSkuDo) FirstOrInit() (*models.ProductSku, error) {
+	if result, err := p.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) FirstOrCreate() (*models.ProductSku, error) {
+	if result, err := p.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSku), nil
+	}
+}
+
+func (p productSkuDo) FindByPage(offset int, limit int) (result []*models.ProductSku, 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 productSkuDo) 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 productSkuDo) Scan(result interface{}) (err error) {
+	return p.DO.Scan(result)
+}
+
+func (p productSkuDo) Delete(models ...*models.ProductSku) (result gen.ResultInfo, err error) {
+	return p.DO.Delete(models)
+}
+
+func (p *productSkuDo) withDO(do gen.Dao) *productSkuDo {
+	p.DO = *do.(*gen.DO)
+	return p
+}

web/queries/product_sku_user.gen.go

@@ -0,0 +1,544 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newProductSkuUser(db *gorm.DB, opts ...gen.DOOption) productSkuUser {
+	_productSkuUser := productSkuUser{}
+
+	_productSkuUser.productSkuUserDo.UseDB(db, opts...)
+	_productSkuUser.productSkuUserDo.UseModel(&models.ProductSkuUser{})
+
+	tableName := _productSkuUser.productSkuUserDo.TableName()
+	_productSkuUser.ALL = field.NewAsterisk(tableName)
+	_productSkuUser.ID = field.NewInt32(tableName, "id")
+	_productSkuUser.UserID = field.NewInt32(tableName, "user_id")
+	_productSkuUser.ProductSkuID = field.NewInt32(tableName, "product_sku_id")
+	_productSkuUser.Price = field.NewField(tableName, "price")
+	_productSkuUser.Discount = field.NewFloat32(tableName, "discount")
+	_productSkuUser.CreatedAt = field.NewTime(tableName, "created_at")
+	_productSkuUser.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_productSkuUser.User = productSkuUserBelongsToUser{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("User", "models.User"),
+		Admin: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("User.Admin", "models.Admin"),
+		},
+	}
+
+	_productSkuUser.ProductSku = productSkuUserBelongsToProductSku{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("ProductSku", "models.ProductSku"),
+		Product: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("ProductSku.Product", "models.Product"),
+		},
+	}
+
+	_productSkuUser.fillFieldMap()
+
+	return _productSkuUser
+}
+
+type productSkuUser struct {
+	productSkuUserDo
+
+	ALL          field.Asterisk
+	ID           field.Int32
+	UserID       field.Int32
+	ProductSkuID field.Int32
+	Price        field.Field
+	Discount     field.Float32
+	CreatedAt    field.Time
+	UpdatedAt    field.Time
+	User         productSkuUserBelongsToUser
+
+	ProductSku productSkuUserBelongsToProductSku
+
+	fieldMap map[string]field.Expr
+}
+
+func (p productSkuUser) Table(newTableName string) *productSkuUser {
+	p.productSkuUserDo.UseTable(newTableName)
+	return p.updateTableName(newTableName)
+}
+
+func (p productSkuUser) As(alias string) *productSkuUser {
+	p.productSkuUserDo.DO = *(p.productSkuUserDo.As(alias).(*gen.DO))
+	return p.updateTableName(alias)
+}
+
+func (p *productSkuUser) updateTableName(table string) *productSkuUser {
+	p.ALL = field.NewAsterisk(table)
+	p.ID = field.NewInt32(table, "id")
+	p.UserID = field.NewInt32(table, "user_id")
+	p.ProductSkuID = field.NewInt32(table, "product_sku_id")
+	p.Price = field.NewField(table, "price")
+	p.Discount = field.NewFloat32(table, "discount")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
+
+	p.fillFieldMap()
+
+	return p
+}
+
+func (p *productSkuUser) 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 *productSkuUser) fillFieldMap() {
+	p.fieldMap = make(map[string]field.Expr, 9)
+	p.fieldMap["id"] = p.ID
+	p.fieldMap["user_id"] = p.UserID
+	p.fieldMap["product_sku_id"] = p.ProductSkuID
+	p.fieldMap["price"] = p.Price
+	p.fieldMap["discount"] = p.Discount
+	p.fieldMap["created_at"] = p.CreatedAt
+	p.fieldMap["updated_at"] = p.UpdatedAt
+
+}
+
+func (p productSkuUser) clone(db *gorm.DB) productSkuUser {
+	p.productSkuUserDo.ReplaceConnPool(db.Statement.ConnPool)
+	p.User.db = db.Session(&gorm.Session{Initialized: true})
+	p.User.db.Statement.ConnPool = db.Statement.ConnPool
+	p.ProductSku.db = db.Session(&gorm.Session{Initialized: true})
+	p.ProductSku.db.Statement.ConnPool = db.Statement.ConnPool
+	return p
+}
+
+func (p productSkuUser) replaceDB(db *gorm.DB) productSkuUser {
+	p.productSkuUserDo.ReplaceDB(db)
+	p.User.db = db.Session(&gorm.Session{})
+	p.ProductSku.db = db.Session(&gorm.Session{})
+	return p
+}
+
+type productSkuUserBelongsToUser struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Admin struct {
+		field.RelationField
+	}
+}
+
+func (a productSkuUserBelongsToUser) Where(conds ...field.Expr) *productSkuUserBelongsToUser {
+	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 productSkuUserBelongsToUser) WithContext(ctx context.Context) *productSkuUserBelongsToUser {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuUserBelongsToUser) Session(session *gorm.Session) *productSkuUserBelongsToUser {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuUserBelongsToUser) Model(m *models.ProductSkuUser) *productSkuUserBelongsToUserTx {
+	return &productSkuUserBelongsToUserTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuUserBelongsToUser) Unscoped() *productSkuUserBelongsToUser {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuUserBelongsToUserTx struct{ tx *gorm.Association }
+
+func (a productSkuUserBelongsToUserTx) Find() (result *models.User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuUserBelongsToUserTx) Append(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuUserBelongsToUserTx) Replace(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuUserBelongsToUserTx) Delete(values ...*models.User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuUserBelongsToUserTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuUserBelongsToUserTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuUserBelongsToUserTx) Unscoped() *productSkuUserBelongsToUserTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type productSkuUserBelongsToProductSku struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Product struct {
+		field.RelationField
+	}
+}
+
+func (a productSkuUserBelongsToProductSku) Where(conds ...field.Expr) *productSkuUserBelongsToProductSku {
+	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 productSkuUserBelongsToProductSku) WithContext(ctx context.Context) *productSkuUserBelongsToProductSku {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuUserBelongsToProductSku) Session(session *gorm.Session) *productSkuUserBelongsToProductSku {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuUserBelongsToProductSku) Model(m *models.ProductSkuUser) *productSkuUserBelongsToProductSkuTx {
+	return &productSkuUserBelongsToProductSkuTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuUserBelongsToProductSku) Unscoped() *productSkuUserBelongsToProductSku {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuUserBelongsToProductSkuTx struct{ tx *gorm.Association }
+
+func (a productSkuUserBelongsToProductSkuTx) Find() (result *models.ProductSku, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Append(values ...*models.ProductSku) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Replace(values ...*models.ProductSku) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Delete(values ...*models.ProductSku) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuUserBelongsToProductSkuTx) Unscoped() *productSkuUserBelongsToProductSkuTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type productSkuUserDo struct{ gen.DO }
+
+func (p productSkuUserDo) Debug() *productSkuUserDo {
+	return p.withDO(p.DO.Debug())
+}
+
+func (p productSkuUserDo) WithContext(ctx context.Context) *productSkuUserDo {
+	return p.withDO(p.DO.WithContext(ctx))
+}
+
+func (p productSkuUserDo) ReadDB() *productSkuUserDo {
+	return p.Clauses(dbresolver.Read)
+}
+
+func (p productSkuUserDo) WriteDB() *productSkuUserDo {
+	return p.Clauses(dbresolver.Write)
+}
+
+func (p productSkuUserDo) Session(config *gorm.Session) *productSkuUserDo {
+	return p.withDO(p.DO.Session(config))
+}
+
+func (p productSkuUserDo) Clauses(conds ...clause.Expression) *productSkuUserDo {
+	return p.withDO(p.DO.Clauses(conds...))
+}
+
+func (p productSkuUserDo) Returning(value interface{}, columns ...string) *productSkuUserDo {
+	return p.withDO(p.DO.Returning(value, columns...))
+}
+
+func (p productSkuUserDo) Not(conds ...gen.Condition) *productSkuUserDo {
+	return p.withDO(p.DO.Not(conds...))
+}
+
+func (p productSkuUserDo) Or(conds ...gen.Condition) *productSkuUserDo {
+	return p.withDO(p.DO.Or(conds...))
+}
+
+func (p productSkuUserDo) Select(conds ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Select(conds...))
+}
+
+func (p productSkuUserDo) Where(conds ...gen.Condition) *productSkuUserDo {
+	return p.withDO(p.DO.Where(conds...))
+}
+
+func (p productSkuUserDo) Order(conds ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Order(conds...))
+}
+
+func (p productSkuUserDo) Distinct(cols ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Distinct(cols...))
+}
+
+func (p productSkuUserDo) Omit(cols ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Omit(cols...))
+}
+
+func (p productSkuUserDo) Join(table schema.Tabler, on ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Join(table, on...))
+}
+
+func (p productSkuUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.LeftJoin(table, on...))
+}
+
+func (p productSkuUserDo) RightJoin(table schema.Tabler, on ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.RightJoin(table, on...))
+}
+
+func (p productSkuUserDo) Group(cols ...field.Expr) *productSkuUserDo {
+	return p.withDO(p.DO.Group(cols...))
+}
+
+func (p productSkuUserDo) Having(conds ...gen.Condition) *productSkuUserDo {
+	return p.withDO(p.DO.Having(conds...))
+}
+
+func (p productSkuUserDo) Limit(limit int) *productSkuUserDo {
+	return p.withDO(p.DO.Limit(limit))
+}
+
+func (p productSkuUserDo) Offset(offset int) *productSkuUserDo {
+	return p.withDO(p.DO.Offset(offset))
+}
+
+func (p productSkuUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *productSkuUserDo {
+	return p.withDO(p.DO.Scopes(funcs...))
+}
+
+func (p productSkuUserDo) Unscoped() *productSkuUserDo {
+	return p.withDO(p.DO.Unscoped())
+}
+
+func (p productSkuUserDo) Create(values ...*models.ProductSkuUser) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Create(values)
+}
+
+func (p productSkuUserDo) CreateInBatches(values []*models.ProductSkuUser, 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 productSkuUserDo) Save(values ...*models.ProductSkuUser) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Save(values)
+}
+
+func (p productSkuUserDo) First() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) Take() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) Last() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) Find() ([]*models.ProductSkuUser, error) {
+	result, err := p.DO.Find()
+	return result.([]*models.ProductSkuUser), err
+}
+
+func (p productSkuUserDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.ProductSkuUser, err error) {
+	buf := make([]*models.ProductSkuUser, 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 productSkuUserDo) FindInBatches(result *[]*models.ProductSkuUser, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return p.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (p productSkuUserDo) Attrs(attrs ...field.AssignExpr) *productSkuUserDo {
+	return p.withDO(p.DO.Attrs(attrs...))
+}
+
+func (p productSkuUserDo) Assign(attrs ...field.AssignExpr) *productSkuUserDo {
+	return p.withDO(p.DO.Assign(attrs...))
+}
+
+func (p productSkuUserDo) Joins(fields ...field.RelationField) *productSkuUserDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Joins(_f))
+	}
+	return &p
+}
+
+func (p productSkuUserDo) Preload(fields ...field.RelationField) *productSkuUserDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Preload(_f))
+	}
+	return &p
+}
+
+func (p productSkuUserDo) FirstOrInit() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) FirstOrCreate() (*models.ProductSkuUser, error) {
+	if result, err := p.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.ProductSkuUser), nil
+	}
+}
+
+func (p productSkuUserDo) FindByPage(offset int, limit int) (result []*models.ProductSkuUser, 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 productSkuUserDo) 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 productSkuUserDo) Scan(result interface{}) (err error) {
+	return p.DO.Scan(result)
+}
+
+func (p productSkuUserDo) Delete(models ...*models.ProductSkuUser) (result gen.ResultInfo, err error) {
+	return p.DO.Delete(models)
+}
+
+func (p *productSkuUserDo) withDO(do gen.Dao) *productSkuUserDo {
+	p.DO = *do.(*gen.DO)
+	return p
+}