重构 orm 代码生成逻辑，实现 bill 接口，优化请求字段检查与 list total 查询逻辑

web/queries/bill.gen.go

@@ -39,6 +39,29 @@ func newBill(db *gorm.DB, opts ...gen.DOOption) bill {
 	_bill.BillNo = field.NewString(tableName, "bill_no")
 	_bill.RefundID = field.NewInt32(tableName, "refund_id")
 	_bill.Status = field.NewInt32(tableName, "status")
+	_bill.Amount = field.NewFloat64(tableName, "amount")
+	_bill.Trade = billBelongsToTrade{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Trade", "models.Trade"),
+	}
+
+	_bill.Refund = billBelongsToRefund{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Refund", "models.Refund"),
+	}
+
+	_bill.Resource = billBelongsToResource{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Resource", "models.Resource"),
+		Pss: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Resource.Pss", "models.ResourcePss"),
+		},
+	}
 
 	_bill.fillFieldMap()
 
@@ -61,6 +84,12 @@ type bill struct {
 	BillNo     field.String
 	RefundID   field.Int32
 	Status     field.Int32
+	Amount     field.Float64
+	Trade      billBelongsToTrade
+
+	Refund billBelongsToRefund
+
+	Resource billBelongsToResource
 
 	fieldMap map[string]field.Expr
 }
