完善定价与套餐关联表结构

web/queries/product_sku.gen.go

@@ -32,16 +32,22 @@ func newProductSku(db *gorm.DB, opts ...gen.DOOption) productSku {
 	_productSku.UpdatedAt = field.NewTime(tableName, "updated_at")
 	_productSku.DeletedAt = field.NewField(tableName, "deleted_at")
 	_productSku.ProductID = field.NewInt32(tableName, "product_id")
+	_productSku.DiscountId = field.NewInt32(tableName, "discount_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.Discount = productSkuBelongsToDiscount{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Discount", "models.ProductDiscount"),
+	}
+
 	_productSku.fillFieldMap()
 
 	return _productSku
@@ -50,17 +56,19 @@ func newProductSku(db *gorm.DB, opts ...gen.DOOption) 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
+	ALL        field.Asterisk
+	ID         field.Int32
+	CreatedAt  field.Time
+	UpdatedAt  field.Time
+	DeletedAt  field.Field
+	ProductID  field.Int32
+	DiscountId field.Int32
+	Code       field.String
+	Name       field.String
+	Price      field.Field
+	Product    productSkuBelongsToProduct
+
+	Discount productSkuBelongsToDiscount
 
 	fieldMap map[string]field.Expr
 }
@@ -82,10 +90,10 @@ func (p *productSku) updateTableName(table string) *productSku {
 	p.UpdatedAt = field.NewTime(table, "updated_at")
 	p.DeletedAt = field.NewField(table, "deleted_at")
 	p.ProductID = field.NewInt32(table, "product_id")
+	p.DiscountId = field.NewInt32(table, "discount_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()
 
@@ -102,16 +110,16 @@ func (p *productSku) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (p *productSku) fillFieldMap() {
-	p.fieldMap = make(map[string]field.Expr, 10)
+	p.fieldMap = make(map[string]field.Expr, 11)
 	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["discount_id"] = p.DiscountId
 	p.fieldMap["code"] = p.Code
 	p.fieldMap["name"] = p.Name
 	p.fieldMap["price"] = p.Price
-	p.fieldMap["discount"] = p.Discount
 
 }
 
@@ -119,12 +127,15 @@ 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
+	p.Discount.db = db.Session(&gorm.Session{Initialized: true})
+	p.Discount.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{})
+	p.Discount.db = db.Session(&gorm.Session{})
 	return p
 }
 
@@ -209,6 +220,87 @@ func (a productSkuBelongsToProductTx) Unscoped() *productSkuBelongsToProductTx {
 	return &a
 }
 
+type productSkuBelongsToDiscount struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a productSkuBelongsToDiscount) Where(conds ...field.Expr) *productSkuBelongsToDiscount {
+	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 productSkuBelongsToDiscount) WithContext(ctx context.Context) *productSkuBelongsToDiscount {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a productSkuBelongsToDiscount) Session(session *gorm.Session) *productSkuBelongsToDiscount {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a productSkuBelongsToDiscount) Model(m *models.ProductSku) *productSkuBelongsToDiscountTx {
+	return &productSkuBelongsToDiscountTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a productSkuBelongsToDiscount) Unscoped() *productSkuBelongsToDiscount {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type productSkuBelongsToDiscountTx struct{ tx *gorm.Association }
+
+func (a productSkuBelongsToDiscountTx) Find() (result *models.ProductDiscount, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a productSkuBelongsToDiscountTx) Append(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a productSkuBelongsToDiscountTx) Replace(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a productSkuBelongsToDiscountTx) Delete(values ...*models.ProductDiscount) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a productSkuBelongsToDiscountTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a productSkuBelongsToDiscountTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a productSkuBelongsToDiscountTx) Unscoped() *productSkuBelongsToDiscountTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type productSkuDo struct{ gen.DO }
 
 func (p productSkuDo) Debug() *productSkuDo {