Refactor order and tenant ledger models to use consts for Currency and Type fields; add new UserStatus values; implement comprehensive test cases for content, creator, order, super, and wallet services.

backend/database/models/comments.gen.go

@@ -26,6 +26,7 @@ type Comment struct {
 	CreatedAt time.Time      `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
 	UpdatedAt time.Time      `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
 	DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp with time zone" json:"deleted_at"`
+	User      *User          `gorm:"foreignKey:UserID;references:ID" json:"user,omitempty"`
 }
 
 // Quick operations without importing query package

backend/database/models/comments.query.gen.go

@@ -35,6 +35,11 @@ func newComment(db *gorm.DB, opts ...gen.DOOption) commentQuery {
 	_commentQuery.CreatedAt = field.NewTime(tableName, "created_at")
 	_commentQuery.UpdatedAt = field.NewTime(tableName, "updated_at")
 	_commentQuery.DeletedAt = field.NewField(tableName, "deleted_at")
+	_commentQuery.User = commentQueryBelongsToUser{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("User", "User"),
+	}
 
 	_commentQuery.fillFieldMap()
 
@@ -55,6 +60,7 @@ type commentQuery struct {
 	CreatedAt field.Time
 	UpdatedAt field.Time
 	DeletedAt field.Field
+	User      commentQueryBelongsToUser
 
 	fieldMap map[string]field.Expr
 }
@@ -113,7 +119,7 @@ func (c *commentQuery) GetFieldByName(fieldName string) (field.OrderExpr, bool)
 }
 
 func (c *commentQuery) fillFieldMap() {
-	c.fieldMap = make(map[string]field.Expr, 10)
+	c.fieldMap = make(map[string]field.Expr, 11)
 	c.fieldMap["id"] = c.ID
 	c.fieldMap["tenant_id"] = c.TenantID
 	c.fieldMap["user_id"] = c.UserID
@@ -124,18 +130,103 @@ func (c *commentQuery) fillFieldMap() {
 	c.fieldMap["created_at"] = c.CreatedAt
 	c.fieldMap["updated_at"] = c.UpdatedAt
 	c.fieldMap["deleted_at"] = c.DeletedAt
+
 }
 
 func (c commentQuery) clone(db *gorm.DB) commentQuery {
 	c.commentQueryDo.ReplaceConnPool(db.Statement.ConnPool)
+	c.User.db = db.Session(&gorm.Session{Initialized: true})
+	c.User.db.Statement.ConnPool = db.Statement.ConnPool
 	return c
 }
 
 func (c commentQuery) replaceDB(db *gorm.DB) commentQuery {
 	c.commentQueryDo.ReplaceDB(db)
+	c.User.db = db.Session(&gorm.Session{})
 	return c
 }
 
+type commentQueryBelongsToUser struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a commentQueryBelongsToUser) Where(conds ...field.Expr) *commentQueryBelongsToUser {
+	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 commentQueryBelongsToUser) WithContext(ctx context.Context) *commentQueryBelongsToUser {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a commentQueryBelongsToUser) Session(session *gorm.Session) *commentQueryBelongsToUser {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a commentQueryBelongsToUser) Model(m *Comment) *commentQueryBelongsToUserTx {
+	return &commentQueryBelongsToUserTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a commentQueryBelongsToUser) Unscoped() *commentQueryBelongsToUser {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type commentQueryBelongsToUserTx struct{ tx *gorm.Association }
+
+func (a commentQueryBelongsToUserTx) Find() (result *User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a commentQueryBelongsToUserTx) Append(values ...*User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a commentQueryBelongsToUserTx) Replace(values ...*User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a commentQueryBelongsToUserTx) Delete(values ...*User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a commentQueryBelongsToUserTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a commentQueryBelongsToUserTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a commentQueryBelongsToUserTx) Unscoped() *commentQueryBelongsToUserTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type commentQueryDo struct{ gen.DO }
 
 func (c commentQueryDo) Debug() *commentQueryDo {

backend/database/models/content_access.gen.go

@@ -8,6 +8,8 @@ import (
 	"context"
 	"time"
 
+	"quyun/v2/pkg/consts"
+
 	"go.ipao.vip/gen"
 )
 
@@ -15,15 +17,15 @@ const TableNameContentAccess = "content_access"
 
 // ContentAccess mapped from table <content_access>
 type ContentAccess struct {
-	ID        int64     `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"`
-	TenantID  int64     `gorm:"column:tenant_id;type:bigint;not null" json:"tenant_id"`
-	UserID    int64     `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
-	ContentID int64     `gorm:"column:content_id;type:bigint;not null" json:"content_id"`
-	OrderID   int64     `gorm:"column:order_id;type:bigint" json:"order_id"`
-	Status    string    `gorm:"column:status;type:character varying(16);default:active" json:"status"`
-	RevokedAt time.Time `gorm:"column:revoked_at;type:timestamp with time zone" json:"revoked_at"`
-	CreatedAt time.Time `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
-	UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
+	ID        int64                      `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"`
+	TenantID  int64                      `gorm:"column:tenant_id;type:bigint;not null" json:"tenant_id"`
+	UserID    int64                      `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
+	ContentID int64                      `gorm:"column:content_id;type:bigint;not null" json:"content_id"`
+	OrderID   int64                      `gorm:"column:order_id;type:bigint" json:"order_id"`
+	Status    consts.ContentAccessStatus `gorm:"column:status;type:character varying(16);default:active" json:"status"`
+	RevokedAt time.Time                  `gorm:"column:revoked_at;type:timestamp with time zone" json:"revoked_at"`
+	CreatedAt time.Time                  `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
+	UpdatedAt time.Time                  `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
 }
 
 // Quick operations without importing query package

backend/database/models/content_access.query.gen.go

@@ -30,7 +30,7 @@ func newContentAccess(db *gorm.DB, opts ...gen.DOOption) contentAccessQuery {
 	_contentAccessQuery.UserID = field.NewInt64(tableName, "user_id")
 	_contentAccessQuery.ContentID = field.NewInt64(tableName, "content_id")
 	_contentAccessQuery.OrderID = field.NewInt64(tableName, "order_id")
-	_contentAccessQuery.Status = field.NewString(tableName, "status")
+	_contentAccessQuery.Status = field.NewField(tableName, "status")
 	_contentAccessQuery.RevokedAt = field.NewTime(tableName, "revoked_at")
 	_contentAccessQuery.CreatedAt = field.NewTime(tableName, "created_at")
 	_contentAccessQuery.UpdatedAt = field.NewTime(tableName, "updated_at")
@@ -49,7 +49,7 @@ type contentAccessQuery struct {
 	UserID    field.Int64
 	ContentID field.Int64
 	OrderID   field.Int64
-	Status    field.String
+	Status    field.Field
 	RevokedAt field.Time
 	CreatedAt field.Time
 	UpdatedAt field.Time
@@ -74,7 +74,7 @@ func (c *contentAccessQuery) updateTableName(table string) *contentAccessQuery {
 	c.UserID = field.NewInt64(table, "user_id")
 	c.ContentID = field.NewInt64(table, "content_id")
 	c.OrderID = field.NewInt64(table, "order_id")
-	c.Status = field.NewString(table, "status")
+	c.Status = field.NewField(table, "status")
 	c.RevokedAt = field.NewTime(table, "revoked_at")
 	c.CreatedAt = field.NewTime(table, "created_at")
 	c.UpdatedAt = field.NewTime(table, "updated_at")

backend/database/models/content_assets.gen.go

@@ -8,6 +8,8 @@ import (
 	"context"
 	"time"
 
+	"quyun/v2/pkg/consts"
+
 	"go.ipao.vip/gen"
 )
 
@@ -15,15 +17,16 @@ const TableNameContentAsset = "content_assets"
 
 // ContentAsset mapped from table <content_assets>
 type ContentAsset struct {
-	ID        int64     `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"`
-	TenantID  int64     `gorm:"column:tenant_id;type:bigint;not null" json:"tenant_id"`
-	UserID    int64     `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
-	ContentID int64     `gorm:"column:content_id;type:bigint;not null" json:"content_id"`
-	AssetID   int64     `gorm:"column:asset_id;type:bigint;not null" json:"asset_id"`
-	Role      string    `gorm:"column:role;type:character varying(32);default:main" json:"role"`
-	Sort      int32     `gorm:"column:sort;type:integer" json:"sort"`
-	CreatedAt time.Time `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
-	UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
+	ID        int64                   `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"`
+	TenantID  int64                   `gorm:"column:tenant_id;type:bigint;not null" json:"tenant_id"`
+	UserID    int64                   `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
+	ContentID int64                   `gorm:"column:content_id;type:bigint;not null" json:"content_id"`
+	AssetID   int64                   `gorm:"column:asset_id;type:bigint;not null" json:"asset_id"`
+	Role      consts.ContentAssetRole `gorm:"column:role;type:character varying(32);default:main" json:"role"`
+	Sort      int32                   `gorm:"column:sort;type:integer" json:"sort"`
+	CreatedAt time.Time               `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
+	UpdatedAt time.Time               `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
+	Asset     *MediaAsset             `gorm:"foreignKey:AssetID;references:ID" json:"asset,omitempty"`
 }
 
 // Quick operations without importing query package

backend/database/models/content_assets.query.gen.go

@@ -30,10 +30,15 @@ func newContentAsset(db *gorm.DB, opts ...gen.DOOption) contentAssetQuery {
 	_contentAssetQuery.UserID = field.NewInt64(tableName, "user_id")
 	_contentAssetQuery.ContentID = field.NewInt64(tableName, "content_id")
 	_contentAssetQuery.AssetID = field.NewInt64(tableName, "asset_id")
-	_contentAssetQuery.Role = field.NewString(tableName, "role")
+	_contentAssetQuery.Role = field.NewField(tableName, "role")
 	_contentAssetQuery.Sort = field.NewInt32(tableName, "sort")
 	_contentAssetQuery.CreatedAt = field.NewTime(tableName, "created_at")
 	_contentAssetQuery.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_contentAssetQuery.Asset = contentAssetQueryBelongsToAsset{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Asset", "MediaAsset"),
+	}
 
 	_contentAssetQuery.fillFieldMap()
 
@@ -49,10 +54,11 @@ type contentAssetQuery struct {
 	UserID    field.Int64
 	ContentID field.Int64
 	AssetID   field.Int64
-	Role      field.String
+	Role      field.Field
 	Sort      field.Int32
 	CreatedAt field.Time
 	UpdatedAt field.Time
+	Asset     contentAssetQueryBelongsToAsset
 
 	fieldMap map[string]field.Expr
 }
@@ -74,7 +80,7 @@ func (c *contentAssetQuery) updateTableName(table string) *contentAssetQuery {
 	c.UserID = field.NewInt64(table, "user_id")
 	c.ContentID = field.NewInt64(table, "content_id")
 	c.AssetID = field.NewInt64(table, "asset_id")
-	c.Role = field.NewString(table, "role")
+	c.Role = field.NewField(table, "role")
 	c.Sort = field.NewInt32(table, "sort")
 	c.CreatedAt = field.NewTime(table, "created_at")
 	c.UpdatedAt = field.NewTime(table, "updated_at")
@@ -110,7 +116,7 @@ func (c *contentAssetQuery) GetFieldByName(fieldName string) (field.OrderExpr, b
 }
 
 func (c *contentAssetQuery) fillFieldMap() {
-	c.fieldMap = make(map[string]field.Expr, 9)
+	c.fieldMap = make(map[string]field.Expr, 10)
 	c.fieldMap["id"] = c.ID
 	c.fieldMap["tenant_id"] = c.TenantID
 	c.fieldMap["user_id"] = c.UserID
@@ -120,18 +126,103 @@ func (c *contentAssetQuery) fillFieldMap() {
 	c.fieldMap["sort"] = c.Sort
 	c.fieldMap["created_at"] = c.CreatedAt
 	c.fieldMap["updated_at"] = c.UpdatedAt
+
 }
 
 func (c contentAssetQuery) clone(db *gorm.DB) contentAssetQuery {
 	c.contentAssetQueryDo.ReplaceConnPool(db.Statement.ConnPool)
+	c.Asset.db = db.Session(&gorm.Session{Initialized: true})
+	c.Asset.db.Statement.ConnPool = db.Statement.ConnPool
 	return c
 }
 
 func (c contentAssetQuery) replaceDB(db *gorm.DB) contentAssetQuery {
 	c.contentAssetQueryDo.ReplaceDB(db)
+	c.Asset.db = db.Session(&gorm.Session{})
 	return c
 }
 
+type contentAssetQueryBelongsToAsset struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a contentAssetQueryBelongsToAsset) Where(conds ...field.Expr) *contentAssetQueryBelongsToAsset {
+	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 contentAssetQueryBelongsToAsset) WithContext(ctx context.Context) *contentAssetQueryBelongsToAsset {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a contentAssetQueryBelongsToAsset) Session(session *gorm.Session) *contentAssetQueryBelongsToAsset {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a contentAssetQueryBelongsToAsset) Model(m *ContentAsset) *contentAssetQueryBelongsToAssetTx {
+	return &contentAssetQueryBelongsToAssetTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a contentAssetQueryBelongsToAsset) Unscoped() *contentAssetQueryBelongsToAsset {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type contentAssetQueryBelongsToAssetTx struct{ tx *gorm.Association }
+
+func (a contentAssetQueryBelongsToAssetTx) Find() (result *MediaAsset, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a contentAssetQueryBelongsToAssetTx) Append(values ...*MediaAsset) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a contentAssetQueryBelongsToAssetTx) Replace(values ...*MediaAsset) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a contentAssetQueryBelongsToAssetTx) Delete(values ...*MediaAsset) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a contentAssetQueryBelongsToAssetTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a contentAssetQueryBelongsToAssetTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a contentAssetQueryBelongsToAssetTx) Unscoped() *contentAssetQueryBelongsToAssetTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type contentAssetQueryDo struct{ gen.DO }
 
 func (c contentAssetQueryDo) Debug() *contentAssetQueryDo {

backend/database/models/contents.gen.go

@@ -38,6 +38,9 @@ type Content struct {
 	CreatedAt           time.Time                `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
 	UpdatedAt           time.Time                `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
 	DeletedAt           gorm.DeletedAt           `gorm:"column:deleted_at;type:timestamp with time zone" json:"deleted_at"`
+	Author              *User                    `gorm:"foreignKey:UserID;references:ID" json:"author,omitempty"`
+	ContentAssets       []*ContentAsset          `gorm:"foreignKey:ContentID;references:ID" json:"content_assets,omitempty"`
+	Comments            []*Comment               `gorm:"foreignKey:ContentID;references:ID" json:"comments,omitempty"`
 }
 
 // Quick operations without importing query package

backend/database/models/contents.query.gen.go

@@ -44,6 +44,23 @@ func newContent(db *gorm.DB, opts ...gen.DOOption) contentQuery {
 	_contentQuery.CreatedAt = field.NewTime(tableName, "created_at")
 	_contentQuery.UpdatedAt = field.NewTime(tableName, "updated_at")
 	_contentQuery.DeletedAt = field.NewField(tableName, "deleted_at")
+	_contentQuery.Author = contentQueryBelongsToAuthor{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Author", "User"),
+	}
+
+	_contentQuery.ContentAssets = contentQueryHasManyContentAssets{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("ContentAssets", "ContentAsset"),
+	}
+
+	_contentQuery.Comments = contentQueryHasManyComments{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Comments", "Comment"),
+	}
 
 	_contentQuery.fillFieldMap()
 
@@ -73,6 +90,11 @@ type contentQuery struct {
 	CreatedAt           field.Time
 	UpdatedAt           field.Time
 	DeletedAt           field.Field
+	Author              contentQueryBelongsToAuthor
+
+	ContentAssets contentQueryHasManyContentAssets
+
+	Comments contentQueryHasManyComments
 
 	fieldMap map[string]field.Expr
 }
@@ -140,7 +162,7 @@ func (c *contentQuery) GetFieldByName(fieldName string) (field.OrderExpr, bool)
 }
 
 func (c *contentQuery) fillFieldMap() {
-	c.fieldMap = make(map[string]field.Expr, 19)
+	c.fieldMap = make(map[string]field.Expr, 22)
 	c.fieldMap["id"] = c.ID
 	c.fieldMap["tenant_id"] = c.TenantID
 	c.fieldMap["user_id"] = c.UserID
@@ -160,18 +182,271 @@ func (c *contentQuery) fillFieldMap() {
 	c.fieldMap["created_at"] = c.CreatedAt
 	c.fieldMap["updated_at"] = c.UpdatedAt
 	c.fieldMap["deleted_at"] = c.DeletedAt
+
 }
 
 func (c contentQuery) clone(db *gorm.DB) contentQuery {
 	c.contentQueryDo.ReplaceConnPool(db.Statement.ConnPool)
+	c.Author.db = db.Session(&gorm.Session{Initialized: true})
+	c.Author.db.Statement.ConnPool = db.Statement.ConnPool
+	c.ContentAssets.db = db.Session(&gorm.Session{Initialized: true})
+	c.ContentAssets.db.Statement.ConnPool = db.Statement.ConnPool
+	c.Comments.db = db.Session(&gorm.Session{Initialized: true})
+	c.Comments.db.Statement.ConnPool = db.Statement.ConnPool
 	return c
 }
 
 func (c contentQuery) replaceDB(db *gorm.DB) contentQuery {
 	c.contentQueryDo.ReplaceDB(db)
+	c.Author.db = db.Session(&gorm.Session{})
+	c.ContentAssets.db = db.Session(&gorm.Session{})
+	c.Comments.db = db.Session(&gorm.Session{})
 	return c
 }
 
+type contentQueryBelongsToAuthor struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a contentQueryBelongsToAuthor) Where(conds ...field.Expr) *contentQueryBelongsToAuthor {
+	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 contentQueryBelongsToAuthor) WithContext(ctx context.Context) *contentQueryBelongsToAuthor {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a contentQueryBelongsToAuthor) Session(session *gorm.Session) *contentQueryBelongsToAuthor {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a contentQueryBelongsToAuthor) Model(m *Content) *contentQueryBelongsToAuthorTx {
+	return &contentQueryBelongsToAuthorTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a contentQueryBelongsToAuthor) Unscoped() *contentQueryBelongsToAuthor {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type contentQueryBelongsToAuthorTx struct{ tx *gorm.Association }
+
+func (a contentQueryBelongsToAuthorTx) Find() (result *User, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a contentQueryBelongsToAuthorTx) Append(values ...*User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a contentQueryBelongsToAuthorTx) Replace(values ...*User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a contentQueryBelongsToAuthorTx) Delete(values ...*User) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a contentQueryBelongsToAuthorTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a contentQueryBelongsToAuthorTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a contentQueryBelongsToAuthorTx) Unscoped() *contentQueryBelongsToAuthorTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type contentQueryHasManyContentAssets struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a contentQueryHasManyContentAssets) Where(conds ...field.Expr) *contentQueryHasManyContentAssets {
+	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 contentQueryHasManyContentAssets) WithContext(ctx context.Context) *contentQueryHasManyContentAssets {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a contentQueryHasManyContentAssets) Session(session *gorm.Session) *contentQueryHasManyContentAssets {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a contentQueryHasManyContentAssets) Model(m *Content) *contentQueryHasManyContentAssetsTx {
+	return &contentQueryHasManyContentAssetsTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a contentQueryHasManyContentAssets) Unscoped() *contentQueryHasManyContentAssets {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type contentQueryHasManyContentAssetsTx struct{ tx *gorm.Association }
+
+func (a contentQueryHasManyContentAssetsTx) Find() (result []*ContentAsset, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a contentQueryHasManyContentAssetsTx) Append(values ...*ContentAsset) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a contentQueryHasManyContentAssetsTx) Replace(values ...*ContentAsset) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a contentQueryHasManyContentAssetsTx) Delete(values ...*ContentAsset) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a contentQueryHasManyContentAssetsTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a contentQueryHasManyContentAssetsTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a contentQueryHasManyContentAssetsTx) Unscoped() *contentQueryHasManyContentAssetsTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type contentQueryHasManyComments struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a contentQueryHasManyComments) Where(conds ...field.Expr) *contentQueryHasManyComments {
+	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 contentQueryHasManyComments) WithContext(ctx context.Context) *contentQueryHasManyComments {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a contentQueryHasManyComments) Session(session *gorm.Session) *contentQueryHasManyComments {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a contentQueryHasManyComments) Model(m *Content) *contentQueryHasManyCommentsTx {
+	return &contentQueryHasManyCommentsTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a contentQueryHasManyComments) Unscoped() *contentQueryHasManyComments {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type contentQueryHasManyCommentsTx struct{ tx *gorm.Association }
+
+func (a contentQueryHasManyCommentsTx) Find() (result []*Comment, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a contentQueryHasManyCommentsTx) Append(values ...*Comment) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a contentQueryHasManyCommentsTx) Replace(values ...*Comment) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a contentQueryHasManyCommentsTx) Delete(values ...*Comment) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a contentQueryHasManyCommentsTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a contentQueryHasManyCommentsTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a contentQueryHasManyCommentsTx) Unscoped() *contentQueryHasManyCommentsTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type contentQueryDo struct{ gen.DO }
 
 func (c contentQueryDo) Debug() *contentQueryDo {

backend/database/models/orders.gen.go

@@ -24,7 +24,7 @@ type Order struct {
 	UserID               int64                                 `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
 	Type                 consts.OrderType                      `gorm:"column:type;type:character varying(32);default:content_purchase" json:"type"`
 	Status               consts.OrderStatus                    `gorm:"column:status;type:character varying(32);default:created" json:"status"`
-	Currency             string                                `gorm:"column:currency;type:character varying(16);default:CNY" json:"currency"`
+	Currency             consts.Currency                       `gorm:"column:currency;type:character varying(16);default:CNY" json:"currency"`
 	AmountOriginal       int64                                 `gorm:"column:amount_original;type:bigint;not null" json:"amount_original"`
 	AmountDiscount       int64                                 `gorm:"column:amount_discount;type:bigint;not null" json:"amount_discount"`
 	AmountPaid           int64                                 `gorm:"column:amount_paid;type:bigint;not null" json:"amount_paid"`

backend/database/models/orders.query.gen.go

@@ -30,7 +30,7 @@ func newOrder(db *gorm.DB, opts ...gen.DOOption) orderQuery {
 	_orderQuery.UserID = field.NewInt64(tableName, "user_id")
 	_orderQuery.Type = field.NewField(tableName, "type")
 	_orderQuery.Status = field.NewField(tableName, "status")
-	_orderQuery.Currency = field.NewString(tableName, "currency")
+	_orderQuery.Currency = field.NewField(tableName, "currency")
 	_orderQuery.AmountOriginal = field.NewInt64(tableName, "amount_original")
 	_orderQuery.AmountDiscount = field.NewInt64(tableName, "amount_discount")
 	_orderQuery.AmountPaid = field.NewInt64(tableName, "amount_paid")
@@ -58,7 +58,7 @@ type orderQuery struct {
 	UserID               field.Int64
 	Type                 field.Field
 	Status               field.Field
-	Currency             field.String
+	Currency             field.Field
 	AmountOriginal       field.Int64
 	AmountDiscount       field.Int64
 	AmountPaid           field.Int64
@@ -92,7 +92,7 @@ func (o *orderQuery) updateTableName(table string) *orderQuery {
 	o.UserID = field.NewInt64(table, "user_id")
 	o.Type = field.NewField(table, "type")
 	o.Status = field.NewField(table, "status")
-	o.Currency = field.NewString(table, "currency")
+	o.Currency = field.NewField(table, "currency")
 	o.AmountOriginal = field.NewInt64(table, "amount_original")
 	o.AmountDiscount = field.NewInt64(table, "amount_discount")
 	o.AmountPaid = field.NewInt64(table, "amount_paid")

backend/database/models/tenant_ledgers.gen.go

@@ -8,6 +8,8 @@ import (
 	"context"
 	"time"
 
+	"quyun/v2/pkg/consts"
+
 	"go.ipao.vip/gen"
 )
 
@@ -15,23 +17,23 @@ const TableNameTenantLedger = "tenant_ledgers"
 
 // TenantLedger mapped from table <tenant_ledgers>
 type TenantLedger struct {
-	ID             int64     `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"`
-	TenantID       int64     `gorm:"column:tenant_id;type:bigint;not null" json:"tenant_id"`
-	UserID         int64     `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
-	OrderID        int64     `gorm:"column:order_id;type:bigint" json:"order_id"`
-	Type           string    `gorm:"column:type;type:character varying(32);not null" json:"type"`
-	Amount         int64     `gorm:"column:amount;type:bigint;not null" json:"amount"`
-	BalanceBefore  int64     `gorm:"column:balance_before;type:bigint;not null" json:"balance_before"`
-	BalanceAfter   int64     `gorm:"column:balance_after;type:bigint;not null" json:"balance_after"`
-	FrozenBefore   int64     `gorm:"column:frozen_before;type:bigint;not null" json:"frozen_before"`
-	FrozenAfter    int64     `gorm:"column:frozen_after;type:bigint;not null" json:"frozen_after"`
-	IdempotencyKey string    `gorm:"column:idempotency_key;type:character varying(128);not null" json:"idempotency_key"`
-	Remark         string    `gorm:"column:remark;type:character varying(255);not null" json:"remark"`
-	OperatorUserID int64     `gorm:"column:operator_user_id;type:bigint" json:"operator_user_id"`
-	BizRefType     string    `gorm:"column:biz_ref_type;type:character varying(32)" json:"biz_ref_type"`
-	BizRefID       int64     `gorm:"column:biz_ref_id;type:bigint" json:"biz_ref_id"`
-	CreatedAt      time.Time `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
-	UpdatedAt      time.Time `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
+	ID             int64                   `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"`
+	TenantID       int64                   `gorm:"column:tenant_id;type:bigint;not null" json:"tenant_id"`
+	UserID         int64                   `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
+	OrderID        int64                   `gorm:"column:order_id;type:bigint" json:"order_id"`
+	Type           consts.TenantLedgerType `gorm:"column:type;type:character varying(32);not null" json:"type"`
+	Amount         int64                   `gorm:"column:amount;type:bigint;not null" json:"amount"`
+	BalanceBefore  int64                   `gorm:"column:balance_before;type:bigint;not null" json:"balance_before"`
+	BalanceAfter   int64                   `gorm:"column:balance_after;type:bigint;not null" json:"balance_after"`
+	FrozenBefore   int64                   `gorm:"column:frozen_before;type:bigint;not null" json:"frozen_before"`
+	FrozenAfter    int64                   `gorm:"column:frozen_after;type:bigint;not null" json:"frozen_after"`
+	IdempotencyKey string                  `gorm:"column:idempotency_key;type:character varying(128);not null" json:"idempotency_key"`
+	Remark         string                  `gorm:"column:remark;type:character varying(255);not null" json:"remark"`
+	OperatorUserID int64                   `gorm:"column:operator_user_id;type:bigint" json:"operator_user_id"`
+	BizRefType     string                  `gorm:"column:biz_ref_type;type:character varying(32)" json:"biz_ref_type"`
+	BizRefID       int64                   `gorm:"column:biz_ref_id;type:bigint" json:"biz_ref_id"`
+	CreatedAt      time.Time               `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
+	UpdatedAt      time.Time               `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
 }
 
 // Quick operations without importing query package

backend/database/models/tenant_ledgers.query.gen.go

@@ -29,7 +29,7 @@ func newTenantLedger(db *gorm.DB, opts ...gen.DOOption) tenantLedgerQuery {
 	_tenantLedgerQuery.TenantID = field.NewInt64(tableName, "tenant_id")
 	_tenantLedgerQuery.UserID = field.NewInt64(tableName, "user_id")
 	_tenantLedgerQuery.OrderID = field.NewInt64(tableName, "order_id")
-	_tenantLedgerQuery.Type = field.NewString(tableName, "type")
+	_tenantLedgerQuery.Type = field.NewField(tableName, "type")
 	_tenantLedgerQuery.Amount = field.NewInt64(tableName, "amount")
 	_tenantLedgerQuery.BalanceBefore = field.NewInt64(tableName, "balance_before")
 	_tenantLedgerQuery.BalanceAfter = field.NewInt64(tableName, "balance_after")
@@ -56,7 +56,7 @@ type tenantLedgerQuery struct {
 	TenantID       field.Int64
 	UserID         field.Int64
 	OrderID        field.Int64
-	Type           field.String
+	Type           field.Field
 	Amount         field.Int64
 	BalanceBefore  field.Int64
 	BalanceAfter   field.Int64
@@ -89,7 +89,7 @@ func (t *tenantLedgerQuery) updateTableName(table string) *tenantLedgerQuery {
 	t.TenantID = field.NewInt64(table, "tenant_id")
 	t.UserID = field.NewInt64(table, "user_id")
 	t.OrderID = field.NewInt64(table, "order_id")
-	t.Type = field.NewString(table, "type")
+	t.Type = field.NewField(table, "type")
 	t.Amount = field.NewInt64(table, "amount")
 	t.BalanceBefore = field.NewInt64(table, "balance_before")
 	t.BalanceAfter = field.NewInt64(table, "balance_after")

backend/database/models/tenant_users.gen.go

@@ -22,7 +22,7 @@ type TenantUser struct {
 	TenantID  int64                              `gorm:"column:tenant_id;type:bigint;not null" json:"tenant_id"`
 	UserID    int64                              `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
 	Role      types.Array[consts.TenantUserRole] `gorm:"column:role;type:text[];default:{member}" json:"role"`
-	Status    string                             `gorm:"column:status;type:character varying(50);default:verified" json:"status"`
+	Status    consts.UserStatus                  `gorm:"column:status;type:character varying(50);default:verified" json:"status"`
 	CreatedAt time.Time                          `gorm:"column:created_at;type:timestamp with time zone;default:now()" json:"created_at"`
 	UpdatedAt time.Time                          `gorm:"column:updated_at;type:timestamp with time zone;default:now()" json:"updated_at"`
 }

backend/database/models/tenant_users.query.gen.go

@@ -29,7 +29,7 @@ func newTenantUser(db *gorm.DB, opts ...gen.DOOption) tenantUserQuery {
 	_tenantUserQuery.TenantID = field.NewInt64(tableName, "tenant_id")
 	_tenantUserQuery.UserID = field.NewInt64(tableName, "user_id")
 	_tenantUserQuery.Role = field.NewArray(tableName, "role")
-	_tenantUserQuery.Status = field.NewString(tableName, "status")
+	_tenantUserQuery.Status = field.NewField(tableName, "status")
 	_tenantUserQuery.CreatedAt = field.NewTime(tableName, "created_at")
 	_tenantUserQuery.UpdatedAt = field.NewTime(tableName, "updated_at")
 
@@ -46,7 +46,7 @@ type tenantUserQuery struct {
 	TenantID  field.Int64
 	UserID    field.Int64
 	Role      field.Array
-	Status    field.String
+	Status    field.Field
 	CreatedAt field.Time
 	UpdatedAt field.Time
 
@@ -69,7 +69,7 @@ func (t *tenantUserQuery) updateTableName(table string) *tenantUserQuery {
 	t.TenantID = field.NewInt64(table, "tenant_id")
 	t.UserID = field.NewInt64(table, "user_id")
 	t.Role = field.NewArray(table, "role")
-	t.Status = field.NewString(table, "status")
+	t.Status = field.NewField(table, "status")
 	t.CreatedAt = field.NewTime(table, "created_at")
 	t.UpdatedAt = field.NewTime(table, "updated_at")