@@ -89,6 +118,7 @@ func (b *bill) updateTableName(table string) *bill {
 	b.BillNo = field.NewString(table, "bill_no")
 	b.RefundID = field.NewInt32(table, "refund_id")
 	b.Status = field.NewInt32(table, "status")
+	b.Amount = field.NewFloat64(table, "amount")
 
 	b.fillFieldMap()
 
@@ -105,7 +135,7 @@ func (b *bill) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (b *bill) fillFieldMap() {
-	b.fieldMap = make(map[string]field.Expr, 12)
+	b.fieldMap = make(map[string]field.Expr, 16)
 	b.fieldMap["id"] = b.ID
 	b.fieldMap["user_id"] = b.UserID
 	b.fieldMap["info"] = b.Info
@@ -118,6 +148,8 @@ func (b *bill) fillFieldMap() {
 	b.fieldMap["bill_no"] = b.BillNo
 	b.fieldMap["refund_id"] = b.RefundID
 	b.fieldMap["status"] = b.Status
+	b.fieldMap["amount"] = b.Amount
+
 }
 
 func (b bill) clone(db *gorm.DB) bill {
@@ -130,6 +162,223 @@ func (b bill) replaceDB(db *gorm.DB) bill {
 	return b
 }
 
+type billBelongsToTrade struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a billBelongsToTrade) Where(conds ...field.Expr) *billBelongsToTrade {
+	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 billBelongsToTrade) WithContext(ctx context.Context) *billBelongsToTrade {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a billBelongsToTrade) Session(session *gorm.Session) *billBelongsToTrade {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a billBelongsToTrade) Model(m *models.Bill) *billBelongsToTradeTx {
+	return &billBelongsToTradeTx{a.db.Model(m).Association(a.Name())}
+}
+
+type billBelongsToTradeTx struct{ tx *gorm.Association }
+
+func (a billBelongsToTradeTx) Find() (result *models.Trade, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a billBelongsToTradeTx) Append(values ...*models.Trade) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a billBelongsToTradeTx) Replace(values ...*models.Trade) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a billBelongsToTradeTx) Delete(values ...*models.Trade) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a billBelongsToTradeTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a billBelongsToTradeTx) Count() int64 {
+	return a.tx.Count()
+}
+
+type billBelongsToRefund struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a billBelongsToRefund) Where(conds ...field.Expr) *billBelongsToRefund {
+	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 billBelongsToRefund) WithContext(ctx context.Context) *billBelongsToRefund {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a billBelongsToRefund) Session(session *gorm.Session) *billBelongsToRefund {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a billBelongsToRefund) Model(m *models.Bill) *billBelongsToRefundTx {
+	return &billBelongsToRefundTx{a.db.Model(m).Association(a.Name())}
+}
+
+type billBelongsToRefundTx struct{ tx *gorm.Association }
+
+func (a billBelongsToRefundTx) Find() (result *models.Refund, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a billBelongsToRefundTx) Append(values ...*models.Refund) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a billBelongsToRefundTx) Replace(values ...*models.Refund) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a billBelongsToRefundTx) Delete(values ...*models.Refund) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a billBelongsToRefundTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a billBelongsToRefundTx) Count() int64 {
+	return a.tx.Count()
+}
+
+type billBelongsToResource struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Pss struct {
+		field.RelationField
+	}
+}
+
+func (a billBelongsToResource) Where(conds ...field.Expr) *billBelongsToResource {
+	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 billBelongsToResource) WithContext(ctx context.Context) *billBelongsToResource {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a billBelongsToResource) Session(session *gorm.Session) *billBelongsToResource {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a billBelongsToResource) Model(m *models.Bill) *billBelongsToResourceTx {
+	return &billBelongsToResourceTx{a.db.Model(m).Association(a.Name())}
+}
+
+type billBelongsToResourceTx struct{ tx *gorm.Association }
+
+func (a billBelongsToResourceTx) Find() (result *models.Resource, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a billBelongsToResourceTx) Append(values ...*models.Resource) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a billBelongsToResourceTx) Replace(values ...*models.Resource) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a billBelongsToResourceTx) Delete(values ...*models.Resource) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a billBelongsToResourceTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a billBelongsToResourceTx) Count() int64 {
+	return a.tx.Count()
+}
+
 type billDo struct{ gen.DO }
 
 func (b billDo) Debug() *billDo {

web/queries/resource.gen.go

@@ -33,6 +33,12 @@ func newResource(db *gorm.DB, opts ...gen.DOOption) resource {
 	_resource.CreatedAt = field.NewField(tableName, "created_at")
 	_resource.UpdatedAt = field.NewField(tableName, "updated_at")
 	_resource.DeletedAt = field.NewField(tableName, "deleted_at")
+	_resource.ResourceNo = field.NewString(tableName, "resource_no")
+	_resource.Pss = resourceHasOnePss{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Pss", "models.ResourcePss"),
+	}
 
 	_resource.fillFieldMap()
 
@@ -42,13 +48,15 @@ func newResource(db *gorm.DB, opts ...gen.DOOption) resource {
 type resource struct {
 	resourceDo
 
-	ALL       field.Asterisk
-	ID        field.Int32 // 套餐ID
-	UserID    field.Int32 // 用户ID
-	Active    field.Bool  // 套餐状态
-	CreatedAt field.Field // 创建时间
-	UpdatedAt field.Field // 更新时间
-	DeletedAt field.Field // 删除时间
+	ALL        field.Asterisk
+	ID         field.Int32 // 套餐ID
+	UserID     field.Int32 // 用户ID
+	Active     field.Bool  // 套餐状态
+	CreatedAt  field.Field // 创建时间
+	UpdatedAt  field.Field // 更新时间
+	DeletedAt  field.Field // 删除时间
+	ResourceNo field.String
+	Pss        resourceHasOnePss
 
 	fieldMap map[string]field.Expr
 }
@@ -71,6 +79,7 @@ func (r *resource) updateTableName(table string) *resource {
 	r.CreatedAt = field.NewField(table, "created_at")
 	r.UpdatedAt = field.NewField(table, "updated_at")
 	r.DeletedAt = field.NewField(table, "deleted_at")
+	r.ResourceNo = field.NewString(table, "resource_no")
 
 	r.fillFieldMap()
 
@@ -87,13 +96,15 @@ func (r *resource) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (r *resource) fillFieldMap() {
-	r.fieldMap = make(map[string]field.Expr, 6)
+	r.fieldMap = make(map[string]field.Expr, 8)
 	r.fieldMap["id"] = r.ID
 	r.fieldMap["user_id"] = r.UserID
 	r.fieldMap["active"] = r.Active
 	r.fieldMap["created_at"] = r.CreatedAt
 	r.fieldMap["updated_at"] = r.UpdatedAt
 	r.fieldMap["deleted_at"] = r.DeletedAt
+	r.fieldMap["resource_no"] = r.ResourceNo
+
 }
 
 func (r resource) clone(db *gorm.DB) resource {
@@ -106,6 +117,77 @@ func (r resource) replaceDB(db *gorm.DB) resource {
 	return r
 }
 
+type resourceHasOnePss struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a resourceHasOnePss) Where(conds ...field.Expr) *resourceHasOnePss {
+	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 resourceHasOnePss) WithContext(ctx context.Context) *resourceHasOnePss {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a resourceHasOnePss) Session(session *gorm.Session) *resourceHasOnePss {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a resourceHasOnePss) Model(m *models.Resource) *resourceHasOnePssTx {
+	return &resourceHasOnePssTx{a.db.Model(m).Association(a.Name())}
+}
+
+type resourceHasOnePssTx struct{ tx *gorm.Association }
+
+func (a resourceHasOnePssTx) Find() (result *models.ResourcePss, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a resourceHasOnePssTx) Append(values ...*models.ResourcePss) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a resourceHasOnePssTx) Replace(values ...*models.ResourcePss) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a resourceHasOnePssTx) Delete(values ...*models.ResourcePss) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a resourceHasOnePssTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a resourceHasOnePssTx) Count() int64 {
+	return a.tx.Count()
+}
+
 type resourceDo struct{ gen.DO }
 
 func (r resourceDo) Debug() *resourceDo {

web/queries/resource_pss.gen.go

@@ -32,11 +32,11 @@ func newResourcePss(db *gorm.DB, opts ...gen.DOOption) resourcePss {
 	_resourcePss.Type = field.NewInt32(tableName, "type")
 	_resourcePss.Live = field.NewInt32(tableName, "live")
 	_resourcePss.Quota = field.NewInt32(tableName, "quota")
-	_resourcePss.Expire = field.NewTime(tableName, "expire")
+	_resourcePss.Expire = field.NewField(tableName, "expire")
 	_resourcePss.Used = field.NewInt32(tableName, "used")
 	_resourcePss.DailyLimit = field.NewInt32(tableName, "daily_limit")
 	_resourcePss.DailyUsed = field.NewInt32(tableName, "daily_used")
-	_resourcePss.DailyLast = field.NewTime(tableName, "daily_last")
+	_resourcePss.DailyLast = field.NewField(tableName, "daily_last")
 	_resourcePss.CreatedAt = field.NewField(tableName, "created_at")
 	_resourcePss.UpdatedAt = field.NewField(tableName, "updated_at")
 	_resourcePss.DeletedAt = field.NewField(tableName, "deleted_at")
@@ -55,11 +55,11 @@ type resourcePss struct {
 	Type       field.Int32 // 套餐类型：1-包时，2-包量
 	Live       field.Int32 // 可用时长(秒)
 	Quota      field.Int32 // 配额数量
-	Expire     field.Time  // 过期时间
+	Expire     field.Field // 过期时间
 	Used       field.Int32 // 已用数量
 	DailyLimit field.Int32 // 每日限制
 	DailyUsed  field.Int32 // 今日已用数量
-	DailyLast  field.Time  // 今日最后使用时间
+	DailyLast  field.Field // 今日最后使用时间
 	CreatedAt  field.Field // 创建时间
 	UpdatedAt  field.Field // 更新时间
 	DeletedAt  field.Field // 删除时间
@@ -84,11 +84,11 @@ func (r *resourcePss) updateTableName(table string) *resourcePss {
 	r.Type = field.NewInt32(table, "type")
 	r.Live = field.NewInt32(table, "live")
 	r.Quota = field.NewInt32(table, "quota")
-	r.Expire = field.NewTime(table, "expire")
+	r.Expire = field.NewField(table, "expire")
 	r.Used = field.NewInt32(table, "used")
 	r.DailyLimit = field.NewInt32(table, "daily_limit")
 	r.DailyUsed = field.NewInt32(table, "daily_used")
-	r.DailyLast = field.NewTime(table, "daily_last")
+	r.DailyLast = field.NewField(table, "daily_last")
 	r.CreatedAt = field.NewField(table, "created_at")
 	r.UpdatedAt = field.NewField(table, "updated_at")
 	r.DeletedAt = field.NewField(table, "deleted_at")

web/queries/trade.gen.go

@@ -41,8 +41,8 @@ func newTrade(db *gorm.DB, opts ...gen.DOOption) trade {
 	_trade.UpdatedAt = field.NewField(tableName, "updated_at")
 	_trade.DeletedAt = field.NewField(tableName, "deleted_at")
 	_trade.Type = field.NewInt32(tableName, "type")
-	_trade.CancelAt = field.NewTime(tableName, "cancel_at")
-	_trade.PaidAt = field.NewTime(tableName, "paid_at")
+	_trade.CancelAt = field.NewField(tableName, "cancel_at")
+	_trade.PaidAt = field.NewField(tableName, "paid_at")
 
 	_trade.fillFieldMap()
 
@@ -67,8 +67,8 @@ type trade struct {
 	UpdatedAt field.Field   // 更新时间
 	DeletedAt field.Field   // 删除时间
 	Type      field.Int32
-	CancelAt  field.Time
-	PaidAt    field.Time
+	CancelAt  field.Field
+	PaidAt    field.Field
 
 	fieldMap map[string]field.Expr
 }
@@ -99,8 +99,8 @@ func (t *trade) updateTableName(table string) *trade {
 	t.UpdatedAt = field.NewField(table, "updated_at")
 	t.DeletedAt = field.NewField(table, "deleted_at")
 	t.Type = field.NewInt32(table, "type")
-	t.CancelAt = field.NewTime(table, "cancel_at")
-	t.PaidAt = field.NewTime(table, "paid_at")
+	t.CancelAt = field.NewField(table, "cancel_at")
+	t.PaidAt = field.NewField(table, "paid_at")
 
 	t.fillFieldMap()