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.

2025-12-29 14:21:20 +08:00
parent d648a1e45b
commit 8fa3d18a9c
30 changed files with 2251 additions and 85 deletions
--- a/backend/database/models/contents.query.gen.go
+++ b/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 {