rogee/quyun-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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.

Browse Source
This commit is contained in:
Rogee
2025-12-29 14:21:20 +08:00
parent d648a1e45b
commit 8fa3d18a9c
30 changed files with 2251 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
backend/database/.transform.yaml
View File

@@ -27,6 +27,7 @@ field_type:
orders:
status: consts.OrderStatus
type: consts.OrderType
currency: consts.Currency
snapshot: types.JSONType[fields.OrdersSnapshot]
order_items:
snapshot: types.JSONType[fields.OrderItemsSnapshot]
@@ -35,9 +36,49 @@ field_type:
config: types.JSONType[fields.TenantConfig]
tenant_users:
role: types.Array[consts.TenantUserRole]
status: consts.UserStatus
content_assets:
role: consts.ContentAssetRole
media_assets:
meta: types.JSONType[fields.MediaAssetMeta]
type: consts.MediaAssetType
status: consts.MediaAssetStatus
variant: consts.MediaAssetVariant
content_access:
status: consts.ContentAccessStatus
tenant_ledgers:
type: consts.TenantLedgerType
field_relate:
contents:
Author:
relation: belongs_to
table: users
foreign_key: user_id
references: id
json: author
ContentAssets:
relation: has_many
table: content_assets
foreign_key: content_id
references: id
json: content_assets
Comments:
relation: has_many
table: comments
foreign_key: content_id
references: id
json: comments
comments:
User:
relation: belongs_to
table: users
foreign_key: user_id
references: id
json: user
content_assets:
Asset:
relation: belongs_to
table: media_assets
foreign_key: asset_id
references: id
json: asset

1
backend/database/models/comments.gen.go
View File

@@ -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

93
backend/database/models/comments.query.gen.go
View File

@@ -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 {

20
backend/database/models/content_access.gen.go
View File

@@ -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

6
backend/database/models/content_access.query.gen.go
View File

@@ -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")

21
backend/database/models/content_assets.gen.go
View File

@@ -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

99
backend/database/models/content_assets.query.gen.go
View File

@@ -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 {

3
backend/database/models/contents.gen.go
View File

@@ -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

277
backend/database/models/contents.query.gen.go
View File

@@ -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 {

2
backend/database/models/orders.gen.go
View File

@@ -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"`

6
backend/database/models/orders.query.gen.go
View File

@@ -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")

36
backend/database/models/tenant_ledgers.gen.go
View File

@@ -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

6
backend/database/models/tenant_ledgers.query.gen.go
View File

@@ -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")

2
backend/database/models/tenant_users.gen.go
View File

@@ -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"`
}

6
backend/database/models/tenant_users.query.gen.go
View File

@@ -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")