lanhu/platform
2
0
Fork 0
Code Issues Actions Packages Releases 12 Activity

优化表结构，重构模型，重新实现基于白银网关的提取节点流程

Browse Source
This commit is contained in:
luorijun
2025-11-24 18:44:06 +08:00
parent 9a574f55cb
commit cb2a963a37
142 changed files with 6528 additions and 5808 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
web/queries/admin.gen.go
View File

@@ -28,19 +28,19 @@ func newAdmin(db *gorm.DB, opts ...gen.DOOption) admin {
tableName := _admin.adminDo.TableName()
_admin.ALL = field.NewAsterisk(tableName)
_admin.ID = field.NewInt32(tableName, "id")
_admin.CreatedAt = field.NewTime(tableName, "created_at")
_admin.UpdatedAt = field.NewTime(tableName, "updated_at")
_admin.DeletedAt = field.NewField(tableName, "deleted_at")
_admin.Username = field.NewString(tableName, "username")
_admin.Password = field.NewString(tableName, "password")
_admin.Name = field.NewString(tableName, "name")
_admin.Avatar = field.NewString(tableName, "avatar")
_admin.Phone = field.NewString(tableName, "phone")
_admin.Email = field.NewString(tableName, "email")
_admin.Status = field.NewInt32(tableName, "status")
_admin.LastLogin = field.NewField(tableName, "last_login")
_admin.LastLoginHost = field.NewString(tableName, "last_login_host")
_admin.LastLoginAgent = field.NewString(tableName, "last_login_agent")
_admin.CreatedAt = field.NewField(tableName, "created_at")
_admin.UpdatedAt = field.NewField(tableName, "updated_at")
_admin.DeletedAt = field.NewField(tableName, "deleted_at")
_admin.Status = field.NewInt(tableName, "status")
_admin.LastLogin = field.NewTime(tableName, "last_login")
_admin.LastLoginIP = field.NewField(tableName, "last_login_ip")
_admin.LastLoginUA = field.NewString(tableName, "last_login_ua")
_admin.fillFieldMap()
@@ -50,21 +50,21 @@ func newAdmin(db *gorm.DB, opts ...gen.DOOption) admin {
type admin struct {
adminDo
ALL field.Asterisk
ID field.Int32 // 管理员ID
Username field.String // 用户名
Password field.String // 密码
Name field.String // 真实姓名
Avatar field.String // 头像URL
Phone field.String // 手机号码
Email field.String // 邮箱
Status field.Int32 // 状态：0-禁用，1-正常
LastLogin field.Field // 最后登录时间
LastLoginHost field.String // 最后登录地址
LastLoginAgent field.String // 最后登录代理
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ALL field.Asterisk
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Username field.String
Password field.String
Name field.String
Avatar field.String
Phone field.String
Email field.String
Status field.Int
LastLogin field.Time
LastLoginIP field.Field
LastLoginUA field.String
fieldMap map[string]field.Expr
}
@@ -82,19 +82,19 @@ func (a admin) As(alias string) *admin {
func (a *admin) updateTableName(table string) *admin {
a.ALL = field.NewAsterisk(table)
a.ID = field.NewInt32(table, "id")
a.CreatedAt = field.NewTime(table, "created_at")
a.UpdatedAt = field.NewTime(table, "updated_at")
a.DeletedAt = field.NewField(table, "deleted_at")
a.Username = field.NewString(table, "username")
a.Password = field.NewString(table, "password")
a.Name = field.NewString(table, "name")
a.Avatar = field.NewString(table, "avatar")
a.Phone = field.NewString(table, "phone")
a.Email = field.NewString(table, "email")
a.Status = field.NewInt32(table, "status")
a.LastLogin = field.NewField(table, "last_login")
a.LastLoginHost = field.NewString(table, "last_login_host")
a.LastLoginAgent = field.NewString(table, "last_login_agent")
a.CreatedAt = field.NewField(table, "created_at")
a.UpdatedAt = field.NewField(table, "updated_at")
a.DeletedAt = field.NewField(table, "deleted_at")
a.Status = field.NewInt(table, "status")
a.LastLogin = field.NewTime(table, "last_login")
a.LastLoginIP = field.NewField(table, "last_login_ip")
a.LastLoginUA = field.NewString(table, "last_login_ua")
a.fillFieldMap()
@@ -113,6 +113,9 @@ func (a *admin) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (a *admin) fillFieldMap() {
a.fieldMap = make(map[string]field.Expr, 14)
a.fieldMap["id"] = a.ID
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
a.fieldMap["deleted_at"] = a.DeletedAt
a.fieldMap["username"] = a.Username
a.fieldMap["password"] = a.Password
a.fieldMap["name"] = a.Name
@@ -121,11 +124,8 @@ func (a *admin) fillFieldMap() {
a.fieldMap["email"] = a.Email
a.fieldMap["status"] = a.Status
a.fieldMap["last_login"] = a.LastLogin
a.fieldMap["last_login_host"] = a.LastLoginHost
a.fieldMap["last_login_agent"] = a.LastLoginAgent
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
a.fieldMap["deleted_at"] = a.DeletedAt
a.fieldMap["last_login_ip"] = a.LastLoginIP
a.fieldMap["last_login_ua"] = a.LastLoginUA
}
func (a admin) clone(db *gorm.DB) admin {

34
web/queries/admin_role.gen.go
View File

@@ -28,13 +28,13 @@ func newAdminRole(db *gorm.DB, opts ...gen.DOOption) adminRole {
tableName := _adminRole.adminRoleDo.TableName()
_adminRole.ALL = field.NewAsterisk(tableName)
_adminRole.ID = field.NewInt32(tableName, "id")
_adminRole.CreatedAt = field.NewTime(tableName, "created_at")
_adminRole.UpdatedAt = field.NewTime(tableName, "updated_at")
_adminRole.DeletedAt = field.NewField(tableName, "deleted_at")
_adminRole.Name = field.NewString(tableName, "name")
_adminRole.Description = field.NewString(tableName, "description")
_adminRole.Active = field.NewBool(tableName, "active")
_adminRole.Sort = field.NewInt32(tableName, "sort")
_adminRole.CreatedAt = field.NewField(tableName, "created_at")
_adminRole.UpdatedAt = field.NewField(tableName, "updated_at")
_adminRole.DeletedAt = field.NewField(tableName, "deleted_at")
_adminRole.fillFieldMap()
@@ -45,14 +45,14 @@ type adminRole struct {
adminRoleDo
ALL field.Asterisk
ID field.Int32 // 管理员角色ID
Name field.String // 角色名称
Description field.String // 角色描述
Active field.Bool // 是否激活
Sort field.Int32 // 排序
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Name field.String
Description field.String
Active field.Bool
Sort field.Int32
fieldMap map[string]field.Expr
}
@@ -70,13 +70,13 @@ func (a adminRole) As(alias string) *adminRole {
func (a *adminRole) updateTableName(table string) *adminRole {
a.ALL = field.NewAsterisk(table)
a.ID = field.NewInt32(table, "id")
a.CreatedAt = field.NewTime(table, "created_at")
a.UpdatedAt = field.NewTime(table, "updated_at")
a.DeletedAt = field.NewField(table, "deleted_at")
a.Name = field.NewString(table, "name")
a.Description = field.NewString(table, "description")
a.Active = field.NewBool(table, "active")
a.Sort = field.NewInt32(table, "sort")
a.CreatedAt = field.NewField(table, "created_at")
a.UpdatedAt = field.NewField(table, "updated_at")
a.DeletedAt = field.NewField(table, "deleted_at")
a.fillFieldMap()
@@ -95,13 +95,13 @@ func (a *adminRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (a *adminRole) fillFieldMap() {
a.fieldMap = make(map[string]field.Expr, 8)
a.fieldMap["id"] = a.ID
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
a.fieldMap["deleted_at"] = a.DeletedAt
a.fieldMap["name"] = a.Name
a.fieldMap["description"] = a.Description
a.fieldMap["active"] = a.Active
a.fieldMap["sort"] = a.Sort
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
a.fieldMap["deleted_at"] = a.DeletedAt
}
func (a adminRole) clone(db *gorm.DB) adminRole {

339
web/queries/admin_role_link.gen.go
View File

@@ -1,339 +0,0 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newAdminRoleLink(db *gorm.DB, opts ...gen.DOOption) adminRoleLink {
_adminRoleLink := adminRoleLink{}
_adminRoleLink.adminRoleLinkDo.UseDB(db, opts...)
_adminRoleLink.adminRoleLinkDo.UseModel(&models.AdminRoleLink{})
tableName := _adminRoleLink.adminRoleLinkDo.TableName()
_adminRoleLink.ALL = field.NewAsterisk(tableName)
_adminRoleLink.ID = field.NewInt32(tableName, "id")
_adminRoleLink.AdminID = field.NewInt32(tableName, "admin_id")
_adminRoleLink.RoleID = field.NewInt32(tableName, "role_id")
_adminRoleLink.CreatedAt = field.NewField(tableName, "created_at")
_adminRoleLink.UpdatedAt = field.NewField(tableName, "updated_at")
_adminRoleLink.DeletedAt = field.NewField(tableName, "deleted_at")
_adminRoleLink.fillFieldMap()
return _adminRoleLink
}
type adminRoleLink struct {
adminRoleLinkDo
ALL field.Asterisk
ID field.Int32 // 关联ID
AdminID field.Int32 // 管理员ID
RoleID field.Int32 // 角色ID
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (a adminRoleLink) Table(newTableName string) *adminRoleLink {
a.adminRoleLinkDo.UseTable(newTableName)
return a.updateTableName(newTableName)
}
func (a adminRoleLink) As(alias string) *adminRoleLink {
a.adminRoleLinkDo.DO = *(a.adminRoleLinkDo.As(alias).(*gen.DO))
return a.updateTableName(alias)
}
func (a *adminRoleLink) updateTableName(table string) *adminRoleLink {
a.ALL = field.NewAsterisk(table)
a.ID = field.NewInt32(table, "id")
a.AdminID = field.NewInt32(table, "admin_id")
a.RoleID = field.NewInt32(table, "role_id")
a.CreatedAt = field.NewField(table, "created_at")
a.UpdatedAt = field.NewField(table, "updated_at")
a.DeletedAt = field.NewField(table, "deleted_at")
a.fillFieldMap()
return a
}
func (a *adminRoleLink) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := a.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (a *adminRoleLink) fillFieldMap() {
a.fieldMap = make(map[string]field.Expr, 6)
a.fieldMap["id"] = a.ID
a.fieldMap["admin_id"] = a.AdminID
a.fieldMap["role_id"] = a.RoleID
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
a.fieldMap["deleted_at"] = a.DeletedAt
}
func (a adminRoleLink) clone(db *gorm.DB) adminRoleLink {
a.adminRoleLinkDo.ReplaceConnPool(db.Statement.ConnPool)
return a
}
func (a adminRoleLink) replaceDB(db *gorm.DB) adminRoleLink {
a.adminRoleLinkDo.ReplaceDB(db)
return a
}
type adminRoleLinkDo struct{ gen.DO }
func (a adminRoleLinkDo) Debug() *adminRoleLinkDo {
return a.withDO(a.DO.Debug())
}
func (a adminRoleLinkDo) WithContext(ctx context.Context) *adminRoleLinkDo {
return a.withDO(a.DO.WithContext(ctx))
}
func (a adminRoleLinkDo) ReadDB() *adminRoleLinkDo {
return a.Clauses(dbresolver.Read)
}
func (a adminRoleLinkDo) WriteDB() *adminRoleLinkDo {
return a.Clauses(dbresolver.Write)
}
func (a adminRoleLinkDo) Session(config *gorm.Session) *adminRoleLinkDo {
return a.withDO(a.DO.Session(config))
}
func (a adminRoleLinkDo) Clauses(conds ...clause.Expression) *adminRoleLinkDo {
return a.withDO(a.DO.Clauses(conds...))
}
func (a adminRoleLinkDo) Returning(value interface{}, columns ...string) *adminRoleLinkDo {
return a.withDO(a.DO.Returning(value, columns...))
}
func (a adminRoleLinkDo) Not(conds ...gen.Condition) *adminRoleLinkDo {
return a.withDO(a.DO.Not(conds...))
}
func (a adminRoleLinkDo) Or(conds ...gen.Condition) *adminRoleLinkDo {
return a.withDO(a.DO.Or(conds...))
}
func (a adminRoleLinkDo) Select(conds ...field.Expr) *adminRoleLinkDo {
return a.withDO(a.DO.Select(conds...))
}
func (a adminRoleLinkDo) Where(conds ...gen.Condition) *adminRoleLinkDo {
return a.withDO(a.DO.Where(conds...))
}
func (a adminRoleLinkDo) Order(conds ...field.Expr) *adminRoleLinkDo {
return a.withDO(a.DO.Order(conds...))
}
func (a adminRoleLinkDo) Distinct(cols ...field.Expr) *adminRoleLinkDo {
return a.withDO(a.DO.Distinct(cols...))
}
func (a adminRoleLinkDo) Omit(cols ...field.Expr) *adminRoleLinkDo {
return a.withDO(a.DO.Omit(cols...))
}
func (a adminRoleLinkDo) Join(table schema.Tabler, on ...field.Expr) *adminRoleLinkDo {
return a.withDO(a.DO.Join(table, on...))
}
func (a adminRoleLinkDo) LeftJoin(table schema.Tabler, on ...field.Expr) *adminRoleLinkDo {
return a.withDO(a.DO.LeftJoin(table, on...))
}
func (a adminRoleLinkDo) RightJoin(table schema.Tabler, on ...field.Expr) *adminRoleLinkDo {
return a.withDO(a.DO.RightJoin(table, on...))
}
func (a adminRoleLinkDo) Group(cols ...field.Expr) *adminRoleLinkDo {
return a.withDO(a.DO.Group(cols...))
}
func (a adminRoleLinkDo) Having(conds ...gen.Condition) *adminRoleLinkDo {
return a.withDO(a.DO.Having(conds...))
}
func (a adminRoleLinkDo) Limit(limit int) *adminRoleLinkDo {
return a.withDO(a.DO.Limit(limit))
}
func (a adminRoleLinkDo) Offset(offset int) *adminRoleLinkDo {
return a.withDO(a.DO.Offset(offset))
}
func (a adminRoleLinkDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *adminRoleLinkDo {
return a.withDO(a.DO.Scopes(funcs...))
}
func (a adminRoleLinkDo) Unscoped() *adminRoleLinkDo {
return a.withDO(a.DO.Unscoped())
}
func (a adminRoleLinkDo) Create(values ...*models.AdminRoleLink) error {
if len(values) == 0 {
return nil
}
return a.DO.Create(values)
}
func (a adminRoleLinkDo) CreateInBatches(values []*models.AdminRoleLink, batchSize int) error {
return a.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (a adminRoleLinkDo) Save(values ...*models.AdminRoleLink) error {
if len(values) == 0 {
return nil
}
return a.DO.Save(values)
}
func (a adminRoleLinkDo) First() (*models.AdminRoleLink, error) {
if result, err := a.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.AdminRoleLink), nil
}
}
func (a adminRoleLinkDo) Take() (*models.AdminRoleLink, error) {
if result, err := a.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.AdminRoleLink), nil
}
}
func (a adminRoleLinkDo) Last() (*models.AdminRoleLink, error) {
if result, err := a.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.AdminRoleLink), nil
}
}
func (a adminRoleLinkDo) Find() ([]*models.AdminRoleLink, error) {
result, err := a.DO.Find()
return result.([]*models.AdminRoleLink), err
}
func (a adminRoleLinkDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.AdminRoleLink, err error) {
buf := make([]*models.AdminRoleLink, 0, batchSize)
err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (a adminRoleLinkDo) FindInBatches(result *[]*models.AdminRoleLink, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return a.DO.FindInBatches(result, batchSize, fc)
}
func (a adminRoleLinkDo) Attrs(attrs ...field.AssignExpr) *adminRoleLinkDo {
return a.withDO(a.DO.Attrs(attrs...))
}
func (a adminRoleLinkDo) Assign(attrs ...field.AssignExpr) *adminRoleLinkDo {
return a.withDO(a.DO.Assign(attrs...))
}
func (a adminRoleLinkDo) Joins(fields ...field.RelationField) *adminRoleLinkDo {
for _, _f := range fields {
a = *a.withDO(a.DO.Joins(_f))
}
return &a
}
func (a adminRoleLinkDo) Preload(fields ...field.RelationField) *adminRoleLinkDo {
for _, _f := range fields {
a = *a.withDO(a.DO.Preload(_f))
}
return &a
}
func (a adminRoleLinkDo) FirstOrInit() (*models.AdminRoleLink, error) {
if result, err := a.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.AdminRoleLink), nil
}
}
func (a adminRoleLinkDo) FirstOrCreate() (*models.AdminRoleLink, error) {
if result, err := a.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.AdminRoleLink), nil
}
}
func (a adminRoleLinkDo) FindByPage(offset int, limit int) (result []*models.AdminRoleLink, count int64, err error) {
result, err = a.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = a.Offset(-1).Limit(-1).Count()
return
}
func (a adminRoleLinkDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = a.Count()
if err != nil {
return
}
err = a.Offset(offset).Limit(limit).Scan(result)
return
}
func (a adminRoleLinkDo) Scan(result interface{}) (err error) {
return a.DO.Scan(result)
}
func (a adminRoleLinkDo) Delete(models ...*models.AdminRoleLink) (result gen.ResultInfo, err error) {
return a.DO.Delete(models)
}
func (a *adminRoleLinkDo) withDO(do gen.Dao) *adminRoleLinkDo {
a.DO = *do.(*gen.DO)
return a
}

339
web/queries/admin_role_permission_link.gen.go
View File

@@ -1,339 +0,0 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newAdminRolePermissionLink(db *gorm.DB, opts ...gen.DOOption) adminRolePermissionLink {
_adminRolePermissionLink := adminRolePermissionLink{}
_adminRolePermissionLink.adminRolePermissionLinkDo.UseDB(db, opts...)
_adminRolePermissionLink.adminRolePermissionLinkDo.UseModel(&models.AdminRolePermissionLink{})
tableName := _adminRolePermissionLink.adminRolePermissionLinkDo.TableName()
_adminRolePermissionLink.ALL = field.NewAsterisk(tableName)
_adminRolePermissionLink.ID = field.NewInt32(tableName, "id")
_adminRolePermissionLink.RoleID = field.NewInt32(tableName, "role_id")
_adminRolePermissionLink.PermissionID = field.NewInt32(tableName, "permission_id")
_adminRolePermissionLink.CreatedAt = field.NewField(tableName, "created_at")
_adminRolePermissionLink.UpdatedAt = field.NewField(tableName, "updated_at")
_adminRolePermissionLink.DeletedAt = field.NewField(tableName, "deleted_at")
_adminRolePermissionLink.fillFieldMap()
return _adminRolePermissionLink
}
type adminRolePermissionLink struct {
adminRolePermissionLinkDo
ALL field.Asterisk
ID field.Int32 // 关联ID
RoleID field.Int32 // 角色ID
PermissionID field.Int32 // 权限ID
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (a adminRolePermissionLink) Table(newTableName string) *adminRolePermissionLink {
a.adminRolePermissionLinkDo.UseTable(newTableName)
return a.updateTableName(newTableName)
}
func (a adminRolePermissionLink) As(alias string) *adminRolePermissionLink {
a.adminRolePermissionLinkDo.DO = *(a.adminRolePermissionLinkDo.As(alias).(*gen.DO))
return a.updateTableName(alias)
}
func (a *adminRolePermissionLink) updateTableName(table string) *adminRolePermissionLink {
a.ALL = field.NewAsterisk(table)
a.ID = field.NewInt32(table, "id")
a.RoleID = field.NewInt32(table, "role_id")
a.PermissionID = field.NewInt32(table, "permission_id")
a.CreatedAt = field.NewField(table, "created_at")
a.UpdatedAt = field.NewField(table, "updated_at")
a.DeletedAt = field.NewField(table, "deleted_at")
a.fillFieldMap()
return a
}
func (a *adminRolePermissionLink) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := a.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (a *adminRolePermissionLink) fillFieldMap() {
a.fieldMap = make(map[string]field.Expr, 6)
a.fieldMap["id"] = a.ID
a.fieldMap["role_id"] = a.RoleID
a.fieldMap["permission_id"] = a.PermissionID
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
a.fieldMap["deleted_at"] = a.DeletedAt
}
func (a adminRolePermissionLink) clone(db *gorm.DB) adminRolePermissionLink {
a.adminRolePermissionLinkDo.ReplaceConnPool(db.Statement.ConnPool)
return a
}
func (a adminRolePermissionLink) replaceDB(db *gorm.DB) adminRolePermissionLink {
a.adminRolePermissionLinkDo.ReplaceDB(db)
return a
}
type adminRolePermissionLinkDo struct{ gen.DO }
func (a adminRolePermissionLinkDo) Debug() *adminRolePermissionLinkDo {
return a.withDO(a.DO.Debug())
}
func (a adminRolePermissionLinkDo) WithContext(ctx context.Context) *adminRolePermissionLinkDo {
return a.withDO(a.DO.WithContext(ctx))
}
func (a adminRolePermissionLinkDo) ReadDB() *adminRolePermissionLinkDo {
return a.Clauses(dbresolver.Read)
}
func (a adminRolePermissionLinkDo) WriteDB() *adminRolePermissionLinkDo {
return a.Clauses(dbresolver.Write)
}
func (a adminRolePermissionLinkDo) Session(config *gorm.Session) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Session(config))
}
func (a adminRolePermissionLinkDo) Clauses(conds ...clause.Expression) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Clauses(conds...))
}
func (a adminRolePermissionLinkDo) Returning(value interface{}, columns ...string) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Returning(value, columns...))
}
func (a adminRolePermissionLinkDo) Not(conds ...gen.Condition) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Not(conds...))
}
func (a adminRolePermissionLinkDo) Or(conds ...gen.Condition) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Or(conds...))
}
func (a adminRolePermissionLinkDo) Select(conds ...field.Expr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Select(conds...))
}
func (a adminRolePermissionLinkDo) Where(conds ...gen.Condition) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Where(conds...))
}
func (a adminRolePermissionLinkDo) Order(conds ...field.Expr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Order(conds...))
}
func (a adminRolePermissionLinkDo) Distinct(cols ...field.Expr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Distinct(cols...))
}
func (a adminRolePermissionLinkDo) Omit(cols ...field.Expr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Omit(cols...))
}
func (a adminRolePermissionLinkDo) Join(table schema.Tabler, on ...field.Expr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Join(table, on...))
}
func (a adminRolePermissionLinkDo) LeftJoin(table schema.Tabler, on ...field.Expr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.LeftJoin(table, on...))
}
func (a adminRolePermissionLinkDo) RightJoin(table schema.Tabler, on ...field.Expr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.RightJoin(table, on...))
}
func (a adminRolePermissionLinkDo) Group(cols ...field.Expr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Group(cols...))
}
func (a adminRolePermissionLinkDo) Having(conds ...gen.Condition) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Having(conds...))
}
func (a adminRolePermissionLinkDo) Limit(limit int) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Limit(limit))
}
func (a adminRolePermissionLinkDo) Offset(offset int) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Offset(offset))
}
func (a adminRolePermissionLinkDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Scopes(funcs...))
}
func (a adminRolePermissionLinkDo) Unscoped() *adminRolePermissionLinkDo {
return a.withDO(a.DO.Unscoped())
}
func (a adminRolePermissionLinkDo) Create(values ...*models.AdminRolePermissionLink) error {
if len(values) == 0 {
return nil
}
return a.DO.Create(values)
}
func (a adminRolePermissionLinkDo) CreateInBatches(values []*models.AdminRolePermissionLink, batchSize int) error {
return a.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (a adminRolePermissionLinkDo) Save(values ...*models.AdminRolePermissionLink) error {
if len(values) == 0 {
return nil
}
return a.DO.Save(values)
}
func (a adminRolePermissionLinkDo) First() (*models.AdminRolePermissionLink, error) {
if result, err := a.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.AdminRolePermissionLink), nil
}
}
func (a adminRolePermissionLinkDo) Take() (*models.AdminRolePermissionLink, error) {
if result, err := a.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.AdminRolePermissionLink), nil
}
}
func (a adminRolePermissionLinkDo) Last() (*models.AdminRolePermissionLink, error) {
if result, err := a.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.AdminRolePermissionLink), nil
}
}
func (a adminRolePermissionLinkDo) Find() ([]*models.AdminRolePermissionLink, error) {
result, err := a.DO.Find()
return result.([]*models.AdminRolePermissionLink), err
}
func (a adminRolePermissionLinkDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.AdminRolePermissionLink, err error) {
buf := make([]*models.AdminRolePermissionLink, 0, batchSize)
err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (a adminRolePermissionLinkDo) FindInBatches(result *[]*models.AdminRolePermissionLink, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return a.DO.FindInBatches(result, batchSize, fc)
}
func (a adminRolePermissionLinkDo) Attrs(attrs ...field.AssignExpr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Attrs(attrs...))
}
func (a adminRolePermissionLinkDo) Assign(attrs ...field.AssignExpr) *adminRolePermissionLinkDo {
return a.withDO(a.DO.Assign(attrs...))
}
func (a adminRolePermissionLinkDo) Joins(fields ...field.RelationField) *adminRolePermissionLinkDo {
for _, _f := range fields {
a = *a.withDO(a.DO.Joins(_f))
}
return &a
}
func (a adminRolePermissionLinkDo) Preload(fields ...field.RelationField) *adminRolePermissionLinkDo {
for _, _f := range fields {
a = *a.withDO(a.DO.Preload(_f))
}
return &a
}
func (a adminRolePermissionLinkDo) FirstOrInit() (*models.AdminRolePermissionLink, error) {
if result, err := a.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.AdminRolePermissionLink), nil
}
}
func (a adminRolePermissionLinkDo) FirstOrCreate() (*models.AdminRolePermissionLink, error) {
if result, err := a.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.AdminRolePermissionLink), nil
}
}
func (a adminRolePermissionLinkDo) FindByPage(offset int, limit int) (result []*models.AdminRolePermissionLink, count int64, err error) {
result, err = a.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = a.Offset(-1).Limit(-1).Count()
return
}
func (a adminRolePermissionLinkDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = a.Count()
if err != nil {
return
}
err = a.Offset(offset).Limit(limit).Scan(result)
return
}
func (a adminRolePermissionLinkDo) Scan(result interface{}) (err error) {
return a.DO.Scan(result)
}
func (a adminRolePermissionLinkDo) Delete(models ...*models.AdminRolePermissionLink) (result gen.ResultInfo, err error) {
return a.DO.Delete(models)
}
func (a *adminRolePermissionLinkDo) withDO(do gen.Dao) *adminRolePermissionLinkDo {
a.DO = *do.(*gen.DO)
return a
}

46
web/queries/announcement.gen.go
View File

@@ -28,15 +28,15 @@ func newAnnouncement(db *gorm.DB, opts ...gen.DOOption) announcement {
tableName := _announcement.announcementDo.TableName()
_announcement.ALL = field.NewAsterisk(tableName)
_announcement.ID = field.NewInt32(tableName, "id")
_announcement.CreatedAt = field.NewTime(tableName, "created_at")
_announcement.UpdatedAt = field.NewTime(tableName, "updated_at")
_announcement.DeletedAt = field.NewField(tableName, "deleted_at")
_announcement.Title = field.NewString(tableName, "title")
_announcement.Content = field.NewString(tableName, "content")
_announcement.Type = field.NewInt32(tableName, "type")
_announcement.Type = field.NewInt(tableName, "type")
_announcement.Pin = field.NewBool(tableName, "pin")
_announcement.Status = field.NewInt32(tableName, "status")
_announcement.Status = field.NewInt(tableName, "status")
_announcement.Sort = field.NewInt32(tableName, "sort")
_announcement.CreatedAt = field.NewField(tableName, "created_at")
_announcement.UpdatedAt = field.NewField(tableName, "updated_at")
_announcement.DeletedAt = field.NewField(tableName, "deleted_at")
_announcement.fillFieldMap()
@@ -47,16 +47,16 @@ type announcement struct {
announcementDo
ALL field.Asterisk
ID field.Int32 // 公告ID
Title field.String // 公告标题
Content field.String // 公告内容
Type field.Int32 // 公告类型：1-普通公告
Pin field.Bool // 是否置顶
Status field.Int32 // 公告状态：0-禁用，1-正常
Sort field.Int32 // 公告排序
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Title field.String
Content field.String
Type field.Int
Pin field.Bool
Status field.Int
Sort field.Int32
fieldMap map[string]field.Expr
}
@@ -74,15 +74,15 @@ func (a announcement) As(alias string) *announcement {
func (a *announcement) updateTableName(table string) *announcement {
a.ALL = field.NewAsterisk(table)
a.ID = field.NewInt32(table, "id")
a.CreatedAt = field.NewTime(table, "created_at")
a.UpdatedAt = field.NewTime(table, "updated_at")
a.DeletedAt = field.NewField(table, "deleted_at")
a.Title = field.NewString(table, "title")
a.Content = field.NewString(table, "content")
a.Type = field.NewInt32(table, "type")
a.Type = field.NewInt(table, "type")
a.Pin = field.NewBool(table, "pin")
a.Status = field.NewInt32(table, "status")
a.Status = field.NewInt(table, "status")
a.Sort = field.NewInt32(table, "sort")
a.CreatedAt = field.NewField(table, "created_at")
a.UpdatedAt = field.NewField(table, "updated_at")
a.DeletedAt = field.NewField(table, "deleted_at")
a.fillFieldMap()
@@ -101,15 +101,15 @@ func (a *announcement) GetFieldByName(fieldName string) (field.OrderExpr, bool)
func (a *announcement) fillFieldMap() {
a.fieldMap = make(map[string]field.Expr, 10)
a.fieldMap["id"] = a.ID
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
a.fieldMap["deleted_at"] = a.DeletedAt
a.fieldMap["title"] = a.Title
a.fieldMap["content"] = a.Content
a.fieldMap["type"] = a.Type
a.fieldMap["pin"] = a.Pin
a.fieldMap["status"] = a.Status
a.fieldMap["sort"] = a.Sort
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
a.fieldMap["deleted_at"] = a.DeletedAt
}
func (a announcement) clone(db *gorm.DB) announcement {

341
web/queries/bill.gen.go
View File

@@ -28,33 +28,43 @@ func newBill(db *gorm.DB, opts ...gen.DOOption) bill {
tableName := _bill.billDo.TableName()
_bill.ALL = field.NewAsterisk(tableName)
_bill.ID = field.NewInt32(tableName, "id")
_bill.CreatedAt = field.NewTime(tableName, "created_at")
_bill.UpdatedAt = field.NewTime(tableName, "updated_at")
_bill.DeletedAt = field.NewField(tableName, "deleted_at")
_bill.UserID = field.NewInt32(tableName, "user_id")
_bill.TradeID = field.NewInt32(tableName, "trade_id")
_bill.ResourceID = field.NewInt32(tableName, "resource_id")
_bill.RefundID = field.NewInt32(tableName, "refund_id")
_bill.BillNo = field.NewString(tableName, "bill_no")
_bill.Info = field.NewString(tableName, "info")
_bill.Type = field.NewInt32(tableName, "type")
_bill.Type = field.NewInt(tableName, "type")
_bill.Amount = field.NewField(tableName, "amount")
_bill.CreatedAt = field.NewField(tableName, "created_at")
_bill.UpdatedAt = field.NewField(tableName, "updated_at")
_bill.DeletedAt = field.NewField(tableName, "deleted_at")
_bill.User = billBelongsToUser{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("User", "models.User"),
Admin: struct {
field.RelationField
}{
RelationField: field.NewRelation("User.Admin", "models.Admin"),
},
}
_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"),
User: struct {
field.RelationField
}{
RelationField: field.NewRelation("Resource.User", "models.User"),
},
Short: struct {
field.RelationField
}{
@@ -67,6 +77,12 @@ func newBill(db *gorm.DB, opts ...gen.DOOption) bill {
},
}
_bill.Refund = billBelongsToRefund{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Refund", "models.Refund"),
}
_bill.fillFieldMap()
return _bill
@@ -76,24 +92,26 @@ type bill struct {
billDo
ALL field.Asterisk
ID field.Int32 // 账单ID
UserID field.Int32 // 用户ID
TradeID field.Int32 // 订单ID
ResourceID field.Int32 // 套餐ID
RefundID field.Int32 // 退款ID
BillNo field.String // 易读账单号
Info field.String // 产品可读信息
Type field.Int32 // 账单类型：1-消费，2-退款，3-充值
Amount field.Field // 账单金额
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
Trade billBelongsToTrade
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
UserID field.Int32
TradeID field.Int32
ResourceID field.Int32
RefundID field.Int32
BillNo field.String
Info field.String
Type field.Int
Amount field.Field
User billBelongsToUser
Refund billBelongsToRefund
Trade billBelongsToTrade
Resource billBelongsToResource
Refund billBelongsToRefund
fieldMap map[string]field.Expr
}
@@ -110,17 +128,17 @@ func (b bill) As(alias string) *bill {
func (b *bill) updateTableName(table string) *bill {
b.ALL = field.NewAsterisk(table)
b.ID = field.NewInt32(table, "id")
b.CreatedAt = field.NewTime(table, "created_at")
b.UpdatedAt = field.NewTime(table, "updated_at")
b.DeletedAt = field.NewField(table, "deleted_at")
b.UserID = field.NewInt32(table, "user_id")
b.TradeID = field.NewInt32(table, "trade_id")
b.ResourceID = field.NewInt32(table, "resource_id")
b.RefundID = field.NewInt32(table, "refund_id")
b.BillNo = field.NewString(table, "bill_no")
b.Info = field.NewString(table, "info")
b.Type = field.NewInt32(table, "type")
b.Type = field.NewInt(table, "type")
b.Amount = field.NewField(table, "amount")
b.CreatedAt = field.NewField(table, "created_at")
b.UpdatedAt = field.NewField(table, "updated_at")
b.DeletedAt = field.NewField(table, "deleted_at")
b.fillFieldMap()
@@ -137,8 +155,11 @@ func (b *bill) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (b *bill) fillFieldMap() {
b.fieldMap = make(map[string]field.Expr, 15)
b.fieldMap = make(map[string]field.Expr, 16)
b.fieldMap["id"] = b.ID
b.fieldMap["created_at"] = b.CreatedAt
b.fieldMap["updated_at"] = b.UpdatedAt
b.fieldMap["deleted_at"] = b.DeletedAt
b.fieldMap["user_id"] = b.UserID
b.fieldMap["trade_id"] = b.TradeID
b.fieldMap["resource_id"] = b.ResourceID
@@ -147,31 +168,116 @@ func (b *bill) fillFieldMap() {
b.fieldMap["info"] = b.Info
b.fieldMap["type"] = b.Type
b.fieldMap["amount"] = b.Amount
b.fieldMap["created_at"] = b.CreatedAt
b.fieldMap["updated_at"] = b.UpdatedAt
b.fieldMap["deleted_at"] = b.DeletedAt
}
func (b bill) clone(db *gorm.DB) bill {
b.billDo.ReplaceConnPool(db.Statement.ConnPool)
b.User.db = db.Session(&gorm.Session{Initialized: true})
b.User.db.Statement.ConnPool = db.Statement.ConnPool
b.Trade.db = db.Session(&gorm.Session{Initialized: true})
b.Trade.db.Statement.ConnPool = db.Statement.ConnPool
b.Refund.db = db.Session(&gorm.Session{Initialized: true})
b.Refund.db.Statement.ConnPool = db.Statement.ConnPool
b.Resource.db = db.Session(&gorm.Session{Initialized: true})
b.Resource.db.Statement.ConnPool = db.Statement.ConnPool
b.Refund.db = db.Session(&gorm.Session{Initialized: true})
b.Refund.db.Statement.ConnPool = db.Statement.ConnPool
return b
}
func (b bill) replaceDB(db *gorm.DB) bill {
b.billDo.ReplaceDB(db)
b.User.db = db.Session(&gorm.Session{})
b.Trade.db = db.Session(&gorm.Session{})
b.Refund.db = db.Session(&gorm.Session{})
b.Resource.db = db.Session(&gorm.Session{})
b.Refund.db = db.Session(&gorm.Session{})
return b
}
type billBelongsToUser struct {
db *gorm.DB
field.RelationField
Admin struct {
field.RelationField
}
}
func (a billBelongsToUser) Where(conds ...field.Expr) *billBelongsToUser {
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 billBelongsToUser) WithContext(ctx context.Context) *billBelongsToUser {
a.db = a.db.WithContext(ctx)
return &a
}
func (a billBelongsToUser) Session(session *gorm.Session) *billBelongsToUser {
a.db = a.db.Session(session)
return &a
}
func (a billBelongsToUser) Model(m *models.Bill) *billBelongsToUserTx {
return &billBelongsToUserTx{a.db.Model(m).Association(a.Name())}
}
func (a billBelongsToUser) Unscoped() *billBelongsToUser {
a.db = a.db.Unscoped()
return &a
}
type billBelongsToUserTx struct{ tx *gorm.Association }
func (a billBelongsToUserTx) Find() (result *models.User, err error) {
return result, a.tx.Find(&result)
}
func (a billBelongsToUserTx) Append(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a billBelongsToUserTx) Replace(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a billBelongsToUserTx) Delete(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a billBelongsToUserTx) Clear() error {
return a.tx.Clear()
}
func (a billBelongsToUserTx) Count() int64 {
return a.tx.Count()
}
func (a billBelongsToUserTx) Unscoped() *billBelongsToUserTx {
a.tx = a.tx.Unscoped()
return &a
}
type billBelongsToTrade struct {
db *gorm.DB
@@ -253,92 +359,14 @@ func (a billBelongsToTradeTx) Unscoped() *billBelongsToTradeTx {
return &a
}
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())}
}
func (a billBelongsToRefund) Unscoped() *billBelongsToRefund {
a.db = a.db.Unscoped()
return &a
}
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()
}
func (a billBelongsToRefundTx) Unscoped() *billBelongsToRefundTx {
a.tx = a.tx.Unscoped()
return &a
}
type billBelongsToResource struct {
db *gorm.DB
field.RelationField
User struct {
field.RelationField
}
Short struct {
field.RelationField
}
@@ -422,6 +450,87 @@ func (a billBelongsToResourceTx) Unscoped() *billBelongsToResourceTx {
return &a
}
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())}
}
func (a billBelongsToRefund) Unscoped() *billBelongsToRefund {
a.db = a.db.Unscoped()
return &a
}
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()
}
func (a billBelongsToRefundTx) Unscoped() *billBelongsToRefundTx {
a.tx = a.tx.Unscoped()
return &a
}
type billDo struct{ gen.DO }
func (b billDo) Debug() *billDo {

572
web/queries/channel.gen.go
View File

@@ -28,23 +28,103 @@ func newChannel(db *gorm.DB, opts ...gen.DOOption) channel {
tableName := _channel.channelDo.TableName()
_channel.ALL = field.NewAsterisk(tableName)
_channel.ID = field.NewInt32(tableName, "id")
_channel.CreatedAt = field.NewTime(tableName, "created_at")
_channel.UpdatedAt = field.NewTime(tableName, "updated_at")
_channel.DeletedAt = field.NewField(tableName, "deleted_at")
_channel.UserID = field.NewInt32(tableName, "user_id")
_channel.ProxyID = field.NewInt32(tableName, "proxy_id")
_channel.EdgeID = field.NewInt32(tableName, "edge_id")
_channel.ResourceID = field.NewInt32(tableName, "resource_id")
_channel.ProxyHost = field.NewString(tableName, "proxy_host")
_channel.ProxyPort = field.NewInt32(tableName, "proxy_port")
_channel.EdgeHost = field.NewString(tableName, "edge_host")
_channel.Protocol = field.NewInt32(tableName, "protocol")
_channel.AuthIP = field.NewBool(tableName, "auth_ip")
_channel.Whitelists = field.NewString(tableName, "whitelists")
_channel.AuthPass = field.NewBool(tableName, "auth_pass")
_channel.ProxyID = field.NewInt32(tableName, "proxy_id")
_channel.BatchNo = field.NewString(tableName, "batch_no")
_channel.Port = field.NewUint16(tableName, "port")
_channel.EdgeID = field.NewInt32(tableName, "edge_id")
_channel.FilterISP = field.NewInt(tableName, "filter_isp")
_channel.FilterProv = field.NewString(tableName, "filter_prov")
_channel.FilterCity = field.NewString(tableName, "filter_city")
_channel.IP = field.NewField(tableName, "ip")
_channel.Whitelists = field.NewField(tableName, "whitelists")
_channel.Username = field.NewString(tableName, "username")
_channel.Password = field.NewString(tableName, "password")
_channel.Expiration = field.NewField(tableName, "expiration")
_channel.CreatedAt = field.NewField(tableName, "created_at")
_channel.UpdatedAt = field.NewField(tableName, "updated_at")
_channel.DeletedAt = field.NewField(tableName, "deleted_at")
_channel.ExpiredAt = field.NewTime(tableName, "expired_at")
_channel.User = channelBelongsToUser{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("User", "models.User"),
Admin: struct {
field.RelationField
}{
RelationField: field.NewRelation("User.Admin", "models.Admin"),
},
}
_channel.Resource = channelBelongsToResource{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Resource", "models.Resource"),
User: struct {
field.RelationField
}{
RelationField: field.NewRelation("Resource.User", "models.User"),
},
Short: struct {
field.RelationField
}{
RelationField: field.NewRelation("Resource.Short", "models.ResourceShort"),
},
Long: struct {
field.RelationField
}{
RelationField: field.NewRelation("Resource.Long", "models.ResourceLong"),
},
}
_channel.Proxy = channelBelongsToProxy{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Proxy", "models.Proxy"),
Channels: struct {
field.RelationField
User struct {
field.RelationField
}
Resource struct {
field.RelationField
}
Proxy struct {
field.RelationField
}
Edge struct {
field.RelationField
}
}{
RelationField: field.NewRelation("Proxy.Channels", "models.Channel"),
User: struct {
field.RelationField
}{
RelationField: field.NewRelation("Proxy.Channels.User", "models.User"),
},
Resource: struct {
field.RelationField
}{
RelationField: field.NewRelation("Proxy.Channels.Resource", "models.Resource"),
},
Proxy: struct {
field.RelationField
}{
RelationField: field.NewRelation("Proxy.Channels.Proxy", "models.Proxy"),
},
Edge: struct {
field.RelationField
}{
RelationField: field.NewRelation("Proxy.Channels.Edge", "models.Edge"),
},
},
}
_channel.Edge = channelBelongsToEdge{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Edge", "models.Edge"),
}
_channel.fillFieldMap()
@@ -55,24 +135,31 @@ type channel struct {
channelDo
ALL field.Asterisk
ID field.Int32 // 通道ID
UserID field.Int32 // 用户ID
ProxyID field.Int32 // 代理ID
EdgeID field.Int32 // 节点ID
ResourceID field.Int32 // 套餐ID
ProxyHost field.String // 代理地址
ProxyPort field.Int32 // 转发端口
EdgeHost field.String // 节点地址
Protocol field.Int32 // 协议类型：1-http，2-https，3-socks5
AuthIP field.Bool // IP认证
Whitelists field.String // IP白名单，逗号分隔
AuthPass field.Bool // 密码认证
Username field.String // 用户名
Password field.String // 密码
Expiration field.Field // 过期时间
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
UserID field.Int32
ResourceID field.Int32
ProxyID field.Int32
BatchNo field.String
Port field.Uint16
EdgeID field.Int32
FilterISP field.Int
FilterProv field.String
FilterCity field.String
IP field.Field
Whitelists field.Field
Username field.String
Password field.String
ExpiredAt field.Time
User channelBelongsToUser
Resource channelBelongsToResource
Proxy channelBelongsToProxy
Edge channelBelongsToEdge
fieldMap map[string]field.Expr
}
@@ -90,23 +177,23 @@ func (c channel) As(alias string) *channel {
func (c *channel) updateTableName(table string) *channel {
c.ALL = field.NewAsterisk(table)
c.ID = field.NewInt32(table, "id")
c.CreatedAt = field.NewTime(table, "created_at")
c.UpdatedAt = field.NewTime(table, "updated_at")
c.DeletedAt = field.NewField(table, "deleted_at")
c.UserID = field.NewInt32(table, "user_id")
c.ProxyID = field.NewInt32(table, "proxy_id")
c.EdgeID = field.NewInt32(table, "edge_id")
c.ResourceID = field.NewInt32(table, "resource_id")
c.ProxyHost = field.NewString(table, "proxy_host")
c.ProxyPort = field.NewInt32(table, "proxy_port")
c.EdgeHost = field.NewString(table, "edge_host")
c.Protocol = field.NewInt32(table, "protocol")
c.AuthIP = field.NewBool(table, "auth_ip")
c.Whitelists = field.NewString(table, "whitelists")
c.AuthPass = field.NewBool(table, "auth_pass")
c.ProxyID = field.NewInt32(table, "proxy_id")
c.BatchNo = field.NewString(table, "batch_no")
c.Port = field.NewUint16(table, "port")
c.EdgeID = field.NewInt32(table, "edge_id")
c.FilterISP = field.NewInt(table, "filter_isp")
c.FilterProv = field.NewString(table, "filter_prov")
c.FilterCity = field.NewString(table, "filter_city")
c.IP = field.NewField(table, "ip")
c.Whitelists = field.NewField(table, "whitelists")
c.Username = field.NewString(table, "username")
c.Password = field.NewString(table, "password")
c.Expiration = field.NewField(table, "expiration")
c.CreatedAt = field.NewField(table, "created_at")
c.UpdatedAt = field.NewField(table, "updated_at")
c.DeletedAt = field.NewField(table, "deleted_at")
c.ExpiredAt = field.NewTime(table, "expired_at")
c.fillFieldMap()
@@ -123,37 +210,404 @@ func (c *channel) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (c *channel) fillFieldMap() {
c.fieldMap = make(map[string]field.Expr, 18)
c.fieldMap = make(map[string]field.Expr, 22)
c.fieldMap["id"] = c.ID
c.fieldMap["user_id"] = c.UserID
c.fieldMap["proxy_id"] = c.ProxyID
c.fieldMap["edge_id"] = c.EdgeID
c.fieldMap["resource_id"] = c.ResourceID
c.fieldMap["proxy_host"] = c.ProxyHost
c.fieldMap["proxy_port"] = c.ProxyPort
c.fieldMap["edge_host"] = c.EdgeHost
c.fieldMap["protocol"] = c.Protocol
c.fieldMap["auth_ip"] = c.AuthIP
c.fieldMap["whitelists"] = c.Whitelists
c.fieldMap["auth_pass"] = c.AuthPass
c.fieldMap["username"] = c.Username
c.fieldMap["password"] = c.Password
c.fieldMap["expiration"] = c.Expiration
c.fieldMap["created_at"] = c.CreatedAt
c.fieldMap["updated_at"] = c.UpdatedAt
c.fieldMap["deleted_at"] = c.DeletedAt
c.fieldMap["user_id"] = c.UserID
c.fieldMap["resource_id"] = c.ResourceID
c.fieldMap["proxy_id"] = c.ProxyID
c.fieldMap["batch_no"] = c.BatchNo
c.fieldMap["port"] = c.Port
c.fieldMap["edge_id"] = c.EdgeID
c.fieldMap["filter_isp"] = c.FilterISP
c.fieldMap["filter_prov"] = c.FilterProv
c.fieldMap["filter_city"] = c.FilterCity
c.fieldMap["ip"] = c.IP
c.fieldMap["whitelists"] = c.Whitelists
c.fieldMap["username"] = c.Username
c.fieldMap["password"] = c.Password
c.fieldMap["expired_at"] = c.ExpiredAt
}
func (c channel) clone(db *gorm.DB) channel {
c.channelDo.ReplaceConnPool(db.Statement.ConnPool)
c.User.db = db.Session(&gorm.Session{Initialized: true})
c.User.db.Statement.ConnPool = db.Statement.ConnPool
c.Resource.db = db.Session(&gorm.Session{Initialized: true})
c.Resource.db.Statement.ConnPool = db.Statement.ConnPool
c.Proxy.db = db.Session(&gorm.Session{Initialized: true})
c.Proxy.db.Statement.ConnPool = db.Statement.ConnPool
c.Edge.db = db.Session(&gorm.Session{Initialized: true})
c.Edge.db.Statement.ConnPool = db.Statement.ConnPool
return c
}
func (c channel) replaceDB(db *gorm.DB) channel {
c.channelDo.ReplaceDB(db)
c.User.db = db.Session(&gorm.Session{})
c.Resource.db = db.Session(&gorm.Session{})
c.Proxy.db = db.Session(&gorm.Session{})
c.Edge.db = db.Session(&gorm.Session{})
return c
}
type channelBelongsToUser struct {
db *gorm.DB
field.RelationField
Admin struct {
field.RelationField
}
}
func (a channelBelongsToUser) Where(conds ...field.Expr) *channelBelongsToUser {
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 channelBelongsToUser) WithContext(ctx context.Context) *channelBelongsToUser {
a.db = a.db.WithContext(ctx)
return &a
}
func (a channelBelongsToUser) Session(session *gorm.Session) *channelBelongsToUser {
a.db = a.db.Session(session)
return &a
}
func (a channelBelongsToUser) Model(m *models.Channel) *channelBelongsToUserTx {
return &channelBelongsToUserTx{a.db.Model(m).Association(a.Name())}
}
func (a channelBelongsToUser) Unscoped() *channelBelongsToUser {
a.db = a.db.Unscoped()
return &a
}
type channelBelongsToUserTx struct{ tx *gorm.Association }
func (a channelBelongsToUserTx) Find() (result *models.User, err error) {
return result, a.tx.Find(&result)
}
func (a channelBelongsToUserTx) Append(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a channelBelongsToUserTx) Replace(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a channelBelongsToUserTx) Delete(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a channelBelongsToUserTx) Clear() error {
return a.tx.Clear()
}
func (a channelBelongsToUserTx) Count() int64 {
return a.tx.Count()
}
func (a channelBelongsToUserTx) Unscoped() *channelBelongsToUserTx {
a.tx = a.tx.Unscoped()
return &a
}
type channelBelongsToResource struct {
db *gorm.DB
field.RelationField
User struct {
field.RelationField
}
Short struct {
field.RelationField
}
Long struct {
field.RelationField
}
}
func (a channelBelongsToResource) Where(conds ...field.Expr) *channelBelongsToResource {
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 channelBelongsToResource) WithContext(ctx context.Context) *channelBelongsToResource {
a.db = a.db.WithContext(ctx)
return &a
}
func (a channelBelongsToResource) Session(session *gorm.Session) *channelBelongsToResource {
a.db = a.db.Session(session)
return &a
}
func (a channelBelongsToResource) Model(m *models.Channel) *channelBelongsToResourceTx {
return &channelBelongsToResourceTx{a.db.Model(m).Association(a.Name())}
}
func (a channelBelongsToResource) Unscoped() *channelBelongsToResource {
a.db = a.db.Unscoped()
return &a
}
type channelBelongsToResourceTx struct{ tx *gorm.Association }
func (a channelBelongsToResourceTx) Find() (result *models.Resource, err error) {
return result, a.tx.Find(&result)
}
func (a channelBelongsToResourceTx) 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 channelBelongsToResourceTx) 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 channelBelongsToResourceTx) 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 channelBelongsToResourceTx) Clear() error {
return a.tx.Clear()
}
func (a channelBelongsToResourceTx) Count() int64 {
return a.tx.Count()
}
func (a channelBelongsToResourceTx) Unscoped() *channelBelongsToResourceTx {
a.tx = a.tx.Unscoped()
return &a
}
type channelBelongsToProxy struct {
db *gorm.DB
field.RelationField
Channels struct {
field.RelationField
User struct {
field.RelationField
}
Resource struct {
field.RelationField
}
Proxy struct {
field.RelationField
}
Edge struct {
field.RelationField
}
}
}
func (a channelBelongsToProxy) Where(conds ...field.Expr) *channelBelongsToProxy {
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 channelBelongsToProxy) WithContext(ctx context.Context) *channelBelongsToProxy {
a.db = a.db.WithContext(ctx)
return &a
}
func (a channelBelongsToProxy) Session(session *gorm.Session) *channelBelongsToProxy {
a.db = a.db.Session(session)
return &a
}
func (a channelBelongsToProxy) Model(m *models.Channel) *channelBelongsToProxyTx {
return &channelBelongsToProxyTx{a.db.Model(m).Association(a.Name())}
}
func (a channelBelongsToProxy) Unscoped() *channelBelongsToProxy {
a.db = a.db.Unscoped()
return &a
}
type channelBelongsToProxyTx struct{ tx *gorm.Association }
func (a channelBelongsToProxyTx) Find() (result *models.Proxy, err error) {
return result, a.tx.Find(&result)
}
func (a channelBelongsToProxyTx) Append(values ...*models.Proxy) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a channelBelongsToProxyTx) Replace(values ...*models.Proxy) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a channelBelongsToProxyTx) Delete(values ...*models.Proxy) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a channelBelongsToProxyTx) Clear() error {
return a.tx.Clear()
}
func (a channelBelongsToProxyTx) Count() int64 {
return a.tx.Count()
}
func (a channelBelongsToProxyTx) Unscoped() *channelBelongsToProxyTx {
a.tx = a.tx.Unscoped()
return &a
}
type channelBelongsToEdge struct {
db *gorm.DB
field.RelationField
}
func (a channelBelongsToEdge) Where(conds ...field.Expr) *channelBelongsToEdge {
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 channelBelongsToEdge) WithContext(ctx context.Context) *channelBelongsToEdge {
a.db = a.db.WithContext(ctx)
return &a
}
func (a channelBelongsToEdge) Session(session *gorm.Session) *channelBelongsToEdge {
a.db = a.db.Session(session)
return &a
}
func (a channelBelongsToEdge) Model(m *models.Channel) *channelBelongsToEdgeTx {
return &channelBelongsToEdgeTx{a.db.Model(m).Association(a.Name())}
}
func (a channelBelongsToEdge) Unscoped() *channelBelongsToEdge {
a.db = a.db.Unscoped()
return &a
}
type channelBelongsToEdgeTx struct{ tx *gorm.Association }
func (a channelBelongsToEdgeTx) Find() (result *models.Edge, err error) {
return result, a.tx.Find(&result)
}
func (a channelBelongsToEdgeTx) Append(values ...*models.Edge) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a channelBelongsToEdgeTx) Replace(values ...*models.Edge) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a channelBelongsToEdgeTx) Delete(values ...*models.Edge) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a channelBelongsToEdgeTx) Clear() error {
return a.tx.Clear()
}
func (a channelBelongsToEdgeTx) Count() int64 {
return a.tx.Count()
}
func (a channelBelongsToEdgeTx) Unscoped() *channelBelongsToEdgeTx {
a.tx = a.tx.Unscoped()
return &a
}
type channelDo struct{ gen.DO }
func (c channelDo) Debug() *channelDo {

54
web/queries/client.gen.go
View File

@@ -28,17 +28,17 @@ func newClient(db *gorm.DB, opts ...gen.DOOption) client {
tableName := _client.clientDo.TableName()
_client.ALL = field.NewAsterisk(tableName)
_client.ID = field.NewInt32(tableName, "id")
_client.CreatedAt = field.NewTime(tableName, "created_at")
_client.UpdatedAt = field.NewTime(tableName, "updated_at")
_client.DeletedAt = field.NewField(tableName, "deleted_at")
_client.ClientID = field.NewString(tableName, "client_id")
_client.ClientSecret = field.NewString(tableName, "client_secret")
_client.RedirectURI = field.NewString(tableName, "redirect_uri")
_client.Spec = field.NewInt32(tableName, "spec")
_client.Spec = field.NewInt(tableName, "spec")
_client.Name = field.NewString(tableName, "name")
_client.Icon = field.NewString(tableName, "icon")
_client.Status = field.NewInt32(tableName, "status")
_client.Type = field.NewInt32(tableName, "type")
_client.CreatedAt = field.NewField(tableName, "created_at")
_client.UpdatedAt = field.NewField(tableName, "updated_at")
_client.DeletedAt = field.NewField(tableName, "deleted_at")
_client.Status = field.NewInt(tableName, "status")
_client.Type = field.NewInt(tableName, "type")
_client.fillFieldMap()
@@ -49,18 +49,18 @@ type client struct {
clientDo
ALL field.Asterisk
ID field.Int32 // 客户端ID
ClientID field.String // OAuth2客户端标识符
ClientSecret field.String // OAuth2客户端密钥
RedirectURI field.String // OAuth2 重定向URI
Spec field.Int32 // 安全规范：1-native，2-browser，3-web，4-api
Name field.String // 名称
Icon field.String // 图标URL
Status field.Int32 // 状态：0-禁用，1-正常
Type field.Int32 // 类型：0-普通，1-官方
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
ClientID field.String
ClientSecret field.String
RedirectURI field.String
Spec field.Int
Name field.String
Icon field.String
Status field.Int
Type field.Int
fieldMap map[string]field.Expr
}
@@ -78,17 +78,17 @@ func (c client) As(alias string) *client {
func (c *client) updateTableName(table string) *client {
c.ALL = field.NewAsterisk(table)
c.ID = field.NewInt32(table, "id")
c.CreatedAt = field.NewTime(table, "created_at")
c.UpdatedAt = field.NewTime(table, "updated_at")
c.DeletedAt = field.NewField(table, "deleted_at")
c.ClientID = field.NewString(table, "client_id")
c.ClientSecret = field.NewString(table, "client_secret")
c.RedirectURI = field.NewString(table, "redirect_uri")
c.Spec = field.NewInt32(table, "spec")
c.Spec = field.NewInt(table, "spec")
c.Name = field.NewString(table, "name")
c.Icon = field.NewString(table, "icon")
c.Status = field.NewInt32(table, "status")
c.Type = field.NewInt32(table, "type")
c.CreatedAt = field.NewField(table, "created_at")
c.UpdatedAt = field.NewField(table, "updated_at")
c.DeletedAt = field.NewField(table, "deleted_at")
c.Status = field.NewInt(table, "status")
c.Type = field.NewInt(table, "type")
c.fillFieldMap()
@@ -107,6 +107,9 @@ func (c *client) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (c *client) fillFieldMap() {
c.fieldMap = make(map[string]field.Expr, 12)
c.fieldMap["id"] = c.ID
c.fieldMap["created_at"] = c.CreatedAt
c.fieldMap["updated_at"] = c.UpdatedAt
c.fieldMap["deleted_at"] = c.DeletedAt
c.fieldMap["client_id"] = c.ClientID
c.fieldMap["client_secret"] = c.ClientSecret
c.fieldMap["redirect_uri"] = c.RedirectURI
@@ -115,9 +118,6 @@ func (c *client) fillFieldMap() {
c.fieldMap["icon"] = c.Icon
c.fieldMap["status"] = c.Status
c.fieldMap["type"] = c.Type
c.fieldMap["created_at"] = c.CreatedAt
c.fieldMap["updated_at"] = c.UpdatedAt
c.fieldMap["deleted_at"] = c.DeletedAt
}
func (c client) clone(db *gorm.DB) client {

339
web/queries/client_permission_link.gen.go
View File

@@ -1,339 +0,0 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newClientPermissionLink(db *gorm.DB, opts ...gen.DOOption) clientPermissionLink {
_clientPermissionLink := clientPermissionLink{}
_clientPermissionLink.clientPermissionLinkDo.UseDB(db, opts...)
_clientPermissionLink.clientPermissionLinkDo.UseModel(&models.ClientPermissionLink{})
tableName := _clientPermissionLink.clientPermissionLinkDo.TableName()
_clientPermissionLink.ALL = field.NewAsterisk(tableName)
_clientPermissionLink.ID = field.NewInt32(tableName, "id")
_clientPermissionLink.ClientID = field.NewInt32(tableName, "client_id")
_clientPermissionLink.PermissionID = field.NewInt32(tableName, "permission_id")
_clientPermissionLink.CreatedAt = field.NewField(tableName, "created_at")
_clientPermissionLink.UpdatedAt = field.NewField(tableName, "updated_at")
_clientPermissionLink.DeletedAt = field.NewField(tableName, "deleted_at")
_clientPermissionLink.fillFieldMap()
return _clientPermissionLink
}
type clientPermissionLink struct {
clientPermissionLinkDo
ALL field.Asterisk
ID field.Int32 // 关联ID
ClientID field.Int32 // 客户端ID
PermissionID field.Int32 // 权限ID
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (c clientPermissionLink) Table(newTableName string) *clientPermissionLink {
c.clientPermissionLinkDo.UseTable(newTableName)
return c.updateTableName(newTableName)
}
func (c clientPermissionLink) As(alias string) *clientPermissionLink {
c.clientPermissionLinkDo.DO = *(c.clientPermissionLinkDo.As(alias).(*gen.DO))
return c.updateTableName(alias)
}
func (c *clientPermissionLink) updateTableName(table string) *clientPermissionLink {
c.ALL = field.NewAsterisk(table)
c.ID = field.NewInt32(table, "id")
c.ClientID = field.NewInt32(table, "client_id")
c.PermissionID = field.NewInt32(table, "permission_id")
c.CreatedAt = field.NewField(table, "created_at")
c.UpdatedAt = field.NewField(table, "updated_at")
c.DeletedAt = field.NewField(table, "deleted_at")
c.fillFieldMap()
return c
}
func (c *clientPermissionLink) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := c.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (c *clientPermissionLink) fillFieldMap() {
c.fieldMap = make(map[string]field.Expr, 6)
c.fieldMap["id"] = c.ID
c.fieldMap["client_id"] = c.ClientID
c.fieldMap["permission_id"] = c.PermissionID
c.fieldMap["created_at"] = c.CreatedAt
c.fieldMap["updated_at"] = c.UpdatedAt
c.fieldMap["deleted_at"] = c.DeletedAt
}
func (c clientPermissionLink) clone(db *gorm.DB) clientPermissionLink {
c.clientPermissionLinkDo.ReplaceConnPool(db.Statement.ConnPool)
return c
}
func (c clientPermissionLink) replaceDB(db *gorm.DB) clientPermissionLink {
c.clientPermissionLinkDo.ReplaceDB(db)
return c
}
type clientPermissionLinkDo struct{ gen.DO }
func (c clientPermissionLinkDo) Debug() *clientPermissionLinkDo {
return c.withDO(c.DO.Debug())
}
func (c clientPermissionLinkDo) WithContext(ctx context.Context) *clientPermissionLinkDo {
return c.withDO(c.DO.WithContext(ctx))
}
func (c clientPermissionLinkDo) ReadDB() *clientPermissionLinkDo {
return c.Clauses(dbresolver.Read)
}
func (c clientPermissionLinkDo) WriteDB() *clientPermissionLinkDo {
return c.Clauses(dbresolver.Write)
}
func (c clientPermissionLinkDo) Session(config *gorm.Session) *clientPermissionLinkDo {
return c.withDO(c.DO.Session(config))
}
func (c clientPermissionLinkDo) Clauses(conds ...clause.Expression) *clientPermissionLinkDo {
return c.withDO(c.DO.Clauses(conds...))
}
func (c clientPermissionLinkDo) Returning(value interface{}, columns ...string) *clientPermissionLinkDo {
return c.withDO(c.DO.Returning(value, columns...))
}
func (c clientPermissionLinkDo) Not(conds ...gen.Condition) *clientPermissionLinkDo {
return c.withDO(c.DO.Not(conds...))
}
func (c clientPermissionLinkDo) Or(conds ...gen.Condition) *clientPermissionLinkDo {
return c.withDO(c.DO.Or(conds...))
}
func (c clientPermissionLinkDo) Select(conds ...field.Expr) *clientPermissionLinkDo {
return c.withDO(c.DO.Select(conds...))
}
func (c clientPermissionLinkDo) Where(conds ...gen.Condition) *clientPermissionLinkDo {
return c.withDO(c.DO.Where(conds...))
}
func (c clientPermissionLinkDo) Order(conds ...field.Expr) *clientPermissionLinkDo {
return c.withDO(c.DO.Order(conds...))
}
func (c clientPermissionLinkDo) Distinct(cols ...field.Expr) *clientPermissionLinkDo {
return c.withDO(c.DO.Distinct(cols...))
}
func (c clientPermissionLinkDo) Omit(cols ...field.Expr) *clientPermissionLinkDo {
return c.withDO(c.DO.Omit(cols...))
}
func (c clientPermissionLinkDo) Join(table schema.Tabler, on ...field.Expr) *clientPermissionLinkDo {
return c.withDO(c.DO.Join(table, on...))
}
func (c clientPermissionLinkDo) LeftJoin(table schema.Tabler, on ...field.Expr) *clientPermissionLinkDo {
return c.withDO(c.DO.LeftJoin(table, on...))
}
func (c clientPermissionLinkDo) RightJoin(table schema.Tabler, on ...field.Expr) *clientPermissionLinkDo {
return c.withDO(c.DO.RightJoin(table, on...))
}
func (c clientPermissionLinkDo) Group(cols ...field.Expr) *clientPermissionLinkDo {
return c.withDO(c.DO.Group(cols...))
}
func (c clientPermissionLinkDo) Having(conds ...gen.Condition) *clientPermissionLinkDo {
return c.withDO(c.DO.Having(conds...))
}
func (c clientPermissionLinkDo) Limit(limit int) *clientPermissionLinkDo {
return c.withDO(c.DO.Limit(limit))
}
func (c clientPermissionLinkDo) Offset(offset int) *clientPermissionLinkDo {
return c.withDO(c.DO.Offset(offset))
}
func (c clientPermissionLinkDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *clientPermissionLinkDo {
return c.withDO(c.DO.Scopes(funcs...))
}
func (c clientPermissionLinkDo) Unscoped() *clientPermissionLinkDo {
return c.withDO(c.DO.Unscoped())
}
func (c clientPermissionLinkDo) Create(values ...*models.ClientPermissionLink) error {
if len(values) == 0 {
return nil
}
return c.DO.Create(values)
}
func (c clientPermissionLinkDo) CreateInBatches(values []*models.ClientPermissionLink, batchSize int) error {
return c.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (c clientPermissionLinkDo) Save(values ...*models.ClientPermissionLink) error {
if len(values) == 0 {
return nil
}
return c.DO.Save(values)
}
func (c clientPermissionLinkDo) First() (*models.ClientPermissionLink, error) {
if result, err := c.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.ClientPermissionLink), nil
}
}
func (c clientPermissionLinkDo) Take() (*models.ClientPermissionLink, error) {
if result, err := c.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.ClientPermissionLink), nil
}
}
func (c clientPermissionLinkDo) Last() (*models.ClientPermissionLink, error) {
if result, err := c.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.ClientPermissionLink), nil
}
}
func (c clientPermissionLinkDo) Find() ([]*models.ClientPermissionLink, error) {
result, err := c.DO.Find()
return result.([]*models.ClientPermissionLink), err
}
func (c clientPermissionLinkDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.ClientPermissionLink, err error) {
buf := make([]*models.ClientPermissionLink, 0, batchSize)
err = c.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (c clientPermissionLinkDo) FindInBatches(result *[]*models.ClientPermissionLink, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return c.DO.FindInBatches(result, batchSize, fc)
}
func (c clientPermissionLinkDo) Attrs(attrs ...field.AssignExpr) *clientPermissionLinkDo {
return c.withDO(c.DO.Attrs(attrs...))
}
func (c clientPermissionLinkDo) Assign(attrs ...field.AssignExpr) *clientPermissionLinkDo {
return c.withDO(c.DO.Assign(attrs...))
}
func (c clientPermissionLinkDo) Joins(fields ...field.RelationField) *clientPermissionLinkDo {
for _, _f := range fields {
c = *c.withDO(c.DO.Joins(_f))
}
return &c
}
func (c clientPermissionLinkDo) Preload(fields ...field.RelationField) *clientPermissionLinkDo {
for _, _f := range fields {
c = *c.withDO(c.DO.Preload(_f))
}
return &c
}
func (c clientPermissionLinkDo) FirstOrInit() (*models.ClientPermissionLink, error) {
if result, err := c.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.ClientPermissionLink), nil
}
}
func (c clientPermissionLinkDo) FirstOrCreate() (*models.ClientPermissionLink, error) {
if result, err := c.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.ClientPermissionLink), nil
}
}
func (c clientPermissionLinkDo) FindByPage(offset int, limit int) (result []*models.ClientPermissionLink, count int64, err error) {
result, err = c.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = c.Offset(-1).Limit(-1).Count()
return
}
func (c clientPermissionLinkDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = c.Count()
if err != nil {
return
}
err = c.Offset(offset).Limit(limit).Scan(result)
return
}
func (c clientPermissionLinkDo) Scan(result interface{}) (err error) {
return c.DO.Scan(result)
}
func (c clientPermissionLinkDo) Delete(models ...*models.ClientPermissionLink) (result gen.ResultInfo, err error) {
return c.DO.Delete(models)
}
func (c *clientPermissionLinkDo) withDO(do gen.Dao) *clientPermissionLinkDo {
c.DO = *do.(*gen.DO)
return c
}

48
web/queries/coupon.gen.go
View File

@@ -28,16 +28,16 @@ func newCoupon(db *gorm.DB, opts ...gen.DOOption) coupon {
tableName := _coupon.couponDo.TableName()
_coupon.ALL = field.NewAsterisk(tableName)
_coupon.ID = field.NewInt32(tableName, "id")
_coupon.CreatedAt = field.NewTime(tableName, "created_at")
_coupon.UpdatedAt = field.NewTime(tableName, "updated_at")
_coupon.DeletedAt = field.NewField(tableName, "deleted_at")
_coupon.UserID = field.NewInt32(tableName, "user_id")
_coupon.Code = field.NewString(tableName, "code")
_coupon.Remark = field.NewString(tableName, "remark")
_coupon.Amount = field.NewField(tableName, "amount")
_coupon.MinAmount = field.NewField(tableName, "min_amount")
_coupon.Status = field.NewInt32(tableName, "status")
_coupon.ExpireAt = field.NewField(tableName, "expire_at")
_coupon.CreatedAt = field.NewField(tableName, "created_at")
_coupon.UpdatedAt = field.NewField(tableName, "updated_at")
_coupon.DeletedAt = field.NewField(tableName, "deleted_at")
_coupon.Status = field.NewInt(tableName, "status")
_coupon.ExpireAt = field.NewTime(tableName, "expire_at")
_coupon.fillFieldMap()
@@ -48,17 +48,17 @@ type coupon struct {
couponDo
ALL field.Asterisk
ID field.Int32 // 优惠券ID
UserID field.Int32 // 用户ID
Code field.String // 优惠券代码
Remark field.String // 优惠券备注
Amount field.Field // 优惠券金额
MinAmount field.Field // 最低消费金额
Status field.Int32 // 优惠券状态：0-未使用，1-已使用，2-已过期
ExpireAt field.Field // 过期时间
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
UserID field.Int32
Code field.String
Remark field.String
Amount field.Field
MinAmount field.Field
Status field.Int
ExpireAt field.Time
fieldMap map[string]field.Expr
}
@@ -76,16 +76,16 @@ func (c coupon) As(alias string) *coupon {
func (c *coupon) updateTableName(table string) *coupon {
c.ALL = field.NewAsterisk(table)
c.ID = field.NewInt32(table, "id")
c.CreatedAt = field.NewTime(table, "created_at")
c.UpdatedAt = field.NewTime(table, "updated_at")
c.DeletedAt = field.NewField(table, "deleted_at")
c.UserID = field.NewInt32(table, "user_id")
c.Code = field.NewString(table, "code")
c.Remark = field.NewString(table, "remark")
c.Amount = field.NewField(table, "amount")
c.MinAmount = field.NewField(table, "min_amount")
c.Status = field.NewInt32(table, "status")
c.ExpireAt = field.NewField(table, "expire_at")
c.CreatedAt = field.NewField(table, "created_at")
c.UpdatedAt = field.NewField(table, "updated_at")
c.DeletedAt = field.NewField(table, "deleted_at")
c.Status = field.NewInt(table, "status")
c.ExpireAt = field.NewTime(table, "expire_at")
c.fillFieldMap()
@@ -104,6 +104,9 @@ func (c *coupon) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (c *coupon) fillFieldMap() {
c.fieldMap = make(map[string]field.Expr, 11)
c.fieldMap["id"] = c.ID
c.fieldMap["created_at"] = c.CreatedAt
c.fieldMap["updated_at"] = c.UpdatedAt
c.fieldMap["deleted_at"] = c.DeletedAt
c.fieldMap["user_id"] = c.UserID
c.fieldMap["code"] = c.Code
c.fieldMap["remark"] = c.Remark
@@ -111,9 +114,6 @@ func (c *coupon) fillFieldMap() {
c.fieldMap["min_amount"] = c.MinAmount
c.fieldMap["status"] = c.Status
c.fieldMap["expire_at"] = c.ExpireAt
c.fieldMap["created_at"] = c.CreatedAt
c.fieldMap["updated_at"] = c.UpdatedAt
c.fieldMap["deleted_at"] = c.DeletedAt
}
func (c coupon) clone(db *gorm.DB) coupon {

94
web/queries/edge.gen.go
View File

@@ -28,21 +28,19 @@ func newEdge(db *gorm.DB, opts ...gen.DOOption) edge {
tableName := _edge.edgeDo.TableName()
_edge.ALL = field.NewAsterisk(tableName)
_edge.ID = field.NewInt32(tableName, "id")
_edge.ProxyID = field.NewInt32(tableName, "proxy_id")
_edge.Type = field.NewInt32(tableName, "type")
_edge.CreatedAt = field.NewTime(tableName, "created_at")
_edge.UpdatedAt = field.NewTime(tableName, "updated_at")
_edge.DeletedAt = field.NewField(tableName, "deleted_at")
_edge.Type = field.NewInt(tableName, "type")
_edge.Version = field.NewInt32(tableName, "version")
_edge.Name = field.NewString(tableName, "name")
_edge.Host = field.NewString(tableName, "host")
_edge.Isp = field.NewInt32(tableName, "isp")
_edge.Mac = field.NewString(tableName, "mac")
_edge.IP = field.NewField(tableName, "ip")
_edge.ISP = field.NewInt(tableName, "isp")
_edge.Prov = field.NewString(tableName, "prov")
_edge.City = field.NewString(tableName, "city")
_edge.ProxyPort = field.NewInt32(tableName, "proxy_port")
_edge.Status = field.NewInt32(tableName, "status")
_edge.Rtt = field.NewInt32(tableName, "rtt")
_edge.Status = field.NewInt(tableName, "status")
_edge.RTT = field.NewInt32(tableName, "rtt")
_edge.Loss = field.NewInt32(tableName, "loss")
_edge.CreatedAt = field.NewField(tableName, "created_at")
_edge.UpdatedAt = field.NewField(tableName, "updated_at")
_edge.DeletedAt = field.NewField(tableName, "deleted_at")
_edge.fillFieldMap()
@@ -53,22 +51,20 @@ type edge struct {
edgeDo
ALL field.Asterisk
ID field.Int32 // 节点ID
ProxyID field.Int32 // 代理ID
Type field.Int32 // 节点类型：1-自建
Version field.Int32 // 节点版本
Name field.String // 节点名称
Host field.String // 节点地址
Isp field.Int32 // 运营商：0-未知，1-电信，2-联通，3-移动
Prov field.String // 省份
City field.String // 城市
ProxyPort field.Int32 // 代理端口
Status field.Int32 // 节点状态：0-离线，1-正常
Rtt field.Int32 // 最近平均延迟
Loss field.Int32 // 最近丢包率
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Type field.Int
Version field.Int32
Mac field.String
IP field.Field
ISP field.Int
Prov field.String
City field.String
Status field.Int
RTT field.Int32
Loss field.Int32
fieldMap map[string]field.Expr
}
@@ -86,21 +82,19 @@ func (e edge) As(alias string) *edge {
func (e *edge) updateTableName(table string) *edge {
e.ALL = field.NewAsterisk(table)
e.ID = field.NewInt32(table, "id")
e.ProxyID = field.NewInt32(table, "proxy_id")
e.Type = field.NewInt32(table, "type")
e.CreatedAt = field.NewTime(table, "created_at")
e.UpdatedAt = field.NewTime(table, "updated_at")
e.DeletedAt = field.NewField(table, "deleted_at")
e.Type = field.NewInt(table, "type")
e.Version = field.NewInt32(table, "version")
e.Name = field.NewString(table, "name")
e.Host = field.NewString(table, "host")
e.Isp = field.NewInt32(table, "isp")
e.Mac = field.NewString(table, "mac")
e.IP = field.NewField(table, "ip")
e.ISP = field.NewInt(table, "isp")
e.Prov = field.NewString(table, "prov")
e.City = field.NewString(table, "city")
e.ProxyPort = field.NewInt32(table, "proxy_port")
e.Status = field.NewInt32(table, "status")
e.Rtt = field.NewInt32(table, "rtt")
e.Status = field.NewInt(table, "status")
e.RTT = field.NewInt32(table, "rtt")
e.Loss = field.NewInt32(table, "loss")
e.CreatedAt = field.NewField(table, "created_at")
e.UpdatedAt = field.NewField(table, "updated_at")
e.DeletedAt = field.NewField(table, "deleted_at")
e.fillFieldMap()
@@ -117,23 +111,21 @@ func (e *edge) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (e *edge) fillFieldMap() {
e.fieldMap = make(map[string]field.Expr, 16)
e.fieldMap = make(map[string]field.Expr, 14)
e.fieldMap["id"] = e.ID
e.fieldMap["proxy_id"] = e.ProxyID
e.fieldMap["type"] = e.Type
e.fieldMap["version"] = e.Version
e.fieldMap["name"] = e.Name
e.fieldMap["host"] = e.Host
e.fieldMap["isp"] = e.Isp
e.fieldMap["prov"] = e.Prov
e.fieldMap["city"] = e.City
e.fieldMap["proxy_port"] = e.ProxyPort
e.fieldMap["status"] = e.Status
e.fieldMap["rtt"] = e.Rtt
e.fieldMap["loss"] = e.Loss
e.fieldMap["created_at"] = e.CreatedAt
e.fieldMap["updated_at"] = e.UpdatedAt
e.fieldMap["deleted_at"] = e.DeletedAt
e.fieldMap["type"] = e.Type
e.fieldMap["version"] = e.Version
e.fieldMap["mac"] = e.Mac
e.fieldMap["ip"] = e.IP
e.fieldMap["isp"] = e.ISP
e.fieldMap["prov"] = e.Prov
e.fieldMap["city"] = e.City
e.fieldMap["status"] = e.Status
e.fieldMap["rtt"] = e.RTT
e.fieldMap["loss"] = e.Loss
}
func (e edge) clone(db *gorm.DB) edge {

80
web/queries/gen.go
View File

@@ -19,15 +19,17 @@ var (
Q = new(Query)
Admin *admin
AdminRole *adminRole
AdminRoleLink *adminRoleLink
AdminRolePermissionLink *adminRolePermissionLink
Announcement *announcement
Bill *bill
Channel *channel
Client *client
ClientPermissionLink *clientPermissionLink
Coupon *coupon
Edge *edge
LinkAdminRole *linkAdminRole
LinkAdminRolePermission *linkAdminRolePermission
LinkClientPermission *linkClientPermission
LinkUserRole *linkUserRole
LinkUserRolePermission *linkUserRolePermission
LogsLogin *logsLogin
LogsRequest *logsRequest
LogsUserBandwidth *logsUserBandwidth
@@ -43,8 +45,6 @@ var (
Trade *trade
User *user
UserRole *userRole
UserRoleLink *userRoleLink
UserRolePermissionLink *userRolePermissionLink
Whitelist *whitelist
)
@@ -52,15 +52,17 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
*Q = *Use(db, opts...)
Admin = &Q.Admin
AdminRole = &Q.AdminRole
AdminRoleLink = &Q.AdminRoleLink
AdminRolePermissionLink = &Q.AdminRolePermissionLink
Announcement = &Q.Announcement
Bill = &Q.Bill
Channel = &Q.Channel
Client = &Q.Client
ClientPermissionLink = &Q.ClientPermissionLink
Coupon = &Q.Coupon
Edge = &Q.Edge
LinkAdminRole = &Q.LinkAdminRole
LinkAdminRolePermission = &Q.LinkAdminRolePermission
LinkClientPermission = &Q.LinkClientPermission
LinkUserRole = &Q.LinkUserRole
LinkUserRolePermission = &Q.LinkUserRolePermission
LogsLogin = &Q.LogsLogin
LogsRequest = &Q.LogsRequest
LogsUserBandwidth = &Q.LogsUserBandwidth
@@ -76,8 +78,6 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
Trade = &Q.Trade
User = &Q.User
UserRole = &Q.UserRole
UserRoleLink = &Q.UserRoleLink
UserRolePermissionLink = &Q.UserRolePermissionLink
Whitelist = &Q.Whitelist
}
@@ -86,15 +86,17 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
db: db,
Admin: newAdmin(db, opts...),
AdminRole: newAdminRole(db, opts...),
AdminRoleLink: newAdminRoleLink(db, opts...),
AdminRolePermissionLink: newAdminRolePermissionLink(db, opts...),
Announcement: newAnnouncement(db, opts...),
Bill: newBill(db, opts...),
Channel: newChannel(db, opts...),
Client: newClient(db, opts...),
ClientPermissionLink: newClientPermissionLink(db, opts...),
Coupon: newCoupon(db, opts...),
Edge: newEdge(db, opts...),
LinkAdminRole: newLinkAdminRole(db, opts...),
LinkAdminRolePermission: newLinkAdminRolePermission(db, opts...),
LinkClientPermission: newLinkClientPermission(db, opts...),
LinkUserRole: newLinkUserRole(db, opts...),
LinkUserRolePermission: newLinkUserRolePermission(db, opts...),
LogsLogin: newLogsLogin(db, opts...),
LogsRequest: newLogsRequest(db, opts...),
LogsUserBandwidth: newLogsUserBandwidth(db, opts...),
@@ -110,8 +112,6 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
Trade: newTrade(db, opts...),
User: newUser(db, opts...),
UserRole: newUserRole(db, opts...),
UserRoleLink: newUserRoleLink(db, opts...),
UserRolePermissionLink: newUserRolePermissionLink(db, opts...),
Whitelist: newWhitelist(db, opts...),
}
}
@@ -121,15 +121,17 @@ type Query struct {
Admin admin
AdminRole adminRole
AdminRoleLink adminRoleLink
AdminRolePermissionLink adminRolePermissionLink
Announcement announcement
Bill bill
Channel channel
Client client
ClientPermissionLink clientPermissionLink
Coupon coupon
Edge edge
LinkAdminRole linkAdminRole
LinkAdminRolePermission linkAdminRolePermission
LinkClientPermission linkClientPermission
LinkUserRole linkUserRole
LinkUserRolePermission linkUserRolePermission
LogsLogin logsLogin
LogsRequest logsRequest
LogsUserBandwidth logsUserBandwidth
@@ -145,8 +147,6 @@ type Query struct {
Trade trade
User user
UserRole userRole
UserRoleLink userRoleLink
UserRolePermissionLink userRolePermissionLink
Whitelist whitelist
}
@@ -157,15 +157,17 @@ func (q *Query) clone(db *gorm.DB) *Query {
db: db,
Admin: q.Admin.clone(db),
AdminRole: q.AdminRole.clone(db),
AdminRoleLink: q.AdminRoleLink.clone(db),
AdminRolePermissionLink: q.AdminRolePermissionLink.clone(db),
Announcement: q.Announcement.clone(db),
Bill: q.Bill.clone(db),
Channel: q.Channel.clone(db),
Client: q.Client.clone(db),
ClientPermissionLink: q.ClientPermissionLink.clone(db),
Coupon: q.Coupon.clone(db),
Edge: q.Edge.clone(db),
LinkAdminRole: q.LinkAdminRole.clone(db),
LinkAdminRolePermission: q.LinkAdminRolePermission.clone(db),
LinkClientPermission: q.LinkClientPermission.clone(db),
LinkUserRole: q.LinkUserRole.clone(db),
LinkUserRolePermission: q.LinkUserRolePermission.clone(db),
LogsLogin: q.LogsLogin.clone(db),
LogsRequest: q.LogsRequest.clone(db),
LogsUserBandwidth: q.LogsUserBandwidth.clone(db),
@@ -181,8 +183,6 @@ func (q *Query) clone(db *gorm.DB) *Query {
Trade: q.Trade.clone(db),
User: q.User.clone(db),
UserRole: q.UserRole.clone(db),
UserRoleLink: q.UserRoleLink.clone(db),
UserRolePermissionLink: q.UserRolePermissionLink.clone(db),
Whitelist: q.Whitelist.clone(db),
}
}
@@ -200,15 +200,17 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
db: db,
Admin: q.Admin.replaceDB(db),
AdminRole: q.AdminRole.replaceDB(db),
AdminRoleLink: q.AdminRoleLink.replaceDB(db),
AdminRolePermissionLink: q.AdminRolePermissionLink.replaceDB(db),
Announcement: q.Announcement.replaceDB(db),
Bill: q.Bill.replaceDB(db),
Channel: q.Channel.replaceDB(db),
Client: q.Client.replaceDB(db),
ClientPermissionLink: q.ClientPermissionLink.replaceDB(db),
Coupon: q.Coupon.replaceDB(db),
Edge: q.Edge.replaceDB(db),
LinkAdminRole: q.LinkAdminRole.replaceDB(db),
LinkAdminRolePermission: q.LinkAdminRolePermission.replaceDB(db),
LinkClientPermission: q.LinkClientPermission.replaceDB(db),
LinkUserRole: q.LinkUserRole.replaceDB(db),
LinkUserRolePermission: q.LinkUserRolePermission.replaceDB(db),
LogsLogin: q.LogsLogin.replaceDB(db),
LogsRequest: q.LogsRequest.replaceDB(db),
LogsUserBandwidth: q.LogsUserBandwidth.replaceDB(db),
@@ -224,8 +226,6 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
Trade: q.Trade.replaceDB(db),
User: q.User.replaceDB(db),
UserRole: q.UserRole.replaceDB(db),
UserRoleLink: q.UserRoleLink.replaceDB(db),
UserRolePermissionLink: q.UserRolePermissionLink.replaceDB(db),
Whitelist: q.Whitelist.replaceDB(db),
}
}
@@ -233,15 +233,17 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
type queryCtx struct {
Admin *adminDo
AdminRole *adminRoleDo
AdminRoleLink *adminRoleLinkDo
AdminRolePermissionLink *adminRolePermissionLinkDo
Announcement *announcementDo
Bill *billDo
Channel *channelDo
Client *clientDo
ClientPermissionLink *clientPermissionLinkDo
Coupon *couponDo
Edge *edgeDo
LinkAdminRole *linkAdminRoleDo
LinkAdminRolePermission *linkAdminRolePermissionDo
LinkClientPermission *linkClientPermissionDo
LinkUserRole *linkUserRoleDo
LinkUserRolePermission *linkUserRolePermissionDo
LogsLogin *logsLoginDo
LogsRequest *logsRequestDo
LogsUserBandwidth *logsUserBandwidthDo
@@ -257,8 +259,6 @@ type queryCtx struct {
Trade *tradeDo
User *userDo
UserRole *userRoleDo
UserRoleLink *userRoleLinkDo
UserRolePermissionLink *userRolePermissionLinkDo
Whitelist *whitelistDo
}
@@ -266,15 +266,17 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx {
return &queryCtx{
Admin: q.Admin.WithContext(ctx),
AdminRole: q.AdminRole.WithContext(ctx),
AdminRoleLink: q.AdminRoleLink.WithContext(ctx),
AdminRolePermissionLink: q.AdminRolePermissionLink.WithContext(ctx),
Announcement: q.Announcement.WithContext(ctx),
Bill: q.Bill.WithContext(ctx),
Channel: q.Channel.WithContext(ctx),
Client: q.Client.WithContext(ctx),
ClientPermissionLink: q.ClientPermissionLink.WithContext(ctx),
Coupon: q.Coupon.WithContext(ctx),
Edge: q.Edge.WithContext(ctx),
LinkAdminRole: q.LinkAdminRole.WithContext(ctx),
LinkAdminRolePermission: q.LinkAdminRolePermission.WithContext(ctx),
LinkClientPermission: q.LinkClientPermission.WithContext(ctx),
LinkUserRole: q.LinkUserRole.WithContext(ctx),
LinkUserRolePermission: q.LinkUserRolePermission.WithContext(ctx),
LogsLogin: q.LogsLogin.WithContext(ctx),
LogsRequest: q.LogsRequest.WithContext(ctx),
LogsUserBandwidth: q.LogsUserBandwidth.WithContext(ctx),
@@ -290,8 +292,6 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx {
Trade: q.Trade.WithContext(ctx),
User: q.User.WithContext(ctx),
UserRole: q.UserRole.WithContext(ctx),
UserRoleLink: q.UserRoleLink.WithContext(ctx),
UserRolePermissionLink: q.UserRolePermissionLink.WithContext(ctx),
Whitelist: q.Whitelist.WithContext(ctx),
}
}

327
web/queries/link_admin_role.gen.go Normal file
View File

@@ -0,0 +1,327 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newLinkAdminRole(db *gorm.DB, opts ...gen.DOOption) linkAdminRole {
_linkAdminRole := linkAdminRole{}
_linkAdminRole.linkAdminRoleDo.UseDB(db, opts...)
_linkAdminRole.linkAdminRoleDo.UseModel(&models.LinkAdminRole{})
tableName := _linkAdminRole.linkAdminRoleDo.TableName()
_linkAdminRole.ALL = field.NewAsterisk(tableName)
_linkAdminRole.ID = field.NewInt32(tableName, "id")
_linkAdminRole.AdminID = field.NewInt32(tableName, "admin_id")
_linkAdminRole.RoleID = field.NewInt32(tableName, "role_id")
_linkAdminRole.fillFieldMap()
return _linkAdminRole
}
type linkAdminRole struct {
linkAdminRoleDo
ALL field.Asterisk
ID field.Int32
AdminID field.Int32
RoleID field.Int32
fieldMap map[string]field.Expr
}
func (l linkAdminRole) Table(newTableName string) *linkAdminRole {
l.linkAdminRoleDo.UseTable(newTableName)
return l.updateTableName(newTableName)
}
func (l linkAdminRole) As(alias string) *linkAdminRole {
l.linkAdminRoleDo.DO = *(l.linkAdminRoleDo.As(alias).(*gen.DO))
return l.updateTableName(alias)
}
func (l *linkAdminRole) updateTableName(table string) *linkAdminRole {
l.ALL = field.NewAsterisk(table)
l.ID = field.NewInt32(table, "id")
l.AdminID = field.NewInt32(table, "admin_id")
l.RoleID = field.NewInt32(table, "role_id")
l.fillFieldMap()
return l
}
func (l *linkAdminRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := l.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (l *linkAdminRole) fillFieldMap() {
l.fieldMap = make(map[string]field.Expr, 3)
l.fieldMap["id"] = l.ID
l.fieldMap["admin_id"] = l.AdminID
l.fieldMap["role_id"] = l.RoleID
}
func (l linkAdminRole) clone(db *gorm.DB) linkAdminRole {
l.linkAdminRoleDo.ReplaceConnPool(db.Statement.ConnPool)
return l
}
func (l linkAdminRole) replaceDB(db *gorm.DB) linkAdminRole {
l.linkAdminRoleDo.ReplaceDB(db)
return l
}
type linkAdminRoleDo struct{ gen.DO }
func (l linkAdminRoleDo) Debug() *linkAdminRoleDo {
return l.withDO(l.DO.Debug())
}
func (l linkAdminRoleDo) WithContext(ctx context.Context) *linkAdminRoleDo {
return l.withDO(l.DO.WithContext(ctx))
}
func (l linkAdminRoleDo) ReadDB() *linkAdminRoleDo {
return l.Clauses(dbresolver.Read)
}
func (l linkAdminRoleDo) WriteDB() *linkAdminRoleDo {
return l.Clauses(dbresolver.Write)
}
func (l linkAdminRoleDo) Session(config *gorm.Session) *linkAdminRoleDo {
return l.withDO(l.DO.Session(config))
}
func (l linkAdminRoleDo) Clauses(conds ...clause.Expression) *linkAdminRoleDo {
return l.withDO(l.DO.Clauses(conds...))
}
func (l linkAdminRoleDo) Returning(value interface{}, columns ...string) *linkAdminRoleDo {
return l.withDO(l.DO.Returning(value, columns...))
}
func (l linkAdminRoleDo) Not(conds ...gen.Condition) *linkAdminRoleDo {
return l.withDO(l.DO.Not(conds...))
}
func (l linkAdminRoleDo) Or(conds ...gen.Condition) *linkAdminRoleDo {
return l.withDO(l.DO.Or(conds...))
}
func (l linkAdminRoleDo) Select(conds ...field.Expr) *linkAdminRoleDo {
return l.withDO(l.DO.Select(conds...))
}
func (l linkAdminRoleDo) Where(conds ...gen.Condition) *linkAdminRoleDo {
return l.withDO(l.DO.Where(conds...))
}
func (l linkAdminRoleDo) Order(conds ...field.Expr) *linkAdminRoleDo {
return l.withDO(l.DO.Order(conds...))
}
func (l linkAdminRoleDo) Distinct(cols ...field.Expr) *linkAdminRoleDo {
return l.withDO(l.DO.Distinct(cols...))
}
func (l linkAdminRoleDo) Omit(cols ...field.Expr) *linkAdminRoleDo {
return l.withDO(l.DO.Omit(cols...))
}
func (l linkAdminRoleDo) Join(table schema.Tabler, on ...field.Expr) *linkAdminRoleDo {
return l.withDO(l.DO.Join(table, on...))
}
func (l linkAdminRoleDo) LeftJoin(table schema.Tabler, on ...field.Expr) *linkAdminRoleDo {
return l.withDO(l.DO.LeftJoin(table, on...))
}
func (l linkAdminRoleDo) RightJoin(table schema.Tabler, on ...field.Expr) *linkAdminRoleDo {
return l.withDO(l.DO.RightJoin(table, on...))
}
func (l linkAdminRoleDo) Group(cols ...field.Expr) *linkAdminRoleDo {
return l.withDO(l.DO.Group(cols...))
}
func (l linkAdminRoleDo) Having(conds ...gen.Condition) *linkAdminRoleDo {
return l.withDO(l.DO.Having(conds...))
}
func (l linkAdminRoleDo) Limit(limit int) *linkAdminRoleDo {
return l.withDO(l.DO.Limit(limit))
}
func (l linkAdminRoleDo) Offset(offset int) *linkAdminRoleDo {
return l.withDO(l.DO.Offset(offset))
}
func (l linkAdminRoleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *linkAdminRoleDo {
return l.withDO(l.DO.Scopes(funcs...))
}
func (l linkAdminRoleDo) Unscoped() *linkAdminRoleDo {
return l.withDO(l.DO.Unscoped())
}
func (l linkAdminRoleDo) Create(values ...*models.LinkAdminRole) error {
if len(values) == 0 {
return nil
}
return l.DO.Create(values)
}
func (l linkAdminRoleDo) CreateInBatches(values []*models.LinkAdminRole, batchSize int) error {
return l.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (l linkAdminRoleDo) Save(values ...*models.LinkAdminRole) error {
if len(values) == 0 {
return nil
}
return l.DO.Save(values)
}
func (l linkAdminRoleDo) First() (*models.LinkAdminRole, error) {
if result, err := l.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRole), nil
}
}
func (l linkAdminRoleDo) Take() (*models.LinkAdminRole, error) {
if result, err := l.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRole), nil
}
}
func (l linkAdminRoleDo) Last() (*models.LinkAdminRole, error) {
if result, err := l.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRole), nil
}
}
func (l linkAdminRoleDo) Find() ([]*models.LinkAdminRole, error) {
result, err := l.DO.Find()
return result.([]*models.LinkAdminRole), err
}
func (l linkAdminRoleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.LinkAdminRole, err error) {
buf := make([]*models.LinkAdminRole, 0, batchSize)
err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (l linkAdminRoleDo) FindInBatches(result *[]*models.LinkAdminRole, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return l.DO.FindInBatches(result, batchSize, fc)
}
func (l linkAdminRoleDo) Attrs(attrs ...field.AssignExpr) *linkAdminRoleDo {
return l.withDO(l.DO.Attrs(attrs...))
}
func (l linkAdminRoleDo) Assign(attrs ...field.AssignExpr) *linkAdminRoleDo {
return l.withDO(l.DO.Assign(attrs...))
}
func (l linkAdminRoleDo) Joins(fields ...field.RelationField) *linkAdminRoleDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Joins(_f))
}
return &l
}
func (l linkAdminRoleDo) Preload(fields ...field.RelationField) *linkAdminRoleDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Preload(_f))
}
return &l
}
func (l linkAdminRoleDo) FirstOrInit() (*models.LinkAdminRole, error) {
if result, err := l.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRole), nil
}
}
func (l linkAdminRoleDo) FirstOrCreate() (*models.LinkAdminRole, error) {
if result, err := l.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRole), nil
}
}
func (l linkAdminRoleDo) FindByPage(offset int, limit int) (result []*models.LinkAdminRole, count int64, err error) {
result, err = l.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = l.Offset(-1).Limit(-1).Count()
return
}
func (l linkAdminRoleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = l.Count()
if err != nil {
return
}
err = l.Offset(offset).Limit(limit).Scan(result)
return
}
func (l linkAdminRoleDo) Scan(result interface{}) (err error) {
return l.DO.Scan(result)
}
func (l linkAdminRoleDo) Delete(models ...*models.LinkAdminRole) (result gen.ResultInfo, err error) {
return l.DO.Delete(models)
}
func (l *linkAdminRoleDo) withDO(do gen.Dao) *linkAdminRoleDo {
l.DO = *do.(*gen.DO)
return l
}

327
web/queries/link_admin_role_permission.gen.go Normal file
View File

@@ -0,0 +1,327 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newLinkAdminRolePermission(db *gorm.DB, opts ...gen.DOOption) linkAdminRolePermission {
_linkAdminRolePermission := linkAdminRolePermission{}
_linkAdminRolePermission.linkAdminRolePermissionDo.UseDB(db, opts...)
_linkAdminRolePermission.linkAdminRolePermissionDo.UseModel(&models.LinkAdminRolePermission{})
tableName := _linkAdminRolePermission.linkAdminRolePermissionDo.TableName()
_linkAdminRolePermission.ALL = field.NewAsterisk(tableName)
_linkAdminRolePermission.ID = field.NewInt32(tableName, "id")
_linkAdminRolePermission.RoleID = field.NewInt32(tableName, "role_id")
_linkAdminRolePermission.PermissionID = field.NewInt32(tableName, "permission_id")
_linkAdminRolePermission.fillFieldMap()
return _linkAdminRolePermission
}
type linkAdminRolePermission struct {
linkAdminRolePermissionDo
ALL field.Asterisk
ID field.Int32
RoleID field.Int32
PermissionID field.Int32
fieldMap map[string]field.Expr
}
func (l linkAdminRolePermission) Table(newTableName string) *linkAdminRolePermission {
l.linkAdminRolePermissionDo.UseTable(newTableName)
return l.updateTableName(newTableName)
}
func (l linkAdminRolePermission) As(alias string) *linkAdminRolePermission {
l.linkAdminRolePermissionDo.DO = *(l.linkAdminRolePermissionDo.As(alias).(*gen.DO))
return l.updateTableName(alias)
}
func (l *linkAdminRolePermission) updateTableName(table string) *linkAdminRolePermission {
l.ALL = field.NewAsterisk(table)
l.ID = field.NewInt32(table, "id")
l.RoleID = field.NewInt32(table, "role_id")
l.PermissionID = field.NewInt32(table, "permission_id")
l.fillFieldMap()
return l
}
func (l *linkAdminRolePermission) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := l.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (l *linkAdminRolePermission) fillFieldMap() {
l.fieldMap = make(map[string]field.Expr, 3)
l.fieldMap["id"] = l.ID
l.fieldMap["role_id"] = l.RoleID
l.fieldMap["permission_id"] = l.PermissionID
}
func (l linkAdminRolePermission) clone(db *gorm.DB) linkAdminRolePermission {
l.linkAdminRolePermissionDo.ReplaceConnPool(db.Statement.ConnPool)
return l
}
func (l linkAdminRolePermission) replaceDB(db *gorm.DB) linkAdminRolePermission {
l.linkAdminRolePermissionDo.ReplaceDB(db)
return l
}
type linkAdminRolePermissionDo struct{ gen.DO }
func (l linkAdminRolePermissionDo) Debug() *linkAdminRolePermissionDo {
return l.withDO(l.DO.Debug())
}
func (l linkAdminRolePermissionDo) WithContext(ctx context.Context) *linkAdminRolePermissionDo {
return l.withDO(l.DO.WithContext(ctx))
}
func (l linkAdminRolePermissionDo) ReadDB() *linkAdminRolePermissionDo {
return l.Clauses(dbresolver.Read)
}
func (l linkAdminRolePermissionDo) WriteDB() *linkAdminRolePermissionDo {
return l.Clauses(dbresolver.Write)
}
func (l linkAdminRolePermissionDo) Session(config *gorm.Session) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Session(config))
}
func (l linkAdminRolePermissionDo) Clauses(conds ...clause.Expression) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Clauses(conds...))
}
func (l linkAdminRolePermissionDo) Returning(value interface{}, columns ...string) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Returning(value, columns...))
}
func (l linkAdminRolePermissionDo) Not(conds ...gen.Condition) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Not(conds...))
}
func (l linkAdminRolePermissionDo) Or(conds ...gen.Condition) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Or(conds...))
}
func (l linkAdminRolePermissionDo) Select(conds ...field.Expr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Select(conds...))
}
func (l linkAdminRolePermissionDo) Where(conds ...gen.Condition) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Where(conds...))
}
func (l linkAdminRolePermissionDo) Order(conds ...field.Expr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Order(conds...))
}
func (l linkAdminRolePermissionDo) Distinct(cols ...field.Expr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Distinct(cols...))
}
func (l linkAdminRolePermissionDo) Omit(cols ...field.Expr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Omit(cols...))
}
func (l linkAdminRolePermissionDo) Join(table schema.Tabler, on ...field.Expr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Join(table, on...))
}
func (l linkAdminRolePermissionDo) LeftJoin(table schema.Tabler, on ...field.Expr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.LeftJoin(table, on...))
}
func (l linkAdminRolePermissionDo) RightJoin(table schema.Tabler, on ...field.Expr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.RightJoin(table, on...))
}
func (l linkAdminRolePermissionDo) Group(cols ...field.Expr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Group(cols...))
}
func (l linkAdminRolePermissionDo) Having(conds ...gen.Condition) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Having(conds...))
}
func (l linkAdminRolePermissionDo) Limit(limit int) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Limit(limit))
}
func (l linkAdminRolePermissionDo) Offset(offset int) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Offset(offset))
}
func (l linkAdminRolePermissionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Scopes(funcs...))
}
func (l linkAdminRolePermissionDo) Unscoped() *linkAdminRolePermissionDo {
return l.withDO(l.DO.Unscoped())
}
func (l linkAdminRolePermissionDo) Create(values ...*models.LinkAdminRolePermission) error {
if len(values) == 0 {
return nil
}
return l.DO.Create(values)
}
func (l linkAdminRolePermissionDo) CreateInBatches(values []*models.LinkAdminRolePermission, batchSize int) error {
return l.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (l linkAdminRolePermissionDo) Save(values ...*models.LinkAdminRolePermission) error {
if len(values) == 0 {
return nil
}
return l.DO.Save(values)
}
func (l linkAdminRolePermissionDo) First() (*models.LinkAdminRolePermission, error) {
if result, err := l.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRolePermission), nil
}
}
func (l linkAdminRolePermissionDo) Take() (*models.LinkAdminRolePermission, error) {
if result, err := l.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRolePermission), nil
}
}
func (l linkAdminRolePermissionDo) Last() (*models.LinkAdminRolePermission, error) {
if result, err := l.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRolePermission), nil
}
}
func (l linkAdminRolePermissionDo) Find() ([]*models.LinkAdminRolePermission, error) {
result, err := l.DO.Find()
return result.([]*models.LinkAdminRolePermission), err
}
func (l linkAdminRolePermissionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.LinkAdminRolePermission, err error) {
buf := make([]*models.LinkAdminRolePermission, 0, batchSize)
err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (l linkAdminRolePermissionDo) FindInBatches(result *[]*models.LinkAdminRolePermission, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return l.DO.FindInBatches(result, batchSize, fc)
}
func (l linkAdminRolePermissionDo) Attrs(attrs ...field.AssignExpr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Attrs(attrs...))
}
func (l linkAdminRolePermissionDo) Assign(attrs ...field.AssignExpr) *linkAdminRolePermissionDo {
return l.withDO(l.DO.Assign(attrs...))
}
func (l linkAdminRolePermissionDo) Joins(fields ...field.RelationField) *linkAdminRolePermissionDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Joins(_f))
}
return &l
}
func (l linkAdminRolePermissionDo) Preload(fields ...field.RelationField) *linkAdminRolePermissionDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Preload(_f))
}
return &l
}
func (l linkAdminRolePermissionDo) FirstOrInit() (*models.LinkAdminRolePermission, error) {
if result, err := l.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRolePermission), nil
}
}
func (l linkAdminRolePermissionDo) FirstOrCreate() (*models.LinkAdminRolePermission, error) {
if result, err := l.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.LinkAdminRolePermission), nil
}
}
func (l linkAdminRolePermissionDo) FindByPage(offset int, limit int) (result []*models.LinkAdminRolePermission, count int64, err error) {
result, err = l.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = l.Offset(-1).Limit(-1).Count()
return
}
func (l linkAdminRolePermissionDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = l.Count()
if err != nil {
return
}
err = l.Offset(offset).Limit(limit).Scan(result)
return
}
func (l linkAdminRolePermissionDo) Scan(result interface{}) (err error) {
return l.DO.Scan(result)
}
func (l linkAdminRolePermissionDo) Delete(models ...*models.LinkAdminRolePermission) (result gen.ResultInfo, err error) {
return l.DO.Delete(models)
}
func (l *linkAdminRolePermissionDo) withDO(do gen.Dao) *linkAdminRolePermissionDo {
l.DO = *do.(*gen.DO)
return l
}

327
web/queries/link_client_permission.gen.go Normal file
View File

@@ -0,0 +1,327 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newLinkClientPermission(db *gorm.DB, opts ...gen.DOOption) linkClientPermission {
_linkClientPermission := linkClientPermission{}
_linkClientPermission.linkClientPermissionDo.UseDB(db, opts...)
_linkClientPermission.linkClientPermissionDo.UseModel(&models.LinkClientPermission{})
tableName := _linkClientPermission.linkClientPermissionDo.TableName()
_linkClientPermission.ALL = field.NewAsterisk(tableName)
_linkClientPermission.ID = field.NewInt32(tableName, "id")
_linkClientPermission.ClientID = field.NewInt32(tableName, "client_id")
_linkClientPermission.PermissionID = field.NewInt32(tableName, "permission_id")
_linkClientPermission.fillFieldMap()
return _linkClientPermission
}
type linkClientPermission struct {
linkClientPermissionDo
ALL field.Asterisk
ID field.Int32
ClientID field.Int32
PermissionID field.Int32
fieldMap map[string]field.Expr
}
func (l linkClientPermission) Table(newTableName string) *linkClientPermission {
l.linkClientPermissionDo.UseTable(newTableName)
return l.updateTableName(newTableName)
}
func (l linkClientPermission) As(alias string) *linkClientPermission {
l.linkClientPermissionDo.DO = *(l.linkClientPermissionDo.As(alias).(*gen.DO))
return l.updateTableName(alias)
}
func (l *linkClientPermission) updateTableName(table string) *linkClientPermission {
l.ALL = field.NewAsterisk(table)
l.ID = field.NewInt32(table, "id")
l.ClientID = field.NewInt32(table, "client_id")
l.PermissionID = field.NewInt32(table, "permission_id")
l.fillFieldMap()
return l
}
func (l *linkClientPermission) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := l.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (l *linkClientPermission) fillFieldMap() {
l.fieldMap = make(map[string]field.Expr, 3)
l.fieldMap["id"] = l.ID
l.fieldMap["client_id"] = l.ClientID
l.fieldMap["permission_id"] = l.PermissionID
}
func (l linkClientPermission) clone(db *gorm.DB) linkClientPermission {
l.linkClientPermissionDo.ReplaceConnPool(db.Statement.ConnPool)
return l
}
func (l linkClientPermission) replaceDB(db *gorm.DB) linkClientPermission {
l.linkClientPermissionDo.ReplaceDB(db)
return l
}
type linkClientPermissionDo struct{ gen.DO }
func (l linkClientPermissionDo) Debug() *linkClientPermissionDo {
return l.withDO(l.DO.Debug())
}
func (l linkClientPermissionDo) WithContext(ctx context.Context) *linkClientPermissionDo {
return l.withDO(l.DO.WithContext(ctx))
}
func (l linkClientPermissionDo) ReadDB() *linkClientPermissionDo {
return l.Clauses(dbresolver.Read)
}
func (l linkClientPermissionDo) WriteDB() *linkClientPermissionDo {
return l.Clauses(dbresolver.Write)
}
func (l linkClientPermissionDo) Session(config *gorm.Session) *linkClientPermissionDo {
return l.withDO(l.DO.Session(config))
}
func (l linkClientPermissionDo) Clauses(conds ...clause.Expression) *linkClientPermissionDo {
return l.withDO(l.DO.Clauses(conds...))
}
func (l linkClientPermissionDo) Returning(value interface{}, columns ...string) *linkClientPermissionDo {
return l.withDO(l.DO.Returning(value, columns...))
}
func (l linkClientPermissionDo) Not(conds ...gen.Condition) *linkClientPermissionDo {
return l.withDO(l.DO.Not(conds...))
}
func (l linkClientPermissionDo) Or(conds ...gen.Condition) *linkClientPermissionDo {
return l.withDO(l.DO.Or(conds...))
}
func (l linkClientPermissionDo) Select(conds ...field.Expr) *linkClientPermissionDo {
return l.withDO(l.DO.Select(conds...))
}
func (l linkClientPermissionDo) Where(conds ...gen.Condition) *linkClientPermissionDo {
return l.withDO(l.DO.Where(conds...))
}
func (l linkClientPermissionDo) Order(conds ...field.Expr) *linkClientPermissionDo {
return l.withDO(l.DO.Order(conds...))
}
func (l linkClientPermissionDo) Distinct(cols ...field.Expr) *linkClientPermissionDo {
return l.withDO(l.DO.Distinct(cols...))
}
func (l linkClientPermissionDo) Omit(cols ...field.Expr) *linkClientPermissionDo {
return l.withDO(l.DO.Omit(cols...))
}
func (l linkClientPermissionDo) Join(table schema.Tabler, on ...field.Expr) *linkClientPermissionDo {
return l.withDO(l.DO.Join(table, on...))
}
func (l linkClientPermissionDo) LeftJoin(table schema.Tabler, on ...field.Expr) *linkClientPermissionDo {
return l.withDO(l.DO.LeftJoin(table, on...))
}
func (l linkClientPermissionDo) RightJoin(table schema.Tabler, on ...field.Expr) *linkClientPermissionDo {
return l.withDO(l.DO.RightJoin(table, on...))
}
func (l linkClientPermissionDo) Group(cols ...field.Expr) *linkClientPermissionDo {
return l.withDO(l.DO.Group(cols...))
}
func (l linkClientPermissionDo) Having(conds ...gen.Condition) *linkClientPermissionDo {
return l.withDO(l.DO.Having(conds...))
}
func (l linkClientPermissionDo) Limit(limit int) *linkClientPermissionDo {
return l.withDO(l.DO.Limit(limit))
}
func (l linkClientPermissionDo) Offset(offset int) *linkClientPermissionDo {
return l.withDO(l.DO.Offset(offset))
}
func (l linkClientPermissionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *linkClientPermissionDo {
return l.withDO(l.DO.Scopes(funcs...))
}
func (l linkClientPermissionDo) Unscoped() *linkClientPermissionDo {
return l.withDO(l.DO.Unscoped())
}
func (l linkClientPermissionDo) Create(values ...*models.LinkClientPermission) error {
if len(values) == 0 {
return nil
}
return l.DO.Create(values)
}
func (l linkClientPermissionDo) CreateInBatches(values []*models.LinkClientPermission, batchSize int) error {
return l.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (l linkClientPermissionDo) Save(values ...*models.LinkClientPermission) error {
if len(values) == 0 {
return nil
}
return l.DO.Save(values)
}
func (l linkClientPermissionDo) First() (*models.LinkClientPermission, error) {
if result, err := l.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.LinkClientPermission), nil
}
}
func (l linkClientPermissionDo) Take() (*models.LinkClientPermission, error) {
if result, err := l.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.LinkClientPermission), nil
}
}
func (l linkClientPermissionDo) Last() (*models.LinkClientPermission, error) {
if result, err := l.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.LinkClientPermission), nil
}
}
func (l linkClientPermissionDo) Find() ([]*models.LinkClientPermission, error) {
result, err := l.DO.Find()
return result.([]*models.LinkClientPermission), err
}
func (l linkClientPermissionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.LinkClientPermission, err error) {
buf := make([]*models.LinkClientPermission, 0, batchSize)
err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (l linkClientPermissionDo) FindInBatches(result *[]*models.LinkClientPermission, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return l.DO.FindInBatches(result, batchSize, fc)
}
func (l linkClientPermissionDo) Attrs(attrs ...field.AssignExpr) *linkClientPermissionDo {
return l.withDO(l.DO.Attrs(attrs...))
}
func (l linkClientPermissionDo) Assign(attrs ...field.AssignExpr) *linkClientPermissionDo {
return l.withDO(l.DO.Assign(attrs...))
}
func (l linkClientPermissionDo) Joins(fields ...field.RelationField) *linkClientPermissionDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Joins(_f))
}
return &l
}
func (l linkClientPermissionDo) Preload(fields ...field.RelationField) *linkClientPermissionDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Preload(_f))
}
return &l
}
func (l linkClientPermissionDo) FirstOrInit() (*models.LinkClientPermission, error) {
if result, err := l.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.LinkClientPermission), nil
}
}
func (l linkClientPermissionDo) FirstOrCreate() (*models.LinkClientPermission, error) {
if result, err := l.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.LinkClientPermission), nil
}
}
func (l linkClientPermissionDo) FindByPage(offset int, limit int) (result []*models.LinkClientPermission, count int64, err error) {
result, err = l.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = l.Offset(-1).Limit(-1).Count()
return
}
func (l linkClientPermissionDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = l.Count()
if err != nil {
return
}
err = l.Offset(offset).Limit(limit).Scan(result)
return
}
func (l linkClientPermissionDo) Scan(result interface{}) (err error) {
return l.DO.Scan(result)
}
func (l linkClientPermissionDo) Delete(models ...*models.LinkClientPermission) (result gen.ResultInfo, err error) {
return l.DO.Delete(models)
}
func (l *linkClientPermissionDo) withDO(do gen.Dao) *linkClientPermissionDo {
l.DO = *do.(*gen.DO)
return l
}

327
web/queries/link_user_role.gen.go Normal file
View File

@@ -0,0 +1,327 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newLinkUserRole(db *gorm.DB, opts ...gen.DOOption) linkUserRole {
_linkUserRole := linkUserRole{}
_linkUserRole.linkUserRoleDo.UseDB(db, opts...)
_linkUserRole.linkUserRoleDo.UseModel(&models.LinkUserRole{})
tableName := _linkUserRole.linkUserRoleDo.TableName()
_linkUserRole.ALL = field.NewAsterisk(tableName)
_linkUserRole.ID = field.NewInt32(tableName, "id")
_linkUserRole.UserID = field.NewInt32(tableName, "user_id")
_linkUserRole.RoleID = field.NewInt32(tableName, "role_id")
_linkUserRole.fillFieldMap()
return _linkUserRole
}
type linkUserRole struct {
linkUserRoleDo
ALL field.Asterisk
ID field.Int32
UserID field.Int32
RoleID field.Int32
fieldMap map[string]field.Expr
}
func (l linkUserRole) Table(newTableName string) *linkUserRole {
l.linkUserRoleDo.UseTable(newTableName)
return l.updateTableName(newTableName)
}
func (l linkUserRole) As(alias string) *linkUserRole {
l.linkUserRoleDo.DO = *(l.linkUserRoleDo.As(alias).(*gen.DO))
return l.updateTableName(alias)
}
func (l *linkUserRole) updateTableName(table string) *linkUserRole {
l.ALL = field.NewAsterisk(table)
l.ID = field.NewInt32(table, "id")
l.UserID = field.NewInt32(table, "user_id")
l.RoleID = field.NewInt32(table, "role_id")
l.fillFieldMap()
return l
}
func (l *linkUserRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := l.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (l *linkUserRole) fillFieldMap() {
l.fieldMap = make(map[string]field.Expr, 3)
l.fieldMap["id"] = l.ID
l.fieldMap["user_id"] = l.UserID
l.fieldMap["role_id"] = l.RoleID
}
func (l linkUserRole) clone(db *gorm.DB) linkUserRole {
l.linkUserRoleDo.ReplaceConnPool(db.Statement.ConnPool)
return l
}
func (l linkUserRole) replaceDB(db *gorm.DB) linkUserRole {
l.linkUserRoleDo.ReplaceDB(db)
return l
}
type linkUserRoleDo struct{ gen.DO }
func (l linkUserRoleDo) Debug() *linkUserRoleDo {
return l.withDO(l.DO.Debug())
}
func (l linkUserRoleDo) WithContext(ctx context.Context) *linkUserRoleDo {
return l.withDO(l.DO.WithContext(ctx))
}
func (l linkUserRoleDo) ReadDB() *linkUserRoleDo {
return l.Clauses(dbresolver.Read)
}
func (l linkUserRoleDo) WriteDB() *linkUserRoleDo {
return l.Clauses(dbresolver.Write)
}
func (l linkUserRoleDo) Session(config *gorm.Session) *linkUserRoleDo {
return l.withDO(l.DO.Session(config))
}
func (l linkUserRoleDo) Clauses(conds ...clause.Expression) *linkUserRoleDo {
return l.withDO(l.DO.Clauses(conds...))
}
func (l linkUserRoleDo) Returning(value interface{}, columns ...string) *linkUserRoleDo {
return l.withDO(l.DO.Returning(value, columns...))
}
func (l linkUserRoleDo) Not(conds ...gen.Condition) *linkUserRoleDo {
return l.withDO(l.DO.Not(conds...))
}
func (l linkUserRoleDo) Or(conds ...gen.Condition) *linkUserRoleDo {
return l.withDO(l.DO.Or(conds...))
}
func (l linkUserRoleDo) Select(conds ...field.Expr) *linkUserRoleDo {
return l.withDO(l.DO.Select(conds...))
}
func (l linkUserRoleDo) Where(conds ...gen.Condition) *linkUserRoleDo {
return l.withDO(l.DO.Where(conds...))
}
func (l linkUserRoleDo) Order(conds ...field.Expr) *linkUserRoleDo {
return l.withDO(l.DO.Order(conds...))
}
func (l linkUserRoleDo) Distinct(cols ...field.Expr) *linkUserRoleDo {
return l.withDO(l.DO.Distinct(cols...))
}
func (l linkUserRoleDo) Omit(cols ...field.Expr) *linkUserRoleDo {
return l.withDO(l.DO.Omit(cols...))
}
func (l linkUserRoleDo) Join(table schema.Tabler, on ...field.Expr) *linkUserRoleDo {
return l.withDO(l.DO.Join(table, on...))
}
func (l linkUserRoleDo) LeftJoin(table schema.Tabler, on ...field.Expr) *linkUserRoleDo {
return l.withDO(l.DO.LeftJoin(table, on...))
}
func (l linkUserRoleDo) RightJoin(table schema.Tabler, on ...field.Expr) *linkUserRoleDo {
return l.withDO(l.DO.RightJoin(table, on...))
}
func (l linkUserRoleDo) Group(cols ...field.Expr) *linkUserRoleDo {
return l.withDO(l.DO.Group(cols...))
}
func (l linkUserRoleDo) Having(conds ...gen.Condition) *linkUserRoleDo {
return l.withDO(l.DO.Having(conds...))
}
func (l linkUserRoleDo) Limit(limit int) *linkUserRoleDo {
return l.withDO(l.DO.Limit(limit))
}
func (l linkUserRoleDo) Offset(offset int) *linkUserRoleDo {
return l.withDO(l.DO.Offset(offset))
}
func (l linkUserRoleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *linkUserRoleDo {
return l.withDO(l.DO.Scopes(funcs...))
}
func (l linkUserRoleDo) Unscoped() *linkUserRoleDo {
return l.withDO(l.DO.Unscoped())
}
func (l linkUserRoleDo) Create(values ...*models.LinkUserRole) error {
if len(values) == 0 {
return nil
}
return l.DO.Create(values)
}
func (l linkUserRoleDo) CreateInBatches(values []*models.LinkUserRole, batchSize int) error {
return l.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (l linkUserRoleDo) Save(values ...*models.LinkUserRole) error {
if len(values) == 0 {
return nil
}
return l.DO.Save(values)
}
func (l linkUserRoleDo) First() (*models.LinkUserRole, error) {
if result, err := l.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRole), nil
}
}
func (l linkUserRoleDo) Take() (*models.LinkUserRole, error) {
if result, err := l.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRole), nil
}
}
func (l linkUserRoleDo) Last() (*models.LinkUserRole, error) {
if result, err := l.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRole), nil
}
}
func (l linkUserRoleDo) Find() ([]*models.LinkUserRole, error) {
result, err := l.DO.Find()
return result.([]*models.LinkUserRole), err
}
func (l linkUserRoleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.LinkUserRole, err error) {
buf := make([]*models.LinkUserRole, 0, batchSize)
err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (l linkUserRoleDo) FindInBatches(result *[]*models.LinkUserRole, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return l.DO.FindInBatches(result, batchSize, fc)
}
func (l linkUserRoleDo) Attrs(attrs ...field.AssignExpr) *linkUserRoleDo {
return l.withDO(l.DO.Attrs(attrs...))
}
func (l linkUserRoleDo) Assign(attrs ...field.AssignExpr) *linkUserRoleDo {
return l.withDO(l.DO.Assign(attrs...))
}
func (l linkUserRoleDo) Joins(fields ...field.RelationField) *linkUserRoleDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Joins(_f))
}
return &l
}
func (l linkUserRoleDo) Preload(fields ...field.RelationField) *linkUserRoleDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Preload(_f))
}
return &l
}
func (l linkUserRoleDo) FirstOrInit() (*models.LinkUserRole, error) {
if result, err := l.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRole), nil
}
}
func (l linkUserRoleDo) FirstOrCreate() (*models.LinkUserRole, error) {
if result, err := l.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRole), nil
}
}
func (l linkUserRoleDo) FindByPage(offset int, limit int) (result []*models.LinkUserRole, count int64, err error) {
result, err = l.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = l.Offset(-1).Limit(-1).Count()
return
}
func (l linkUserRoleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = l.Count()
if err != nil {
return
}
err = l.Offset(offset).Limit(limit).Scan(result)
return
}
func (l linkUserRoleDo) Scan(result interface{}) (err error) {
return l.DO.Scan(result)
}
func (l linkUserRoleDo) Delete(models ...*models.LinkUserRole) (result gen.ResultInfo, err error) {
return l.DO.Delete(models)
}
func (l *linkUserRoleDo) withDO(do gen.Dao) *linkUserRoleDo {
l.DO = *do.(*gen.DO)
return l
}

327
web/queries/link_user_role_permission.gen.go Normal file
View File

@@ -0,0 +1,327 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newLinkUserRolePermission(db *gorm.DB, opts ...gen.DOOption) linkUserRolePermission {
_linkUserRolePermission := linkUserRolePermission{}
_linkUserRolePermission.linkUserRolePermissionDo.UseDB(db, opts...)
_linkUserRolePermission.linkUserRolePermissionDo.UseModel(&models.LinkUserRolePermission{})
tableName := _linkUserRolePermission.linkUserRolePermissionDo.TableName()
_linkUserRolePermission.ALL = field.NewAsterisk(tableName)
_linkUserRolePermission.ID = field.NewInt32(tableName, "id")
_linkUserRolePermission.RoleID = field.NewInt32(tableName, "role_id")
_linkUserRolePermission.PermissionID = field.NewInt32(tableName, "permission_id")
_linkUserRolePermission.fillFieldMap()
return _linkUserRolePermission
}
type linkUserRolePermission struct {
linkUserRolePermissionDo
ALL field.Asterisk
ID field.Int32
RoleID field.Int32
PermissionID field.Int32
fieldMap map[string]field.Expr
}
func (l linkUserRolePermission) Table(newTableName string) *linkUserRolePermission {
l.linkUserRolePermissionDo.UseTable(newTableName)
return l.updateTableName(newTableName)
}
func (l linkUserRolePermission) As(alias string) *linkUserRolePermission {
l.linkUserRolePermissionDo.DO = *(l.linkUserRolePermissionDo.As(alias).(*gen.DO))
return l.updateTableName(alias)
}
func (l *linkUserRolePermission) updateTableName(table string) *linkUserRolePermission {
l.ALL = field.NewAsterisk(table)
l.ID = field.NewInt32(table, "id")
l.RoleID = field.NewInt32(table, "role_id")
l.PermissionID = field.NewInt32(table, "permission_id")
l.fillFieldMap()
return l
}
func (l *linkUserRolePermission) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := l.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (l *linkUserRolePermission) fillFieldMap() {
l.fieldMap = make(map[string]field.Expr, 3)
l.fieldMap["id"] = l.ID
l.fieldMap["role_id"] = l.RoleID
l.fieldMap["permission_id"] = l.PermissionID
}
func (l linkUserRolePermission) clone(db *gorm.DB) linkUserRolePermission {
l.linkUserRolePermissionDo.ReplaceConnPool(db.Statement.ConnPool)
return l
}
func (l linkUserRolePermission) replaceDB(db *gorm.DB) linkUserRolePermission {
l.linkUserRolePermissionDo.ReplaceDB(db)
return l
}
type linkUserRolePermissionDo struct{ gen.DO }
func (l linkUserRolePermissionDo) Debug() *linkUserRolePermissionDo {
return l.withDO(l.DO.Debug())
}
func (l linkUserRolePermissionDo) WithContext(ctx context.Context) *linkUserRolePermissionDo {
return l.withDO(l.DO.WithContext(ctx))
}
func (l linkUserRolePermissionDo) ReadDB() *linkUserRolePermissionDo {
return l.Clauses(dbresolver.Read)
}
func (l linkUserRolePermissionDo) WriteDB() *linkUserRolePermissionDo {
return l.Clauses(dbresolver.Write)
}
func (l linkUserRolePermissionDo) Session(config *gorm.Session) *linkUserRolePermissionDo {
return l.withDO(l.DO.Session(config))
}
func (l linkUserRolePermissionDo) Clauses(conds ...clause.Expression) *linkUserRolePermissionDo {
return l.withDO(l.DO.Clauses(conds...))
}
func (l linkUserRolePermissionDo) Returning(value interface{}, columns ...string) *linkUserRolePermissionDo {
return l.withDO(l.DO.Returning(value, columns...))
}
func (l linkUserRolePermissionDo) Not(conds ...gen.Condition) *linkUserRolePermissionDo {
return l.withDO(l.DO.Not(conds...))
}
func (l linkUserRolePermissionDo) Or(conds ...gen.Condition) *linkUserRolePermissionDo {
return l.withDO(l.DO.Or(conds...))
}
func (l linkUserRolePermissionDo) Select(conds ...field.Expr) *linkUserRolePermissionDo {
return l.withDO(l.DO.Select(conds...))
}
func (l linkUserRolePermissionDo) Where(conds ...gen.Condition) *linkUserRolePermissionDo {
return l.withDO(l.DO.Where(conds...))
}
func (l linkUserRolePermissionDo) Order(conds ...field.Expr) *linkUserRolePermissionDo {
return l.withDO(l.DO.Order(conds...))
}
func (l linkUserRolePermissionDo) Distinct(cols ...field.Expr) *linkUserRolePermissionDo {
return l.withDO(l.DO.Distinct(cols...))
}
func (l linkUserRolePermissionDo) Omit(cols ...field.Expr) *linkUserRolePermissionDo {
return l.withDO(l.DO.Omit(cols...))
}
func (l linkUserRolePermissionDo) Join(table schema.Tabler, on ...field.Expr) *linkUserRolePermissionDo {
return l.withDO(l.DO.Join(table, on...))
}
func (l linkUserRolePermissionDo) LeftJoin(table schema.Tabler, on ...field.Expr) *linkUserRolePermissionDo {
return l.withDO(l.DO.LeftJoin(table, on...))
}
func (l linkUserRolePermissionDo) RightJoin(table schema.Tabler, on ...field.Expr) *linkUserRolePermissionDo {
return l.withDO(l.DO.RightJoin(table, on...))
}
func (l linkUserRolePermissionDo) Group(cols ...field.Expr) *linkUserRolePermissionDo {
return l.withDO(l.DO.Group(cols...))
}
func (l linkUserRolePermissionDo) Having(conds ...gen.Condition) *linkUserRolePermissionDo {
return l.withDO(l.DO.Having(conds...))
}
func (l linkUserRolePermissionDo) Limit(limit int) *linkUserRolePermissionDo {
return l.withDO(l.DO.Limit(limit))
}
func (l linkUserRolePermissionDo) Offset(offset int) *linkUserRolePermissionDo {
return l.withDO(l.DO.Offset(offset))
}
func (l linkUserRolePermissionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *linkUserRolePermissionDo {
return l.withDO(l.DO.Scopes(funcs...))
}
func (l linkUserRolePermissionDo) Unscoped() *linkUserRolePermissionDo {
return l.withDO(l.DO.Unscoped())
}
func (l linkUserRolePermissionDo) Create(values ...*models.LinkUserRolePermission) error {
if len(values) == 0 {
return nil
}
return l.DO.Create(values)
}
func (l linkUserRolePermissionDo) CreateInBatches(values []*models.LinkUserRolePermission, batchSize int) error {
return l.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (l linkUserRolePermissionDo) Save(values ...*models.LinkUserRolePermission) error {
if len(values) == 0 {
return nil
}
return l.DO.Save(values)
}
func (l linkUserRolePermissionDo) First() (*models.LinkUserRolePermission, error) {
if result, err := l.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRolePermission), nil
}
}
func (l linkUserRolePermissionDo) Take() (*models.LinkUserRolePermission, error) {
if result, err := l.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRolePermission), nil
}
}
func (l linkUserRolePermissionDo) Last() (*models.LinkUserRolePermission, error) {
if result, err := l.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRolePermission), nil
}
}
func (l linkUserRolePermissionDo) Find() ([]*models.LinkUserRolePermission, error) {
result, err := l.DO.Find()
return result.([]*models.LinkUserRolePermission), err
}
func (l linkUserRolePermissionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.LinkUserRolePermission, err error) {
buf := make([]*models.LinkUserRolePermission, 0, batchSize)
err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (l linkUserRolePermissionDo) FindInBatches(result *[]*models.LinkUserRolePermission, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return l.DO.FindInBatches(result, batchSize, fc)
}
func (l linkUserRolePermissionDo) Attrs(attrs ...field.AssignExpr) *linkUserRolePermissionDo {
return l.withDO(l.DO.Attrs(attrs...))
}
func (l linkUserRolePermissionDo) Assign(attrs ...field.AssignExpr) *linkUserRolePermissionDo {
return l.withDO(l.DO.Assign(attrs...))
}
func (l linkUserRolePermissionDo) Joins(fields ...field.RelationField) *linkUserRolePermissionDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Joins(_f))
}
return &l
}
func (l linkUserRolePermissionDo) Preload(fields ...field.RelationField) *linkUserRolePermissionDo {
for _, _f := range fields {
l = *l.withDO(l.DO.Preload(_f))
}
return &l
}
func (l linkUserRolePermissionDo) FirstOrInit() (*models.LinkUserRolePermission, error) {
if result, err := l.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRolePermission), nil
}
}
func (l linkUserRolePermissionDo) FirstOrCreate() (*models.LinkUserRolePermission, error) {
if result, err := l.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.LinkUserRolePermission), nil
}
}
func (l linkUserRolePermissionDo) FindByPage(offset int, limit int) (result []*models.LinkUserRolePermission, count int64, err error) {
result, err = l.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = l.Offset(-1).Limit(-1).Count()
return
}
func (l linkUserRolePermissionDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = l.Count()
if err != nil {
return
}
err = l.Offset(offset).Limit(limit).Scan(result)
return
}
func (l linkUserRolePermissionDo) Scan(result interface{}) (err error) {
return l.DO.Scan(result)
}
func (l linkUserRolePermissionDo) Delete(models ...*models.LinkUserRolePermission) (result gen.ResultInfo, err error) {
return l.DO.Delete(models)
}
func (l *linkUserRolePermissionDo) withDO(do gen.Dao) *linkUserRolePermissionDo {
l.DO = *do.(*gen.DO)
return l
}

134
web/queries/logs_login.gen.go
View File

@@ -28,13 +28,23 @@ func newLogsLogin(db *gorm.DB, opts ...gen.DOOption) logsLogin {
tableName := _logsLogin.logsLoginDo.TableName()
_logsLogin.ALL = field.NewAsterisk(tableName)
_logsLogin.ID = field.NewInt32(tableName, "id")
_logsLogin.IP = field.NewString(tableName, "ip")
_logsLogin.IP = field.NewField(tableName, "ip")
_logsLogin.UA = field.NewString(tableName, "ua")
_logsLogin.GrantType = field.NewString(tableName, "grant_type")
_logsLogin.PasswordGrantType = field.NewString(tableName, "password_grant_type")
_logsLogin.PasswordType = field.NewString(tableName, "password_type")
_logsLogin.Success = field.NewBool(tableName, "success")
_logsLogin.UserID = field.NewInt32(tableName, "user_id")
_logsLogin.Time = field.NewField(tableName, "time")
_logsLogin.Time = field.NewTime(tableName, "time")
_logsLogin.User = logsLoginBelongsToUser{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("User", "models.User"),
Admin: struct {
field.RelationField
}{
RelationField: field.NewRelation("User.Admin", "models.Admin"),
},
}
_logsLogin.fillFieldMap()
@@ -44,15 +54,16 @@ func newLogsLogin(db *gorm.DB, opts ...gen.DOOption) logsLogin {
type logsLogin struct {
logsLoginDo
ALL field.Asterisk
ID field.Int32 // 登录日志ID
IP field.String // IP地址
UA field.String // 用户代理
GrantType field.String // 授权类型：authorization_code-授权码模式，client_credentials-客户端凭证模式，refresh_token-刷新令牌模式，password-密码模式
PasswordGrantType field.String // 密码模式子授权类型：password-账号密码，phone_code-手机验证码，email_code-邮箱验证码
Success field.Bool // 登录是否成功
UserID field.Int32 // 用户ID
Time field.Field // 登录时间
ALL field.Asterisk
ID field.Int32
IP field.Field
UA field.String
GrantType field.String
PasswordType field.String
Success field.Bool
UserID field.Int32
Time field.Time
User logsLoginBelongsToUser
fieldMap map[string]field.Expr
}
@@ -70,13 +81,13 @@ func (l logsLogin) As(alias string) *logsLogin {
func (l *logsLogin) updateTableName(table string) *logsLogin {
l.ALL = field.NewAsterisk(table)
l.ID = field.NewInt32(table, "id")
l.IP = field.NewString(table, "ip")
l.IP = field.NewField(table, "ip")
l.UA = field.NewString(table, "ua")
l.GrantType = field.NewString(table, "grant_type")
l.PasswordGrantType = field.NewString(table, "password_grant_type")
l.PasswordType = field.NewString(table, "password_type")
l.Success = field.NewBool(table, "success")
l.UserID = field.NewInt32(table, "user_id")
l.Time = field.NewField(table, "time")
l.Time = field.NewTime(table, "time")
l.fillFieldMap()
@@ -93,27 +104,116 @@ func (l *logsLogin) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (l *logsLogin) fillFieldMap() {
l.fieldMap = make(map[string]field.Expr, 8)
l.fieldMap = make(map[string]field.Expr, 9)
l.fieldMap["id"] = l.ID
l.fieldMap["ip"] = l.IP
l.fieldMap["ua"] = l.UA
l.fieldMap["grant_type"] = l.GrantType
l.fieldMap["password_grant_type"] = l.PasswordGrantType
l.fieldMap["password_type"] = l.PasswordType
l.fieldMap["success"] = l.Success
l.fieldMap["user_id"] = l.UserID
l.fieldMap["time"] = l.Time
}
func (l logsLogin) clone(db *gorm.DB) logsLogin {
l.logsLoginDo.ReplaceConnPool(db.Statement.ConnPool)
l.User.db = db.Session(&gorm.Session{Initialized: true})
l.User.db.Statement.ConnPool = db.Statement.ConnPool
return l
}
func (l logsLogin) replaceDB(db *gorm.DB) logsLogin {
l.logsLoginDo.ReplaceDB(db)
l.User.db = db.Session(&gorm.Session{})
return l
}
type logsLoginBelongsToUser struct {
db *gorm.DB
field.RelationField
Admin struct {
field.RelationField
}
}
func (a logsLoginBelongsToUser) Where(conds ...field.Expr) *logsLoginBelongsToUser {
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 logsLoginBelongsToUser) WithContext(ctx context.Context) *logsLoginBelongsToUser {
a.db = a.db.WithContext(ctx)
return &a
}
func (a logsLoginBelongsToUser) Session(session *gorm.Session) *logsLoginBelongsToUser {
a.db = a.db.Session(session)
return &a
}
func (a logsLoginBelongsToUser) Model(m *models.LogsLogin) *logsLoginBelongsToUserTx {
return &logsLoginBelongsToUserTx{a.db.Model(m).Association(a.Name())}
}
func (a logsLoginBelongsToUser) Unscoped() *logsLoginBelongsToUser {
a.db = a.db.Unscoped()
return &a
}
type logsLoginBelongsToUserTx struct{ tx *gorm.Association }
func (a logsLoginBelongsToUserTx) Find() (result *models.User, err error) {
return result, a.tx.Find(&result)
}
func (a logsLoginBelongsToUserTx) Append(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a logsLoginBelongsToUserTx) Replace(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a logsLoginBelongsToUserTx) Delete(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a logsLoginBelongsToUserTx) Clear() error {
return a.tx.Clear()
}
func (a logsLoginBelongsToUserTx) Count() int64 {
return a.tx.Count()
}
func (a logsLoginBelongsToUserTx) Unscoped() *logsLoginBelongsToUserTx {
a.tx = a.tx.Unscoped()
return &a
}
type logsLoginDo struct{ gen.DO }
func (l logsLoginDo) Debug() *logsLoginDo {

228
web/queries/logs_request.gen.go
View File

@@ -28,16 +28,32 @@ func newLogsRequest(db *gorm.DB, opts ...gen.DOOption) logsRequest {
tableName := _logsRequest.logsRequestDo.TableName()
_logsRequest.ALL = field.NewAsterisk(tableName)
_logsRequest.ID = field.NewInt32(tableName, "id")
_logsRequest.IP = field.NewString(tableName, "ip")
_logsRequest.IP = field.NewField(tableName, "ip")
_logsRequest.UA = field.NewString(tableName, "ua")
_logsRequest.UserID = field.NewInt32(tableName, "user_id")
_logsRequest.ClientID = field.NewInt32(tableName, "client_id")
_logsRequest.Method = field.NewString(tableName, "method")
_logsRequest.Path = field.NewString(tableName, "path")
_logsRequest.Status = field.NewInt32(tableName, "status")
_logsRequest.Status = field.NewInt16(tableName, "status")
_logsRequest.Error = field.NewString(tableName, "error")
_logsRequest.Time = field.NewField(tableName, "time")
_logsRequest.Time = field.NewTime(tableName, "time")
_logsRequest.Latency = field.NewString(tableName, "latency")
_logsRequest.Client = logsRequestHasOneClient{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Client", "models.Client"),
}
_logsRequest.User = logsRequestBelongsToUser{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("User", "models.User"),
Admin: struct {
field.RelationField
}{
RelationField: field.NewRelation("User.Admin", "models.Admin"),
},
}
_logsRequest.fillFieldMap()
@@ -48,17 +64,20 @@ type logsRequest struct {
logsRequestDo
ALL field.Asterisk
ID field.Int32 // 访问日志ID
IP field.String // IP地址
UA field.String // 用户代理
UserID field.Int32 // 用户ID
ClientID field.Int32 // 客户端ID
Method field.String // 请求方法
Path field.String // 请求路径
Status field.Int32 // 响应状态码
Error field.String // 错误信息
Time field.Field // 请求时间
Latency field.String // 请求延迟
ID field.Int32
IP field.Field
UA field.String
UserID field.Int32
ClientID field.Int32
Method field.String
Path field.String
Status field.Int16
Error field.String
Time field.Time
Latency field.String
Client logsRequestHasOneClient
User logsRequestBelongsToUser
fieldMap map[string]field.Expr
}
@@ -76,15 +95,15 @@ func (l logsRequest) As(alias string) *logsRequest {
func (l *logsRequest) updateTableName(table string) *logsRequest {
l.ALL = field.NewAsterisk(table)
l.ID = field.NewInt32(table, "id")
l.IP = field.NewString(table, "ip")
l.IP = field.NewField(table, "ip")
l.UA = field.NewString(table, "ua")
l.UserID = field.NewInt32(table, "user_id")
l.ClientID = field.NewInt32(table, "client_id")
l.Method = field.NewString(table, "method")
l.Path = field.NewString(table, "path")
l.Status = field.NewInt32(table, "status")
l.Status = field.NewInt16(table, "status")
l.Error = field.NewString(table, "error")
l.Time = field.NewField(table, "time")
l.Time = field.NewTime(table, "time")
l.Latency = field.NewString(table, "latency")
l.fillFieldMap()
@@ -102,7 +121,7 @@ func (l *logsRequest) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (l *logsRequest) fillFieldMap() {
l.fieldMap = make(map[string]field.Expr, 11)
l.fieldMap = make(map[string]field.Expr, 13)
l.fieldMap["id"] = l.ID
l.fieldMap["ip"] = l.IP
l.fieldMap["ua"] = l.UA
@@ -114,18 +133,191 @@ func (l *logsRequest) fillFieldMap() {
l.fieldMap["error"] = l.Error
l.fieldMap["time"] = l.Time
l.fieldMap["latency"] = l.Latency
}
func (l logsRequest) clone(db *gorm.DB) logsRequest {
l.logsRequestDo.ReplaceConnPool(db.Statement.ConnPool)
l.Client.db = db.Session(&gorm.Session{Initialized: true})
l.Client.db.Statement.ConnPool = db.Statement.ConnPool
l.User.db = db.Session(&gorm.Session{Initialized: true})
l.User.db.Statement.ConnPool = db.Statement.ConnPool
return l
}
func (l logsRequest) replaceDB(db *gorm.DB) logsRequest {
l.logsRequestDo.ReplaceDB(db)
l.Client.db = db.Session(&gorm.Session{})
l.User.db = db.Session(&gorm.Session{})
return l
}
type logsRequestHasOneClient struct {
db *gorm.DB
field.RelationField
}
func (a logsRequestHasOneClient) Where(conds ...field.Expr) *logsRequestHasOneClient {
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 logsRequestHasOneClient) WithContext(ctx context.Context) *logsRequestHasOneClient {
a.db = a.db.WithContext(ctx)
return &a
}
func (a logsRequestHasOneClient) Session(session *gorm.Session) *logsRequestHasOneClient {
a.db = a.db.Session(session)
return &a
}
func (a logsRequestHasOneClient) Model(m *models.LogsRequest) *logsRequestHasOneClientTx {
return &logsRequestHasOneClientTx{a.db.Model(m).Association(a.Name())}
}
func (a logsRequestHasOneClient) Unscoped() *logsRequestHasOneClient {
a.db = a.db.Unscoped()
return &a
}
type logsRequestHasOneClientTx struct{ tx *gorm.Association }
func (a logsRequestHasOneClientTx) Find() (result *models.Client, err error) {
return result, a.tx.Find(&result)
}
func (a logsRequestHasOneClientTx) Append(values ...*models.Client) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a logsRequestHasOneClientTx) Replace(values ...*models.Client) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a logsRequestHasOneClientTx) Delete(values ...*models.Client) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a logsRequestHasOneClientTx) Clear() error {
return a.tx.Clear()
}
func (a logsRequestHasOneClientTx) Count() int64 {
return a.tx.Count()
}
func (a logsRequestHasOneClientTx) Unscoped() *logsRequestHasOneClientTx {
a.tx = a.tx.Unscoped()
return &a
}
type logsRequestBelongsToUser struct {
db *gorm.DB
field.RelationField
Admin struct {
field.RelationField
}
}
func (a logsRequestBelongsToUser) Where(conds ...field.Expr) *logsRequestBelongsToUser {
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 logsRequestBelongsToUser) WithContext(ctx context.Context) *logsRequestBelongsToUser {
a.db = a.db.WithContext(ctx)
return &a
}
func (a logsRequestBelongsToUser) Session(session *gorm.Session) *logsRequestBelongsToUser {
a.db = a.db.Session(session)
return &a
}
func (a logsRequestBelongsToUser) Model(m *models.LogsRequest) *logsRequestBelongsToUserTx {
return &logsRequestBelongsToUserTx{a.db.Model(m).Association(a.Name())}
}
func (a logsRequestBelongsToUser) Unscoped() *logsRequestBelongsToUser {
a.db = a.db.Unscoped()
return &a
}
type logsRequestBelongsToUserTx struct{ tx *gorm.Association }
func (a logsRequestBelongsToUserTx) Find() (result *models.User, err error) {
return result, a.tx.Find(&result)
}
func (a logsRequestBelongsToUserTx) Append(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a logsRequestBelongsToUserTx) Replace(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a logsRequestBelongsToUserTx) Delete(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a logsRequestBelongsToUserTx) Clear() error {
return a.tx.Clear()
}
func (a logsRequestBelongsToUserTx) Count() int64 {
return a.tx.Count()
}
func (a logsRequestBelongsToUserTx) Unscoped() *logsRequestBelongsToUserTx {
a.tx = a.tx.Unscoped()
return &a
}
type logsRequestDo struct{ gen.DO }
func (l logsRequestDo) Debug() *logsRequestDo {

12
web/queries/logs_user_bandwidth.gen.go
View File

@@ -30,7 +30,7 @@ func newLogsUserBandwidth(db *gorm.DB, opts ...gen.DOOption) logsUserBandwidth {
_logsUserBandwidth.ID = field.NewInt32(tableName, "id")
_logsUserBandwidth.UserID = field.NewInt32(tableName, "user_id")
_logsUserBandwidth.Bandwidth = field.NewInt32(tableName, "bandwidth")
_logsUserBandwidth.Time = field.NewField(tableName, "time")
_logsUserBandwidth.Time = field.NewTime(tableName, "time")
_logsUserBandwidth.fillFieldMap()
@@ -41,10 +41,10 @@ type logsUserBandwidth struct {
logsUserBandwidthDo
ALL field.Asterisk
ID field.Int32 // 日志ID
UserID field.Int32 // 用户ID
Bandwidth field.Int32 // 带宽使用量(KB)
Time field.Field // 记录时间
ID field.Int32
UserID field.Int32
Bandwidth field.Int32
Time field.Time
fieldMap map[string]field.Expr
}
@@ -64,7 +64,7 @@ func (l *logsUserBandwidth) updateTableName(table string) *logsUserBandwidth {
l.ID = field.NewInt32(table, "id")
l.UserID = field.NewInt32(table, "user_id")
l.Bandwidth = field.NewInt32(table, "bandwidth")
l.Time = field.NewField(table, "time")
l.Time = field.NewTime(table, "time")
l.fillFieldMap()

32
web/queries/logs_user_usage.gen.go
View File

@@ -33,9 +33,9 @@ func newLogsUserUsage(db *gorm.DB, opts ...gen.DOOption) logsUserUsage {
_logsUserUsage.Count_ = field.NewInt32(tableName, "count")
_logsUserUsage.Prov = field.NewString(tableName, "prov")
_logsUserUsage.City = field.NewString(tableName, "city")
_logsUserUsage.Isp = field.NewString(tableName, "isp")
_logsUserUsage.IP = field.NewString(tableName, "ip")
_logsUserUsage.Time = field.NewField(tableName, "time")
_logsUserUsage.ISP = field.NewString(tableName, "isp")
_logsUserUsage.IP = field.NewField(tableName, "ip")
_logsUserUsage.Time = field.NewTime(tableName, "time")
_logsUserUsage.fillFieldMap()
@@ -46,15 +46,15 @@ type logsUserUsage struct {
logsUserUsageDo
ALL field.Asterisk
ID field.Int32 // 日志ID
UserID field.Int32 // 用户ID
ResourceID field.Int32 // 套餐ID
Count_ field.Int32 // 数量
Prov field.String // 省份
City field.String // 城市
Isp field.String // 运营商
IP field.String // IP地址
Time field.Field // 提取时间
ID field.Int32
UserID field.Int32
ResourceID field.Int32
Count_ field.Int32
Prov field.String
City field.String
ISP field.String
IP field.Field
Time field.Time
fieldMap map[string]field.Expr
}
@@ -77,9 +77,9 @@ func (l *logsUserUsage) updateTableName(table string) *logsUserUsage {
l.Count_ = field.NewInt32(table, "count")
l.Prov = field.NewString(table, "prov")
l.City = field.NewString(table, "city")
l.Isp = field.NewString(table, "isp")
l.IP = field.NewString(table, "ip")
l.Time = field.NewField(table, "time")
l.ISP = field.NewString(table, "isp")
l.IP = field.NewField(table, "ip")
l.Time = field.NewTime(table, "time")
l.fillFieldMap()
@@ -103,7 +103,7 @@ func (l *logsUserUsage) fillFieldMap() {
l.fieldMap["count"] = l.Count_
l.fieldMap["prov"] = l.Prov
l.fieldMap["city"] = l.City
l.fieldMap["isp"] = l.Isp
l.fieldMap["isp"] = l.ISP
l.fieldMap["ip"] = l.IP
l.fieldMap["time"] = l.Time
}

234
web/queries/permission.gen.go
View File

@@ -28,12 +28,33 @@ func newPermission(db *gorm.DB, opts ...gen.DOOption) permission {
tableName := _permission.permissionDo.TableName()
_permission.ALL = field.NewAsterisk(tableName)
_permission.ID = field.NewInt32(tableName, "id")
_permission.CreatedAt = field.NewTime(tableName, "created_at")
_permission.UpdatedAt = field.NewTime(tableName, "updated_at")
_permission.DeletedAt = field.NewField(tableName, "deleted_at")
_permission.ParentID = field.NewInt32(tableName, "parent_id")
_permission.Name = field.NewString(tableName, "name")
_permission.Description = field.NewString(tableName, "description")
_permission.CreatedAt = field.NewField(tableName, "created_at")
_permission.UpdatedAt = field.NewField(tableName, "updated_at")
_permission.DeletedAt = field.NewField(tableName, "deleted_at")
_permission.Children = permissionHasManyChildren{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Children", "models.Permission"),
Parent: struct {
field.RelationField
}{
RelationField: field.NewRelation("Children.Parent", "models.Permission"),
},
Children: struct {
field.RelationField
}{
RelationField: field.NewRelation("Children.Children", "models.Permission"),
},
}
_permission.Parent = permissionBelongsToParent{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Parent", "models.Permission"),
}
_permission.fillFieldMap()
@@ -44,13 +65,16 @@ type permission struct {
permissionDo
ALL field.Asterisk
ID field.Int32 // 权限ID
ParentID field.Int32 // 父权限ID
Name field.String // 权限名称
Description field.String // 权限描述
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
ParentID field.Int32
Name field.String
Description field.String
Children permissionHasManyChildren
Parent permissionBelongsToParent
fieldMap map[string]field.Expr
}
@@ -68,12 +92,12 @@ func (p permission) As(alias string) *permission {
func (p *permission) updateTableName(table string) *permission {
p.ALL = field.NewAsterisk(table)
p.ID = field.NewInt32(table, "id")
p.CreatedAt = field.NewTime(table, "created_at")
p.UpdatedAt = field.NewTime(table, "updated_at")
p.DeletedAt = field.NewField(table, "deleted_at")
p.ParentID = field.NewInt32(table, "parent_id")
p.Name = field.NewString(table, "name")
p.Description = field.NewString(table, "description")
p.CreatedAt = field.NewField(table, "created_at")
p.UpdatedAt = field.NewField(table, "updated_at")
p.DeletedAt = field.NewField(table, "deleted_at")
p.fillFieldMap()
@@ -90,26 +114,202 @@ func (p *permission) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (p *permission) fillFieldMap() {
p.fieldMap = make(map[string]field.Expr, 7)
p.fieldMap = make(map[string]field.Expr, 9)
p.fieldMap["id"] = p.ID
p.fieldMap["parent_id"] = p.ParentID
p.fieldMap["name"] = p.Name
p.fieldMap["description"] = p.Description
p.fieldMap["created_at"] = p.CreatedAt
p.fieldMap["updated_at"] = p.UpdatedAt
p.fieldMap["deleted_at"] = p.DeletedAt
p.fieldMap["parent_id"] = p.ParentID
p.fieldMap["name"] = p.Name
p.fieldMap["description"] = p.Description
}
func (p permission) clone(db *gorm.DB) permission {
p.permissionDo.ReplaceConnPool(db.Statement.ConnPool)
p.Children.db = db.Session(&gorm.Session{Initialized: true})
p.Children.db.Statement.ConnPool = db.Statement.ConnPool
p.Parent.db = db.Session(&gorm.Session{Initialized: true})
p.Parent.db.Statement.ConnPool = db.Statement.ConnPool
return p
}
func (p permission) replaceDB(db *gorm.DB) permission {
p.permissionDo.ReplaceDB(db)
p.Children.db = db.Session(&gorm.Session{})
p.Parent.db = db.Session(&gorm.Session{})
return p
}
type permissionHasManyChildren struct {
db *gorm.DB
field.RelationField
Parent struct {
field.RelationField
}
Children struct {
field.RelationField
}
}
func (a permissionHasManyChildren) Where(conds ...field.Expr) *permissionHasManyChildren {
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 permissionHasManyChildren) WithContext(ctx context.Context) *permissionHasManyChildren {
a.db = a.db.WithContext(ctx)
return &a
}
func (a permissionHasManyChildren) Session(session *gorm.Session) *permissionHasManyChildren {
a.db = a.db.Session(session)
return &a
}
func (a permissionHasManyChildren) Model(m *models.Permission) *permissionHasManyChildrenTx {
return &permissionHasManyChildrenTx{a.db.Model(m).Association(a.Name())}
}
func (a permissionHasManyChildren) Unscoped() *permissionHasManyChildren {
a.db = a.db.Unscoped()
return &a
}
type permissionHasManyChildrenTx struct{ tx *gorm.Association }
func (a permissionHasManyChildrenTx) Find() (result []*models.Permission, err error) {
return result, a.tx.Find(&result)
}
func (a permissionHasManyChildrenTx) Append(values ...*models.Permission) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a permissionHasManyChildrenTx) Replace(values ...*models.Permission) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a permissionHasManyChildrenTx) Delete(values ...*models.Permission) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a permissionHasManyChildrenTx) Clear() error {
return a.tx.Clear()
}
func (a permissionHasManyChildrenTx) Count() int64 {
return a.tx.Count()
}
func (a permissionHasManyChildrenTx) Unscoped() *permissionHasManyChildrenTx {
a.tx = a.tx.Unscoped()
return &a
}
type permissionBelongsToParent struct {
db *gorm.DB
field.RelationField
}
func (a permissionBelongsToParent) Where(conds ...field.Expr) *permissionBelongsToParent {
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 permissionBelongsToParent) WithContext(ctx context.Context) *permissionBelongsToParent {
a.db = a.db.WithContext(ctx)
return &a
}
func (a permissionBelongsToParent) Session(session *gorm.Session) *permissionBelongsToParent {
a.db = a.db.Session(session)
return &a
}
func (a permissionBelongsToParent) Model(m *models.Permission) *permissionBelongsToParentTx {
return &permissionBelongsToParentTx{a.db.Model(m).Association(a.Name())}
}
func (a permissionBelongsToParent) Unscoped() *permissionBelongsToParent {
a.db = a.db.Unscoped()
return &a
}
type permissionBelongsToParentTx struct{ tx *gorm.Association }
func (a permissionBelongsToParentTx) Find() (result *models.Permission, err error) {
return result, a.tx.Find(&result)
}
func (a permissionBelongsToParentTx) Append(values ...*models.Permission) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a permissionBelongsToParentTx) Replace(values ...*models.Permission) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a permissionBelongsToParentTx) Delete(values ...*models.Permission) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a permissionBelongsToParentTx) Clear() error {
return a.tx.Clear()
}
func (a permissionBelongsToParentTx) Count() int64 {
return a.tx.Count()
}
func (a permissionBelongsToParentTx) Unscoped() *permissionBelongsToParentTx {
a.tx = a.tx.Unscoped()
return &a
}
type permissionDo struct{ gen.DO }
func (p permissionDo) Debug() *permissionDo {

40
web/queries/product.gen.go
View File

@@ -28,14 +28,14 @@ func newProduct(db *gorm.DB, opts ...gen.DOOption) product {
tableName := _product.productDo.TableName()
_product.ALL = field.NewAsterisk(tableName)
_product.ID = field.NewInt32(tableName, "id")
_product.CreatedAt = field.NewTime(tableName, "created_at")
_product.UpdatedAt = field.NewTime(tableName, "updated_at")
_product.DeletedAt = field.NewField(tableName, "deleted_at")
_product.Code = field.NewString(tableName, "code")
_product.Name = field.NewString(tableName, "name")
_product.Description = field.NewString(tableName, "description")
_product.Sort = field.NewInt32(tableName, "sort")
_product.Status = field.NewInt32(tableName, "status")
_product.CreatedAt = field.NewField(tableName, "created_at")
_product.UpdatedAt = field.NewField(tableName, "updated_at")
_product.DeletedAt = field.NewField(tableName, "deleted_at")
_product.Status = field.NewInt(tableName, "status")
_product.fillFieldMap()
@@ -46,15 +46,15 @@ type product struct {
productDo
ALL field.Asterisk
ID field.Int32 // 产品ID
Code field.String // 产品代码
Name field.String // 产品名称
Description field.String // 产品描述
Sort field.Int32 // 排序
Status field.Int32 // 产品状态：0-禁用，1-正常
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Code field.String
Name field.String
Description field.String
Sort field.Int32
Status field.Int
fieldMap map[string]field.Expr
}
@@ -72,14 +72,14 @@ func (p product) As(alias string) *product {
func (p *product) updateTableName(table string) *product {
p.ALL = field.NewAsterisk(table)
p.ID = field.NewInt32(table, "id")
p.CreatedAt = field.NewTime(table, "created_at")
p.UpdatedAt = field.NewTime(table, "updated_at")
p.DeletedAt = field.NewField(table, "deleted_at")
p.Code = field.NewString(table, "code")
p.Name = field.NewString(table, "name")
p.Description = field.NewString(table, "description")
p.Sort = field.NewInt32(table, "sort")
p.Status = field.NewInt32(table, "status")
p.CreatedAt = field.NewField(table, "created_at")
p.UpdatedAt = field.NewField(table, "updated_at")
p.DeletedAt = field.NewField(table, "deleted_at")
p.Status = field.NewInt(table, "status")
p.fillFieldMap()
@@ -98,14 +98,14 @@ func (p *product) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (p *product) fillFieldMap() {
p.fieldMap = make(map[string]field.Expr, 9)
p.fieldMap["id"] = p.ID
p.fieldMap["created_at"] = p.CreatedAt
p.fieldMap["updated_at"] = p.UpdatedAt
p.fieldMap["deleted_at"] = p.DeletedAt
p.fieldMap["code"] = p.Code
p.fieldMap["name"] = p.Name
p.fieldMap["description"] = p.Description
p.fieldMap["sort"] = p.Sort
p.fieldMap["status"] = p.Status
p.fieldMap["created_at"] = p.CreatedAt
p.fieldMap["updated_at"] = p.UpdatedAt
p.fieldMap["deleted_at"] = p.DeletedAt
}
func (p product) clone(db *gorm.DB) product {

194
web/queries/proxy.gen.go
View File

@@ -28,19 +28,79 @@ func newProxy(db *gorm.DB, opts ...gen.DOOption) proxy {
tableName := _proxy.proxyDo.TableName()
_proxy.ALL = field.NewAsterisk(tableName)
_proxy.ID = field.NewInt32(tableName, "id")
_proxy.Version = field.NewInt32(tableName, "version")
_proxy.Name = field.NewString(tableName, "name")
_proxy.Host = field.NewString(tableName, "host")
_proxy.Secret = field.NewString(tableName, "secret")
_proxy.Type = field.NewInt32(tableName, "type")
_proxy.Status = field.NewInt32(tableName, "status")
_proxy.CreatedAt = field.NewField(tableName, "created_at")
_proxy.UpdatedAt = field.NewField(tableName, "updated_at")
_proxy.CreatedAt = field.NewTime(tableName, "created_at")
_proxy.UpdatedAt = field.NewTime(tableName, "updated_at")
_proxy.DeletedAt = field.NewField(tableName, "deleted_at")
_proxy.Edges = proxyHasManyEdges{
_proxy.Version = field.NewInt32(tableName, "version")
_proxy.Mac = field.NewString(tableName, "mac")
_proxy.IP = field.NewField(tableName, "ip")
_proxy.Secret = field.NewString(tableName, "secret")
_proxy.Type = field.NewInt(tableName, "type")
_proxy.Status = field.NewInt(tableName, "status")
_proxy.Channels = proxyHasManyChannels{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Edges", "models.Edge"),
RelationField: field.NewRelation("Channels", "models.Channel"),
User: struct {
field.RelationField
Admin struct {
field.RelationField
}
}{
RelationField: field.NewRelation("Channels.User", "models.User"),
Admin: struct {
field.RelationField
}{
RelationField: field.NewRelation("Channels.User.Admin", "models.Admin"),
},
},
Resource: struct {
field.RelationField
User struct {
field.RelationField
}
Short struct {
field.RelationField
}
Long struct {
field.RelationField
}
}{
RelationField: field.NewRelation("Channels.Resource", "models.Resource"),
User: struct {
field.RelationField
}{
RelationField: field.NewRelation("Channels.Resource.User", "models.User"),
},
Short: struct {
field.RelationField
}{
RelationField: field.NewRelation("Channels.Resource.Short", "models.ResourceShort"),
},
Long: struct {
field.RelationField
}{
RelationField: field.NewRelation("Channels.Resource.Long", "models.ResourceLong"),
},
},
Proxy: struct {
field.RelationField
Channels struct {
field.RelationField
}
}{
RelationField: field.NewRelation("Channels.Proxy", "models.Proxy"),
Channels: struct {
field.RelationField
}{
RelationField: field.NewRelation("Channels.Proxy.Channels", "models.Channel"),
},
},
Edge: struct {
field.RelationField
}{
RelationField: field.NewRelation("Channels.Edge", "models.Edge"),
},
}
_proxy.fillFieldMap()
@@ -52,17 +112,17 @@ type proxy struct {
proxyDo
ALL field.Asterisk
ID field.Int32 // 代理服务ID
Version field.Int32 // 代理服务版本
Name field.String // 代理服务名称
Host field.String // 代理服务地址
Secret field.String // 代理服务密钥
Type field.Int32 // 代理服务类型：1-三方，2-自有
Status field.Int32 // 代理服务状态：0-离线，1-在线
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
Edges proxyHasManyEdges
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Version field.Int32
Mac field.String
IP field.Field
Secret field.String
Type field.Int
Status field.Int
Channels proxyHasManyChannels
fieldMap map[string]field.Expr
}
@@ -80,15 +140,15 @@ func (p proxy) As(alias string) *proxy {
func (p *proxy) updateTableName(table string) *proxy {
p.ALL = field.NewAsterisk(table)
p.ID = field.NewInt32(table, "id")
p.Version = field.NewInt32(table, "version")
p.Name = field.NewString(table, "name")
p.Host = field.NewString(table, "host")
p.Secret = field.NewString(table, "secret")
p.Type = field.NewInt32(table, "type")
p.Status = field.NewInt32(table, "status")
p.CreatedAt = field.NewField(table, "created_at")
p.UpdatedAt = field.NewField(table, "updated_at")
p.CreatedAt = field.NewTime(table, "created_at")
p.UpdatedAt = field.NewTime(table, "updated_at")
p.DeletedAt = field.NewField(table, "deleted_at")
p.Version = field.NewInt32(table, "version")
p.Mac = field.NewString(table, "mac")
p.IP = field.NewField(table, "ip")
p.Secret = field.NewString(table, "secret")
p.Type = field.NewInt(table, "type")
p.Status = field.NewInt(table, "status")
p.fillFieldMap()
@@ -107,38 +167,66 @@ func (p *proxy) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (p *proxy) fillFieldMap() {
p.fieldMap = make(map[string]field.Expr, 11)
p.fieldMap["id"] = p.ID
p.fieldMap["version"] = p.Version
p.fieldMap["name"] = p.Name
p.fieldMap["host"] = p.Host
p.fieldMap["secret"] = p.Secret
p.fieldMap["type"] = p.Type
p.fieldMap["status"] = p.Status
p.fieldMap["created_at"] = p.CreatedAt
p.fieldMap["updated_at"] = p.UpdatedAt
p.fieldMap["deleted_at"] = p.DeletedAt
p.fieldMap["version"] = p.Version
p.fieldMap["mac"] = p.Mac
p.fieldMap["ip"] = p.IP
p.fieldMap["secret"] = p.Secret
p.fieldMap["type"] = p.Type
p.fieldMap["status"] = p.Status
}
func (p proxy) clone(db *gorm.DB) proxy {
p.proxyDo.ReplaceConnPool(db.Statement.ConnPool)
p.Edges.db = db.Session(&gorm.Session{Initialized: true})
p.Edges.db.Statement.ConnPool = db.Statement.ConnPool
p.Channels.db = db.Session(&gorm.Session{Initialized: true})
p.Channels.db.Statement.ConnPool = db.Statement.ConnPool
return p
}
func (p proxy) replaceDB(db *gorm.DB) proxy {
p.proxyDo.ReplaceDB(db)
p.Edges.db = db.Session(&gorm.Session{})
p.Channels.db = db.Session(&gorm.Session{})
return p
}
type proxyHasManyEdges struct {
type proxyHasManyChannels struct {
db *gorm.DB
field.RelationField
User struct {
field.RelationField
Admin struct {
field.RelationField
}
}
Resource struct {
field.RelationField
User struct {
field.RelationField
}
Short struct {
field.RelationField
}
Long struct {
field.RelationField
}
}
Proxy struct {
field.RelationField
Channels struct {
field.RelationField
}
}
Edge struct {
field.RelationField
}
}
func (a proxyHasManyEdges) Where(conds ...field.Expr) *proxyHasManyEdges {
func (a proxyHasManyChannels) Where(conds ...field.Expr) *proxyHasManyChannels {
if len(conds) == 0 {
return &a
}
@@ -151,32 +239,32 @@ func (a proxyHasManyEdges) Where(conds ...field.Expr) *proxyHasManyEdges {
return &a
}
func (a proxyHasManyEdges) WithContext(ctx context.Context) *proxyHasManyEdges {
func (a proxyHasManyChannels) WithContext(ctx context.Context) *proxyHasManyChannels {
a.db = a.db.WithContext(ctx)
return &a
}
func (a proxyHasManyEdges) Session(session *gorm.Session) *proxyHasManyEdges {
func (a proxyHasManyChannels) Session(session *gorm.Session) *proxyHasManyChannels {
a.db = a.db.Session(session)
return &a
}
func (a proxyHasManyEdges) Model(m *models.Proxy) *proxyHasManyEdgesTx {
return &proxyHasManyEdgesTx{a.db.Model(m).Association(a.Name())}
func (a proxyHasManyChannels) Model(m *models.Proxy) *proxyHasManyChannelsTx {
return &proxyHasManyChannelsTx{a.db.Model(m).Association(a.Name())}
}
func (a proxyHasManyEdges) Unscoped() *proxyHasManyEdges {
func (a proxyHasManyChannels) Unscoped() *proxyHasManyChannels {
a.db = a.db.Unscoped()
return &a
}
type proxyHasManyEdgesTx struct{ tx *gorm.Association }
type proxyHasManyChannelsTx struct{ tx *gorm.Association }
func (a proxyHasManyEdgesTx) Find() (result []*models.Edge, err error) {
func (a proxyHasManyChannelsTx) Find() (result []*models.Channel, err error) {
return result, a.tx.Find(&result)
}
func (a proxyHasManyEdgesTx) Append(values ...*models.Edge) (err error) {
func (a proxyHasManyChannelsTx) Append(values ...*models.Channel) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
@@ -184,7 +272,7 @@ func (a proxyHasManyEdgesTx) Append(values ...*models.Edge) (err error) {
return a.tx.Append(targetValues...)
}
func (a proxyHasManyEdgesTx) Replace(values ...*models.Edge) (err error) {
func (a proxyHasManyChannelsTx) Replace(values ...*models.Channel) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
@@ -192,7 +280,7 @@ func (a proxyHasManyEdgesTx) Replace(values ...*models.Edge) (err error) {
return a.tx.Replace(targetValues...)
}
func (a proxyHasManyEdgesTx) Delete(values ...*models.Edge) (err error) {
func (a proxyHasManyChannelsTx) Delete(values ...*models.Channel) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
@@ -200,15 +288,15 @@ func (a proxyHasManyEdgesTx) Delete(values ...*models.Edge) (err error) {
return a.tx.Delete(targetValues...)
}
func (a proxyHasManyEdgesTx) Clear() error {
func (a proxyHasManyChannelsTx) Clear() error {
return a.tx.Clear()
}
func (a proxyHasManyEdgesTx) Count() int64 {
func (a proxyHasManyChannelsTx) Count() int64 {
return a.tx.Count()
}
func (a proxyHasManyEdgesTx) Unscoped() *proxyHasManyEdgesTx {
func (a proxyHasManyChannelsTx) Unscoped() *proxyHasManyChannelsTx {
a.tx = a.tx.Unscoped()
return &a
}

40
web/queries/refund.gen.go
View File

@@ -28,14 +28,14 @@ func newRefund(db *gorm.DB, opts ...gen.DOOption) refund {
tableName := _refund.refundDo.TableName()
_refund.ALL = field.NewAsterisk(tableName)
_refund.ID = field.NewInt32(tableName, "id")
_refund.CreatedAt = field.NewTime(tableName, "created_at")
_refund.UpdatedAt = field.NewTime(tableName, "updated_at")
_refund.DeletedAt = field.NewField(tableName, "deleted_at")
_refund.TradeID = field.NewInt32(tableName, "trade_id")
_refund.ProductID = field.NewInt32(tableName, "product_id")
_refund.Amount = field.NewField(tableName, "amount")
_refund.Reason = field.NewString(tableName, "reason")
_refund.Status = field.NewInt32(tableName, "status")
_refund.CreatedAt = field.NewField(tableName, "created_at")
_refund.UpdatedAt = field.NewField(tableName, "updated_at")
_refund.DeletedAt = field.NewField(tableName, "deleted_at")
_refund.Status = field.NewInt(tableName, "status")
_refund.fillFieldMap()
@@ -46,15 +46,15 @@ type refund struct {
refundDo
ALL field.Asterisk
ID field.Int32 // 退款ID
TradeID field.Int32 // 订单ID
ProductID field.Int32 // 产品ID
Amount field.Field // 退款金额
Reason field.String // 退款原因
Status field.Int32 // 退款状态：0-待处理，1-已退款，2-已拒绝
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
TradeID field.Int32
ProductID field.Int32
Amount field.Field
Reason field.String
Status field.Int
fieldMap map[string]field.Expr
}
@@ -72,14 +72,14 @@ func (r refund) As(alias string) *refund {
func (r *refund) updateTableName(table string) *refund {
r.ALL = field.NewAsterisk(table)
r.ID = field.NewInt32(table, "id")
r.CreatedAt = field.NewTime(table, "created_at")
r.UpdatedAt = field.NewTime(table, "updated_at")
r.DeletedAt = field.NewField(table, "deleted_at")
r.TradeID = field.NewInt32(table, "trade_id")
r.ProductID = field.NewInt32(table, "product_id")
r.Amount = field.NewField(table, "amount")
r.Reason = field.NewString(table, "reason")
r.Status = field.NewInt32(table, "status")
r.CreatedAt = field.NewField(table, "created_at")
r.UpdatedAt = field.NewField(table, "updated_at")
r.DeletedAt = field.NewField(table, "deleted_at")
r.Status = field.NewInt(table, "status")
r.fillFieldMap()
@@ -98,14 +98,14 @@ func (r *refund) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (r *refund) fillFieldMap() {
r.fieldMap = make(map[string]field.Expr, 9)
r.fieldMap["id"] = r.ID
r.fieldMap["created_at"] = r.CreatedAt
r.fieldMap["updated_at"] = r.UpdatedAt
r.fieldMap["deleted_at"] = r.DeletedAt
r.fieldMap["trade_id"] = r.TradeID
r.fieldMap["product_id"] = r.ProductID
r.fieldMap["amount"] = r.Amount
r.fieldMap["reason"] = r.Reason
r.fieldMap["status"] = r.Status
r.fieldMap["created_at"] = r.CreatedAt
r.fieldMap["updated_at"] = r.UpdatedAt
r.fieldMap["deleted_at"] = r.DeletedAt
}
func (r refund) clone(db *gorm.DB) refund {

141
web/queries/resource.gen.go
View File

@@ -28,13 +28,13 @@ func newResource(db *gorm.DB, opts ...gen.DOOption) resource {
tableName := _resource.resourceDo.TableName()
_resource.ALL = field.NewAsterisk(tableName)
_resource.ID = field.NewInt32(tableName, "id")
_resource.CreatedAt = field.NewTime(tableName, "created_at")
_resource.UpdatedAt = field.NewTime(tableName, "updated_at")
_resource.DeletedAt = field.NewField(tableName, "deleted_at")
_resource.UserID = field.NewInt32(tableName, "user_id")
_resource.ResourceNo = field.NewString(tableName, "resource_no")
_resource.Active = field.NewBool(tableName, "active")
_resource.Type = field.NewInt32(tableName, "type")
_resource.CreatedAt = field.NewField(tableName, "created_at")
_resource.UpdatedAt = field.NewField(tableName, "updated_at")
_resource.DeletedAt = field.NewField(tableName, "deleted_at")
_resource.Type = field.NewInt(tableName, "type")
_resource.Short = resourceHasOneShort{
db: db.Session(&gorm.Session{}),
@@ -47,6 +47,17 @@ func newResource(db *gorm.DB, opts ...gen.DOOption) resource {
RelationField: field.NewRelation("Long", "models.ResourceLong"),
}
_resource.User = resourceBelongsToUser{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("User", "models.User"),
Admin: struct {
field.RelationField
}{
RelationField: field.NewRelation("User.Admin", "models.Admin"),
},
}
_resource.fillFieldMap()
return _resource
@@ -56,18 +67,20 @@ type resource struct {
resourceDo
ALL field.Asterisk
ID field.Int32 // 套餐ID
UserID field.Int32 // 用户ID
ResourceNo field.String // 套餐编号
Active field.Bool // 套餐状态
Type field.Int32 // 套餐类型：1-短效动态，2-长效动态
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
UserID field.Int32
ResourceNo field.String
Active field.Bool
Type field.Int
Short resourceHasOneShort
Long resourceHasOneLong
User resourceBelongsToUser
fieldMap map[string]field.Expr
}
@@ -84,13 +97,13 @@ func (r resource) As(alias string) *resource {
func (r *resource) updateTableName(table string) *resource {
r.ALL = field.NewAsterisk(table)
r.ID = field.NewInt32(table, "id")
r.CreatedAt = field.NewTime(table, "created_at")
r.UpdatedAt = field.NewTime(table, "updated_at")
r.DeletedAt = field.NewField(table, "deleted_at")
r.UserID = field.NewInt32(table, "user_id")
r.ResourceNo = field.NewString(table, "resource_no")
r.Active = field.NewBool(table, "active")
r.Type = field.NewInt32(table, "type")
r.CreatedAt = field.NewField(table, "created_at")
r.UpdatedAt = field.NewField(table, "updated_at")
r.DeletedAt = field.NewField(table, "deleted_at")
r.Type = field.NewInt(table, "type")
r.fillFieldMap()
@@ -107,15 +120,15 @@ func (r *resource) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (r *resource) fillFieldMap() {
r.fieldMap = make(map[string]field.Expr, 10)
r.fieldMap = make(map[string]field.Expr, 11)
r.fieldMap["id"] = r.ID
r.fieldMap["created_at"] = r.CreatedAt
r.fieldMap["updated_at"] = r.UpdatedAt
r.fieldMap["deleted_at"] = r.DeletedAt
r.fieldMap["user_id"] = r.UserID
r.fieldMap["resource_no"] = r.ResourceNo
r.fieldMap["active"] = r.Active
r.fieldMap["type"] = r.Type
r.fieldMap["created_at"] = r.CreatedAt
r.fieldMap["updated_at"] = r.UpdatedAt
r.fieldMap["deleted_at"] = r.DeletedAt
}
@@ -125,6 +138,8 @@ func (r resource) clone(db *gorm.DB) resource {
r.Short.db.Statement.ConnPool = db.Statement.ConnPool
r.Long.db = db.Session(&gorm.Session{Initialized: true})
r.Long.db.Statement.ConnPool = db.Statement.ConnPool
r.User.db = db.Session(&gorm.Session{Initialized: true})
r.User.db.Statement.ConnPool = db.Statement.ConnPool
return r
}
@@ -132,6 +147,7 @@ func (r resource) replaceDB(db *gorm.DB) resource {
r.resourceDo.ReplaceDB(db)
r.Short.db = db.Session(&gorm.Session{})
r.Long.db = db.Session(&gorm.Session{})
r.User.db = db.Session(&gorm.Session{})
return r
}
@@ -297,6 +313,91 @@ func (a resourceHasOneLongTx) Unscoped() *resourceHasOneLongTx {
return &a
}
type resourceBelongsToUser struct {
db *gorm.DB
field.RelationField
Admin struct {
field.RelationField
}
}
func (a resourceBelongsToUser) Where(conds ...field.Expr) *resourceBelongsToUser {
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 resourceBelongsToUser) WithContext(ctx context.Context) *resourceBelongsToUser {
a.db = a.db.WithContext(ctx)
return &a
}
func (a resourceBelongsToUser) Session(session *gorm.Session) *resourceBelongsToUser {
a.db = a.db.Session(session)
return &a
}
func (a resourceBelongsToUser) Model(m *models.Resource) *resourceBelongsToUserTx {
return &resourceBelongsToUserTx{a.db.Model(m).Association(a.Name())}
}
func (a resourceBelongsToUser) Unscoped() *resourceBelongsToUser {
a.db = a.db.Unscoped()
return &a
}
type resourceBelongsToUserTx struct{ tx *gorm.Association }
func (a resourceBelongsToUserTx) Find() (result *models.User, err error) {
return result, a.tx.Find(&result)
}
func (a resourceBelongsToUserTx) Append(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a resourceBelongsToUserTx) Replace(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a resourceBelongsToUserTx) Delete(values ...*models.User) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a resourceBelongsToUserTx) Clear() error {
return a.tx.Clear()
}
func (a resourceBelongsToUserTx) Count() int64 {
return a.tx.Count()
}
func (a resourceBelongsToUserTx) Unscoped() *resourceBelongsToUserTx {
a.tx = a.tx.Unscoped()
return &a
}
type resourceDo struct{ gen.DO }
func (r resourceDo) Debug() *resourceDo {

32
web/queries/resource_long.gen.go
View File

@@ -29,14 +29,14 @@ func newResourceLong(db *gorm.DB, opts ...gen.DOOption) resourceLong {
_resourceLong.ALL = field.NewAsterisk(tableName)
_resourceLong.ID = field.NewInt32(tableName, "id")
_resourceLong.ResourceID = field.NewInt32(tableName, "resource_id")
_resourceLong.Type = field.NewInt32(tableName, "type")
_resourceLong.Type = field.NewInt(tableName, "type")
_resourceLong.Live = field.NewInt32(tableName, "live")
_resourceLong.Expire = field.NewField(tableName, "expire")
_resourceLong.Expire = field.NewTime(tableName, "expire")
_resourceLong.Quota = field.NewInt32(tableName, "quota")
_resourceLong.Used = field.NewInt32(tableName, "used")
_resourceLong.DailyLimit = field.NewInt32(tableName, "daily_limit")
_resourceLong.DailyUsed = field.NewInt32(tableName, "daily_used")
_resourceLong.DailyLast = field.NewField(tableName, "daily_last")
_resourceLong.DailyLast = field.NewTime(tableName, "daily_last")
_resourceLong.fillFieldMap()
@@ -47,16 +47,16 @@ type resourceLong struct {
resourceLongDo
ALL field.Asterisk
ID field.Int32 // ID
ResourceID field.Int32 // 套餐ID
Type field.Int32 // 套餐类型：1-包时，2-包量
Live field.Int32 // 可用时长(天)
Expire field.Field // 过期时间
Quota field.Int32 // 配额数量
Used field.Int32 // 已用数量
DailyLimit field.Int32 // 每日限制
DailyUsed field.Int32 // 今日已用数量
DailyLast field.Field // 今日最后使用时间
ID field.Int32
ResourceID field.Int32
Type field.Int
Live field.Int32
Expire field.Time
Quota field.Int32
Used field.Int32
DailyLimit field.Int32
DailyUsed field.Int32
DailyLast field.Time
fieldMap map[string]field.Expr
}
@@ -75,14 +75,14 @@ func (r *resourceLong) updateTableName(table string) *resourceLong {
r.ALL = field.NewAsterisk(table)
r.ID = field.NewInt32(table, "id")
r.ResourceID = field.NewInt32(table, "resource_id")
r.Type = field.NewInt32(table, "type")
r.Type = field.NewInt(table, "type")
r.Live = field.NewInt32(table, "live")
r.Expire = field.NewField(table, "expire")
r.Expire = field.NewTime(table, "expire")
r.Quota = field.NewInt32(table, "quota")
r.Used = field.NewInt32(table, "used")
r.DailyLimit = field.NewInt32(table, "daily_limit")
r.DailyUsed = field.NewInt32(table, "daily_used")
r.DailyLast = field.NewField(table, "daily_last")
r.DailyLast = field.NewTime(table, "daily_last")
r.fillFieldMap()

32
web/queries/resource_short.gen.go
View File

@@ -29,14 +29,14 @@ func newResourceShort(db *gorm.DB, opts ...gen.DOOption) resourceShort {
_resourceShort.ALL = field.NewAsterisk(tableName)
_resourceShort.ID = field.NewInt32(tableName, "id")
_resourceShort.ResourceID = field.NewInt32(tableName, "resource_id")
_resourceShort.Type = field.NewInt32(tableName, "type")
_resourceShort.Type = field.NewInt(tableName, "type")
_resourceShort.Live = field.NewInt32(tableName, "live")
_resourceShort.Expire = field.NewField(tableName, "expire")
_resourceShort.Expire = field.NewTime(tableName, "expire")
_resourceShort.Quota = field.NewInt32(tableName, "quota")
_resourceShort.Used = field.NewInt32(tableName, "used")
_resourceShort.DailyLimit = field.NewInt32(tableName, "daily_limit")
_resourceShort.DailyUsed = field.NewInt32(tableName, "daily_used")
_resourceShort.DailyLast = field.NewField(tableName, "daily_last")
_resourceShort.DailyLast = field.NewTime(tableName, "daily_last")
_resourceShort.fillFieldMap()
@@ -47,16 +47,16 @@ type resourceShort struct {
resourceShortDo
ALL field.Asterisk
ID field.Int32 // ID
ResourceID field.Int32 // 套餐ID
Type field.Int32 // 套餐类型：1-包时，2-包量
Live field.Int32 // 可用时长(秒)
Expire field.Field // 过期时间
Quota field.Int32 // 配额数量
Used field.Int32 // 已用数量
DailyLimit field.Int32 // 每日限制
DailyUsed field.Int32 // 今日已用数量
DailyLast field.Field // 今日最后使用时间
ID field.Int32
ResourceID field.Int32
Type field.Int
Live field.Int32
Expire field.Time
Quota field.Int32
Used field.Int32
DailyLimit field.Int32
DailyUsed field.Int32
DailyLast field.Time
fieldMap map[string]field.Expr
}
@@ -75,14 +75,14 @@ func (r *resourceShort) updateTableName(table string) *resourceShort {
r.ALL = field.NewAsterisk(table)
r.ID = field.NewInt32(table, "id")
r.ResourceID = field.NewInt32(table, "resource_id")
r.Type = field.NewInt32(table, "type")
r.Type = field.NewInt(table, "type")
r.Live = field.NewInt32(table, "live")
r.Expire = field.NewField(table, "expire")
r.Expire = field.NewTime(table, "expire")
r.Quota = field.NewInt32(table, "quota")
r.Used = field.NewInt32(table, "used")
r.DailyLimit = field.NewInt32(table, "daily_limit")
r.DailyUsed = field.NewInt32(table, "daily_used")
r.DailyLast = field.NewField(table, "daily_last")
r.DailyLast = field.NewTime(table, "daily_last")
r.fillFieldMap()

67
web/queries/session.gen.go
View File

@@ -28,23 +28,28 @@ func newSession(db *gorm.DB, opts ...gen.DOOption) session {
tableName := _session.sessionDo.TableName()
_session.ALL = field.NewAsterisk(tableName)
_session.ID = field.NewInt32(tableName, "id")
_session.CreatedAt = field.NewTime(tableName, "created_at")
_session.UpdatedAt = field.NewTime(tableName, "updated_at")
_session.DeletedAt = field.NewField(tableName, "deleted_at")
_session.UserID = field.NewInt32(tableName, "user_id")
_session.AdminID = field.NewInt32(tableName, "admin_id")
_session.ClientID = field.NewInt32(tableName, "client_id")
_session.IP = field.NewString(tableName, "ip")
_session.IP = field.NewField(tableName, "ip")
_session.UA = field.NewString(tableName, "ua")
_session.AccessToken = field.NewString(tableName, "access_token")
_session.AccessTokenExpires = field.NewField(tableName, "access_token_expires")
_session.AccessTokenExpires = field.NewTime(tableName, "access_token_expires")
_session.RefreshToken = field.NewString(tableName, "refresh_token")
_session.RefreshTokenExpires = field.NewField(tableName, "refresh_token_expires")
_session.RefreshTokenExpires = field.NewTime(tableName, "refresh_token_expires")
_session.Scopes_ = field.NewString(tableName, "scopes")
_session.CreatedAt = field.NewField(tableName, "created_at")
_session.UpdatedAt = field.NewField(tableName, "updated_at")
_session.DeletedAt = field.NewField(tableName, "deleted_at")
_session.User = sessionBelongsToUser{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("User", "models.User"),
Admin: struct {
field.RelationField
}{
RelationField: field.NewRelation("User.Admin", "models.Admin"),
},
}
_session.Admin = sessionBelongsToAdmin{
@@ -68,20 +73,20 @@ type session struct {
sessionDo
ALL field.Asterisk
ID field.Int32 // 会话ID
UserID field.Int32 // 用户ID
AdminID field.Int32 // 管理员ID
ClientID field.Int32 // 客户端ID
IP field.String // IP地址
UA field.String // 用户代理
AccessToken field.String // 访问令牌
AccessTokenExpires field.Field // 访问令牌过期时间
RefreshToken field.String // 刷新令牌
RefreshTokenExpires field.Field // 刷新令牌过期时间
Scopes_ field.String // 权限范围
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
UserID field.Int32
AdminID field.Int32
ClientID field.Int32
IP field.Field
UA field.String
AccessToken field.String
AccessTokenExpires field.Time
RefreshToken field.String
RefreshTokenExpires field.Time
Scopes_ field.String
User sessionBelongsToUser
Admin sessionBelongsToAdmin
@@ -104,19 +109,19 @@ func (s session) As(alias string) *session {
func (s *session) updateTableName(table string) *session {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt32(table, "id")
s.CreatedAt = field.NewTime(table, "created_at")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.UserID = field.NewInt32(table, "user_id")
s.AdminID = field.NewInt32(table, "admin_id")
s.ClientID = field.NewInt32(table, "client_id")
s.IP = field.NewString(table, "ip")
s.IP = field.NewField(table, "ip")
s.UA = field.NewString(table, "ua")
s.AccessToken = field.NewString(table, "access_token")
s.AccessTokenExpires = field.NewField(table, "access_token_expires")
s.AccessTokenExpires = field.NewTime(table, "access_token_expires")
s.RefreshToken = field.NewString(table, "refresh_token")
s.RefreshTokenExpires = field.NewField(table, "refresh_token_expires")
s.RefreshTokenExpires = field.NewTime(table, "refresh_token_expires")
s.Scopes_ = field.NewString(table, "scopes")
s.CreatedAt = field.NewField(table, "created_at")
s.UpdatedAt = field.NewField(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
@@ -135,6 +140,9 @@ func (s *session) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (s *session) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 17)
s.fieldMap["id"] = s.ID
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
s.fieldMap["user_id"] = s.UserID
s.fieldMap["admin_id"] = s.AdminID
s.fieldMap["client_id"] = s.ClientID
@@ -145,9 +153,6 @@ func (s *session) fillFieldMap() {
s.fieldMap["refresh_token"] = s.RefreshToken
s.fieldMap["refresh_token_expires"] = s.RefreshTokenExpires
s.fieldMap["scopes"] = s.Scopes_
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
}
@@ -174,6 +179,10 @@ type sessionBelongsToUser struct {
db *gorm.DB
field.RelationField
Admin struct {
field.RelationField
}
}
func (a sessionBelongsToUser) Where(conds ...field.Expr) *sessionBelongsToUser {

84
web/queries/trade.gen.go
View File

@@ -28,25 +28,25 @@ func newTrade(db *gorm.DB, opts ...gen.DOOption) trade {
tableName := _trade.tradeDo.TableName()
_trade.ALL = field.NewAsterisk(tableName)
_trade.ID = field.NewInt32(tableName, "id")
_trade.CreatedAt = field.NewTime(tableName, "created_at")
_trade.UpdatedAt = field.NewTime(tableName, "updated_at")
_trade.DeletedAt = field.NewField(tableName, "deleted_at")
_trade.UserID = field.NewInt32(tableName, "user_id")
_trade.InnerNo = field.NewString(tableName, "inner_no")
_trade.OuterNo = field.NewString(tableName, "outer_no")
_trade.Type = field.NewInt32(tableName, "type")
_trade.Type = field.NewInt(tableName, "type")
_trade.Subject = field.NewString(tableName, "subject")
_trade.Remark = field.NewString(tableName, "remark")
_trade.Amount = field.NewField(tableName, "amount")
_trade.Payment = field.NewField(tableName, "payment")
_trade.Method = field.NewInt32(tableName, "method")
_trade.Platform = field.NewInt32(tableName, "platform")
_trade.Acquirer = field.NewInt32(tableName, "acquirer")
_trade.Status = field.NewInt32(tableName, "status")
_trade.Method = field.NewInt(tableName, "method")
_trade.Platform = field.NewInt(tableName, "platform")
_trade.Acquirer = field.NewInt(tableName, "acquirer")
_trade.Status = field.NewInt(tableName, "status")
_trade.Refunded = field.NewBool(tableName, "refunded")
_trade.PaymentURL = field.NewString(tableName, "payment_url")
_trade.CompletedAt = field.NewField(tableName, "completed_at")
_trade.CanceledAt = field.NewField(tableName, "canceled_at")
_trade.CreatedAt = field.NewField(tableName, "created_at")
_trade.UpdatedAt = field.NewField(tableName, "updated_at")
_trade.DeletedAt = field.NewField(tableName, "deleted_at")
_trade.CompletedAt = field.NewTime(tableName, "completed_at")
_trade.CanceledAt = field.NewTime(tableName, "canceled_at")
_trade.fillFieldMap()
@@ -57,26 +57,26 @@ type trade struct {
tradeDo
ALL field.Asterisk
ID field.Int32 // 订单ID
UserID field.Int32 // 用户ID
InnerNo field.String // 内部订单号
OuterNo field.String // 外部订单号
Type field.Int32 // 订单类型：1-购买产品，2-充值余额
Subject field.String // 订单主题
Remark field.String // 订单备注
Amount field.Field // 订单总金额
Payment field.Field // 实际支付金额
Method field.Int32 // 支付方式：1-支付宝，2-微信，3-商福通，4-商福通渠道支付宝，5-商福通渠道微信
Platform field.Int32 // 支付平台：1-电脑网站，2-手机网站
Acquirer field.Int32 // 收单机构：1-支付宝，2-微信，3-银联
Status field.Int32 // 订单状态：0-待支付，1-已支付，2-已取消
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
UserID field.Int32
InnerNo field.String
OuterNo field.String
Type field.Int
Subject field.String
Remark field.String
Amount field.Field
Payment field.Field
Method field.Int
Platform field.Int
Acquirer field.Int
Status field.Int
Refunded field.Bool
PaymentURL field.String // 支付链接
CompletedAt field.Field // 支付时间
CanceledAt field.Field // 取消时间
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
PaymentURL field.String
CompletedAt field.Time
CanceledAt field.Time
fieldMap map[string]field.Expr
}
@@ -94,25 +94,25 @@ func (t trade) As(alias string) *trade {
func (t *trade) updateTableName(table string) *trade {
t.ALL = field.NewAsterisk(table)
t.ID = field.NewInt32(table, "id")
t.CreatedAt = field.NewTime(table, "created_at")
t.UpdatedAt = field.NewTime(table, "updated_at")
t.DeletedAt = field.NewField(table, "deleted_at")
t.UserID = field.NewInt32(table, "user_id")
t.InnerNo = field.NewString(table, "inner_no")
t.OuterNo = field.NewString(table, "outer_no")
t.Type = field.NewInt32(table, "type")
t.Type = field.NewInt(table, "type")
t.Subject = field.NewString(table, "subject")
t.Remark = field.NewString(table, "remark")
t.Amount = field.NewField(table, "amount")
t.Payment = field.NewField(table, "payment")
t.Method = field.NewInt32(table, "method")
t.Platform = field.NewInt32(table, "platform")
t.Acquirer = field.NewInt32(table, "acquirer")
t.Status = field.NewInt32(table, "status")
t.Method = field.NewInt(table, "method")
t.Platform = field.NewInt(table, "platform")
t.Acquirer = field.NewInt(table, "acquirer")
t.Status = field.NewInt(table, "status")
t.Refunded = field.NewBool(table, "refunded")
t.PaymentURL = field.NewString(table, "payment_url")
t.CompletedAt = field.NewField(table, "completed_at")
t.CanceledAt = field.NewField(table, "canceled_at")
t.CreatedAt = field.NewField(table, "created_at")
t.UpdatedAt = field.NewField(table, "updated_at")
t.DeletedAt = field.NewField(table, "deleted_at")
t.CompletedAt = field.NewTime(table, "completed_at")
t.CanceledAt = field.NewTime(table, "canceled_at")
t.fillFieldMap()
@@ -131,6 +131,9 @@ func (t *trade) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (t *trade) fillFieldMap() {
t.fieldMap = make(map[string]field.Expr, 20)
t.fieldMap["id"] = t.ID
t.fieldMap["created_at"] = t.CreatedAt
t.fieldMap["updated_at"] = t.UpdatedAt
t.fieldMap["deleted_at"] = t.DeletedAt
t.fieldMap["user_id"] = t.UserID
t.fieldMap["inner_no"] = t.InnerNo
t.fieldMap["outer_no"] = t.OuterNo
@@ -147,9 +150,6 @@ func (t *trade) fillFieldMap() {
t.fieldMap["payment_url"] = t.PaymentURL
t.fieldMap["completed_at"] = t.CompletedAt
t.fieldMap["canceled_at"] = t.CanceledAt
t.fieldMap["created_at"] = t.CreatedAt
t.fieldMap["updated_at"] = t.UpdatedAt
t.fieldMap["deleted_at"] = t.DeletedAt
}
func (t trade) clone(db *gorm.DB) trade {

179
web/queries/user.gen.go
View File

@@ -28,6 +28,9 @@ func newUser(db *gorm.DB, opts ...gen.DOOption) user {
tableName := _user.userDo.TableName()
_user.ALL = field.NewAsterisk(tableName)
_user.ID = field.NewInt32(tableName, "id")
_user.CreatedAt = field.NewTime(tableName, "created_at")
_user.UpdatedAt = field.NewTime(tableName, "updated_at")
_user.DeletedAt = field.NewField(tableName, "deleted_at")
_user.AdminID = field.NewInt32(tableName, "admin_id")
_user.Phone = field.NewString(tableName, "phone")
_user.Username = field.NewString(tableName, "username")
@@ -35,19 +38,21 @@ func newUser(db *gorm.DB, opts ...gen.DOOption) user {
_user.Password = field.NewString(tableName, "password")
_user.Name = field.NewString(tableName, "name")
_user.Avatar = field.NewString(tableName, "avatar")
_user.Status = field.NewInt32(tableName, "status")
_user.Status = field.NewInt(tableName, "status")
_user.Balance = field.NewField(tableName, "balance")
_user.IDType = field.NewInt32(tableName, "id_type")
_user.IDType = field.NewInt(tableName, "id_type")
_user.IDNo = field.NewString(tableName, "id_no")
_user.IDToken = field.NewString(tableName, "id_token")
_user.ContactQQ = field.NewString(tableName, "contact_qq")
_user.ContactWechat = field.NewString(tableName, "contact_wechat")
_user.LastLogin = field.NewField(tableName, "last_login")
_user.LastLoginHost = field.NewString(tableName, "last_login_host")
_user.LastLoginAgent = field.NewString(tableName, "last_login_agent")
_user.CreatedAt = field.NewField(tableName, "created_at")
_user.UpdatedAt = field.NewField(tableName, "updated_at")
_user.DeletedAt = field.NewField(tableName, "deleted_at")
_user.LastLogin = field.NewTime(tableName, "last_login")
_user.LastLoginIP = field.NewField(tableName, "last_login_ip")
_user.LastLoginUA = field.NewString(tableName, "last_login_ua")
_user.Admin = userBelongsToAdmin{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("Admin", "models.Admin"),
}
_user.fillFieldMap()
@@ -57,28 +62,29 @@ func newUser(db *gorm.DB, opts ...gen.DOOption) user {
type user struct {
userDo
ALL field.Asterisk
ID field.Int32 // 用户ID
AdminID field.Int32 // 管理员ID
Phone field.String // 手机号码
Username field.String // 用户名
Email field.String
Password field.String // 用户密码
Name field.String // 真实姓名
Avatar field.String // 头像URL
Status field.Int32 // 用户状态：0-禁用，1-正常
Balance field.Field // 账户余额
IDType field.Int32 // 认证类型：0-未认证，1-个人认证，2-企业认证
IDNo field.String // 身份证号或营业执照号
IDToken field.String // 身份验证标识
ContactQQ field.String // QQ联系方式
ContactWechat field.String // 微信联系方式
LastLogin field.Field // 最后登录时间
LastLoginHost field.String // 最后登录地址
LastLoginAgent field.String // 最后登录代理
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ALL field.Asterisk
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
AdminID field.Int32
Phone field.String
Username field.String
Email field.String
Password field.String
Name field.String
Avatar field.String
Status field.Int
Balance field.Field
IDType field.Int
IDNo field.String
IDToken field.String
ContactQQ field.String
ContactWechat field.String
LastLogin field.Time
LastLoginIP field.Field
LastLoginUA field.String
Admin userBelongsToAdmin
fieldMap map[string]field.Expr
}
@@ -96,6 +102,9 @@ func (u user) As(alias string) *user {
func (u *user) updateTableName(table string) *user {
u.ALL = field.NewAsterisk(table)
u.ID = field.NewInt32(table, "id")
u.CreatedAt = field.NewTime(table, "created_at")
u.UpdatedAt = field.NewTime(table, "updated_at")
u.DeletedAt = field.NewField(table, "deleted_at")
u.AdminID = field.NewInt32(table, "admin_id")
u.Phone = field.NewString(table, "phone")
u.Username = field.NewString(table, "username")
@@ -103,19 +112,16 @@ func (u *user) updateTableName(table string) *user {
u.Password = field.NewString(table, "password")
u.Name = field.NewString(table, "name")
u.Avatar = field.NewString(table, "avatar")
u.Status = field.NewInt32(table, "status")
u.Status = field.NewInt(table, "status")
u.Balance = field.NewField(table, "balance")
u.IDType = field.NewInt32(table, "id_type")
u.IDType = field.NewInt(table, "id_type")
u.IDNo = field.NewString(table, "id_no")
u.IDToken = field.NewString(table, "id_token")
u.ContactQQ = field.NewString(table, "contact_qq")
u.ContactWechat = field.NewString(table, "contact_wechat")
u.LastLogin = field.NewField(table, "last_login")
u.LastLoginHost = field.NewString(table, "last_login_host")
u.LastLoginAgent = field.NewString(table, "last_login_agent")
u.CreatedAt = field.NewField(table, "created_at")
u.UpdatedAt = field.NewField(table, "updated_at")
u.DeletedAt = field.NewField(table, "deleted_at")
u.LastLogin = field.NewTime(table, "last_login")
u.LastLoginIP = field.NewField(table, "last_login_ip")
u.LastLoginUA = field.NewString(table, "last_login_ua")
u.fillFieldMap()
@@ -132,8 +138,11 @@ func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (u *user) fillFieldMap() {
u.fieldMap = make(map[string]field.Expr, 21)
u.fieldMap = make(map[string]field.Expr, 22)
u.fieldMap["id"] = u.ID
u.fieldMap["created_at"] = u.CreatedAt
u.fieldMap["updated_at"] = u.UpdatedAt
u.fieldMap["deleted_at"] = u.DeletedAt
u.fieldMap["admin_id"] = u.AdminID
u.fieldMap["phone"] = u.Phone
u.fieldMap["username"] = u.Username
@@ -149,23 +158,105 @@ func (u *user) fillFieldMap() {
u.fieldMap["contact_qq"] = u.ContactQQ
u.fieldMap["contact_wechat"] = u.ContactWechat
u.fieldMap["last_login"] = u.LastLogin
u.fieldMap["last_login_host"] = u.LastLoginHost
u.fieldMap["last_login_agent"] = u.LastLoginAgent
u.fieldMap["created_at"] = u.CreatedAt
u.fieldMap["updated_at"] = u.UpdatedAt
u.fieldMap["deleted_at"] = u.DeletedAt
u.fieldMap["last_login_ip"] = u.LastLoginIP
u.fieldMap["last_login_ua"] = u.LastLoginUA
}
func (u user) clone(db *gorm.DB) user {
u.userDo.ReplaceConnPool(db.Statement.ConnPool)
u.Admin.db = db.Session(&gorm.Session{Initialized: true})
u.Admin.db.Statement.ConnPool = db.Statement.ConnPool
return u
}
func (u user) replaceDB(db *gorm.DB) user {
u.userDo.ReplaceDB(db)
u.Admin.db = db.Session(&gorm.Session{})
return u
}
type userBelongsToAdmin struct {
db *gorm.DB
field.RelationField
}
func (a userBelongsToAdmin) Where(conds ...field.Expr) *userBelongsToAdmin {
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 userBelongsToAdmin) WithContext(ctx context.Context) *userBelongsToAdmin {
a.db = a.db.WithContext(ctx)
return &a
}
func (a userBelongsToAdmin) Session(session *gorm.Session) *userBelongsToAdmin {
a.db = a.db.Session(session)
return &a
}
func (a userBelongsToAdmin) Model(m *models.User) *userBelongsToAdminTx {
return &userBelongsToAdminTx{a.db.Model(m).Association(a.Name())}
}
func (a userBelongsToAdmin) Unscoped() *userBelongsToAdmin {
a.db = a.db.Unscoped()
return &a
}
type userBelongsToAdminTx struct{ tx *gorm.Association }
func (a userBelongsToAdminTx) Find() (result *models.Admin, err error) {
return result, a.tx.Find(&result)
}
func (a userBelongsToAdminTx) Append(values ...*models.Admin) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a userBelongsToAdminTx) Replace(values ...*models.Admin) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a userBelongsToAdminTx) Delete(values ...*models.Admin) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a userBelongsToAdminTx) Clear() error {
return a.tx.Clear()
}
func (a userBelongsToAdminTx) Count() int64 {
return a.tx.Count()
}
func (a userBelongsToAdminTx) Unscoped() *userBelongsToAdminTx {
a.tx = a.tx.Unscoped()
return &a
}
type userDo struct{ gen.DO }
func (u userDo) Debug() *userDo {

34
web/queries/user_role.gen.go
View File

@@ -28,13 +28,13 @@ func newUserRole(db *gorm.DB, opts ...gen.DOOption) userRole {
tableName := _userRole.userRoleDo.TableName()
_userRole.ALL = field.NewAsterisk(tableName)
_userRole.ID = field.NewInt32(tableName, "id")
_userRole.CreatedAt = field.NewTime(tableName, "created_at")
_userRole.UpdatedAt = field.NewTime(tableName, "updated_at")
_userRole.DeletedAt = field.NewField(tableName, "deleted_at")
_userRole.Name = field.NewString(tableName, "name")
_userRole.Description = field.NewString(tableName, "description")
_userRole.Active = field.NewBool(tableName, "active")
_userRole.Sort = field.NewInt32(tableName, "sort")
_userRole.CreatedAt = field.NewField(tableName, "created_at")
_userRole.UpdatedAt = field.NewField(tableName, "updated_at")
_userRole.DeletedAt = field.NewField(tableName, "deleted_at")
_userRole.fillFieldMap()
@@ -45,14 +45,14 @@ type userRole struct {
userRoleDo
ALL field.Asterisk
ID field.Int32 // 角色ID
Name field.String // 角色名称
Description field.String // 角色描述
Active field.Bool // 是否激活
Sort field.Int32 // 排序
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Name field.String
Description field.String
Active field.Bool
Sort field.Int32
fieldMap map[string]field.Expr
}
@@ -70,13 +70,13 @@ func (u userRole) As(alias string) *userRole {
func (u *userRole) updateTableName(table string) *userRole {
u.ALL = field.NewAsterisk(table)
u.ID = field.NewInt32(table, "id")
u.CreatedAt = field.NewTime(table, "created_at")
u.UpdatedAt = field.NewTime(table, "updated_at")
u.DeletedAt = field.NewField(table, "deleted_at")
u.Name = field.NewString(table, "name")
u.Description = field.NewString(table, "description")
u.Active = field.NewBool(table, "active")
u.Sort = field.NewInt32(table, "sort")
u.CreatedAt = field.NewField(table, "created_at")
u.UpdatedAt = field.NewField(table, "updated_at")
u.DeletedAt = field.NewField(table, "deleted_at")
u.fillFieldMap()
@@ -95,13 +95,13 @@ func (u *userRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (u *userRole) fillFieldMap() {
u.fieldMap = make(map[string]field.Expr, 8)
u.fieldMap["id"] = u.ID
u.fieldMap["created_at"] = u.CreatedAt
u.fieldMap["updated_at"] = u.UpdatedAt
u.fieldMap["deleted_at"] = u.DeletedAt
u.fieldMap["name"] = u.Name
u.fieldMap["description"] = u.Description
u.fieldMap["active"] = u.Active
u.fieldMap["sort"] = u.Sort
u.fieldMap["created_at"] = u.CreatedAt
u.fieldMap["updated_at"] = u.UpdatedAt
u.fieldMap["deleted_at"] = u.DeletedAt
}
func (u userRole) clone(db *gorm.DB) userRole {

339
web/queries/user_role_link.gen.go
View File

@@ -1,339 +0,0 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newUserRoleLink(db *gorm.DB, opts ...gen.DOOption) userRoleLink {
_userRoleLink := userRoleLink{}
_userRoleLink.userRoleLinkDo.UseDB(db, opts...)
_userRoleLink.userRoleLinkDo.UseModel(&models.UserRoleLink{})
tableName := _userRoleLink.userRoleLinkDo.TableName()
_userRoleLink.ALL = field.NewAsterisk(tableName)
_userRoleLink.ID = field.NewInt32(tableName, "id")
_userRoleLink.UserID = field.NewInt32(tableName, "user_id")
_userRoleLink.RoleID = field.NewInt32(tableName, "role_id")
_userRoleLink.CreatedAt = field.NewField(tableName, "created_at")
_userRoleLink.UpdatedAt = field.NewField(tableName, "updated_at")
_userRoleLink.DeletedAt = field.NewField(tableName, "deleted_at")
_userRoleLink.fillFieldMap()
return _userRoleLink
}
type userRoleLink struct {
userRoleLinkDo
ALL field.Asterisk
ID field.Int32 // 关联ID
UserID field.Int32 // 用户ID
RoleID field.Int32 // 角色ID
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (u userRoleLink) Table(newTableName string) *userRoleLink {
u.userRoleLinkDo.UseTable(newTableName)
return u.updateTableName(newTableName)
}
func (u userRoleLink) As(alias string) *userRoleLink {
u.userRoleLinkDo.DO = *(u.userRoleLinkDo.As(alias).(*gen.DO))
return u.updateTableName(alias)
}
func (u *userRoleLink) updateTableName(table string) *userRoleLink {
u.ALL = field.NewAsterisk(table)
u.ID = field.NewInt32(table, "id")
u.UserID = field.NewInt32(table, "user_id")
u.RoleID = field.NewInt32(table, "role_id")
u.CreatedAt = field.NewField(table, "created_at")
u.UpdatedAt = field.NewField(table, "updated_at")
u.DeletedAt = field.NewField(table, "deleted_at")
u.fillFieldMap()
return u
}
func (u *userRoleLink) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := u.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (u *userRoleLink) fillFieldMap() {
u.fieldMap = make(map[string]field.Expr, 6)
u.fieldMap["id"] = u.ID
u.fieldMap["user_id"] = u.UserID
u.fieldMap["role_id"] = u.RoleID
u.fieldMap["created_at"] = u.CreatedAt
u.fieldMap["updated_at"] = u.UpdatedAt
u.fieldMap["deleted_at"] = u.DeletedAt
}
func (u userRoleLink) clone(db *gorm.DB) userRoleLink {
u.userRoleLinkDo.ReplaceConnPool(db.Statement.ConnPool)
return u
}
func (u userRoleLink) replaceDB(db *gorm.DB) userRoleLink {
u.userRoleLinkDo.ReplaceDB(db)
return u
}
type userRoleLinkDo struct{ gen.DO }
func (u userRoleLinkDo) Debug() *userRoleLinkDo {
return u.withDO(u.DO.Debug())
}
func (u userRoleLinkDo) WithContext(ctx context.Context) *userRoleLinkDo {
return u.withDO(u.DO.WithContext(ctx))
}
func (u userRoleLinkDo) ReadDB() *userRoleLinkDo {
return u.Clauses(dbresolver.Read)
}
func (u userRoleLinkDo) WriteDB() *userRoleLinkDo {
return u.Clauses(dbresolver.Write)
}
func (u userRoleLinkDo) Session(config *gorm.Session) *userRoleLinkDo {
return u.withDO(u.DO.Session(config))
}
func (u userRoleLinkDo) Clauses(conds ...clause.Expression) *userRoleLinkDo {
return u.withDO(u.DO.Clauses(conds...))
}
func (u userRoleLinkDo) Returning(value interface{}, columns ...string) *userRoleLinkDo {
return u.withDO(u.DO.Returning(value, columns...))
}
func (u userRoleLinkDo) Not(conds ...gen.Condition) *userRoleLinkDo {
return u.withDO(u.DO.Not(conds...))
}
func (u userRoleLinkDo) Or(conds ...gen.Condition) *userRoleLinkDo {
return u.withDO(u.DO.Or(conds...))
}
func (u userRoleLinkDo) Select(conds ...field.Expr) *userRoleLinkDo {
return u.withDO(u.DO.Select(conds...))
}
func (u userRoleLinkDo) Where(conds ...gen.Condition) *userRoleLinkDo {
return u.withDO(u.DO.Where(conds...))
}
func (u userRoleLinkDo) Order(conds ...field.Expr) *userRoleLinkDo {
return u.withDO(u.DO.Order(conds...))
}
func (u userRoleLinkDo) Distinct(cols ...field.Expr) *userRoleLinkDo {
return u.withDO(u.DO.Distinct(cols...))
}
func (u userRoleLinkDo) Omit(cols ...field.Expr) *userRoleLinkDo {
return u.withDO(u.DO.Omit(cols...))
}
func (u userRoleLinkDo) Join(table schema.Tabler, on ...field.Expr) *userRoleLinkDo {
return u.withDO(u.DO.Join(table, on...))
}
func (u userRoleLinkDo) LeftJoin(table schema.Tabler, on ...field.Expr) *userRoleLinkDo {
return u.withDO(u.DO.LeftJoin(table, on...))
}
func (u userRoleLinkDo) RightJoin(table schema.Tabler, on ...field.Expr) *userRoleLinkDo {
return u.withDO(u.DO.RightJoin(table, on...))
}
func (u userRoleLinkDo) Group(cols ...field.Expr) *userRoleLinkDo {
return u.withDO(u.DO.Group(cols...))
}
func (u userRoleLinkDo) Having(conds ...gen.Condition) *userRoleLinkDo {
return u.withDO(u.DO.Having(conds...))
}
func (u userRoleLinkDo) Limit(limit int) *userRoleLinkDo {
return u.withDO(u.DO.Limit(limit))
}
func (u userRoleLinkDo) Offset(offset int) *userRoleLinkDo {
return u.withDO(u.DO.Offset(offset))
}
func (u userRoleLinkDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *userRoleLinkDo {
return u.withDO(u.DO.Scopes(funcs...))
}
func (u userRoleLinkDo) Unscoped() *userRoleLinkDo {
return u.withDO(u.DO.Unscoped())
}
func (u userRoleLinkDo) Create(values ...*models.UserRoleLink) error {
if len(values) == 0 {
return nil
}
return u.DO.Create(values)
}
func (u userRoleLinkDo) CreateInBatches(values []*models.UserRoleLink, batchSize int) error {
return u.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (u userRoleLinkDo) Save(values ...*models.UserRoleLink) error {
if len(values) == 0 {
return nil
}
return u.DO.Save(values)
}
func (u userRoleLinkDo) First() (*models.UserRoleLink, error) {
if result, err := u.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.UserRoleLink), nil
}
}
func (u userRoleLinkDo) Take() (*models.UserRoleLink, error) {
if result, err := u.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.UserRoleLink), nil
}
}
func (u userRoleLinkDo) Last() (*models.UserRoleLink, error) {
if result, err := u.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.UserRoleLink), nil
}
}
func (u userRoleLinkDo) Find() ([]*models.UserRoleLink, error) {
result, err := u.DO.Find()
return result.([]*models.UserRoleLink), err
}
func (u userRoleLinkDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.UserRoleLink, err error) {
buf := make([]*models.UserRoleLink, 0, batchSize)
err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (u userRoleLinkDo) FindInBatches(result *[]*models.UserRoleLink, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return u.DO.FindInBatches(result, batchSize, fc)
}
func (u userRoleLinkDo) Attrs(attrs ...field.AssignExpr) *userRoleLinkDo {
return u.withDO(u.DO.Attrs(attrs...))
}
func (u userRoleLinkDo) Assign(attrs ...field.AssignExpr) *userRoleLinkDo {
return u.withDO(u.DO.Assign(attrs...))
}
func (u userRoleLinkDo) Joins(fields ...field.RelationField) *userRoleLinkDo {
for _, _f := range fields {
u = *u.withDO(u.DO.Joins(_f))
}
return &u
}
func (u userRoleLinkDo) Preload(fields ...field.RelationField) *userRoleLinkDo {
for _, _f := range fields {
u = *u.withDO(u.DO.Preload(_f))
}
return &u
}
func (u userRoleLinkDo) FirstOrInit() (*models.UserRoleLink, error) {
if result, err := u.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.UserRoleLink), nil
}
}
func (u userRoleLinkDo) FirstOrCreate() (*models.UserRoleLink, error) {
if result, err := u.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.UserRoleLink), nil
}
}
func (u userRoleLinkDo) FindByPage(offset int, limit int) (result []*models.UserRoleLink, count int64, err error) {
result, err = u.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = u.Offset(-1).Limit(-1).Count()
return
}
func (u userRoleLinkDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = u.Count()
if err != nil {
return
}
err = u.Offset(offset).Limit(limit).Scan(result)
return
}
func (u userRoleLinkDo) Scan(result interface{}) (err error) {
return u.DO.Scan(result)
}
func (u userRoleLinkDo) Delete(models ...*models.UserRoleLink) (result gen.ResultInfo, err error) {
return u.DO.Delete(models)
}
func (u *userRoleLinkDo) withDO(do gen.Dao) *userRoleLinkDo {
u.DO = *do.(*gen.DO)
return u
}

339
web/queries/user_role_permission_link.gen.go
View File

@@ -1,339 +0,0 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package queries
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"platform/web/models"
)
func newUserRolePermissionLink(db *gorm.DB, opts ...gen.DOOption) userRolePermissionLink {
_userRolePermissionLink := userRolePermissionLink{}
_userRolePermissionLink.userRolePermissionLinkDo.UseDB(db, opts...)
_userRolePermissionLink.userRolePermissionLinkDo.UseModel(&models.UserRolePermissionLink{})
tableName := _userRolePermissionLink.userRolePermissionLinkDo.TableName()
_userRolePermissionLink.ALL = field.NewAsterisk(tableName)
_userRolePermissionLink.ID = field.NewInt32(tableName, "id")
_userRolePermissionLink.RoleID = field.NewInt32(tableName, "role_id")
_userRolePermissionLink.PermissionID = field.NewInt32(tableName, "permission_id")
_userRolePermissionLink.CreatedAt = field.NewField(tableName, "created_at")
_userRolePermissionLink.UpdatedAt = field.NewField(tableName, "updated_at")
_userRolePermissionLink.DeletedAt = field.NewField(tableName, "deleted_at")
_userRolePermissionLink.fillFieldMap()
return _userRolePermissionLink
}
type userRolePermissionLink struct {
userRolePermissionLinkDo
ALL field.Asterisk
ID field.Int32 // 关联ID
RoleID field.Int32 // 角色ID
PermissionID field.Int32 // 权限ID
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (u userRolePermissionLink) Table(newTableName string) *userRolePermissionLink {
u.userRolePermissionLinkDo.UseTable(newTableName)
return u.updateTableName(newTableName)
}
func (u userRolePermissionLink) As(alias string) *userRolePermissionLink {
u.userRolePermissionLinkDo.DO = *(u.userRolePermissionLinkDo.As(alias).(*gen.DO))
return u.updateTableName(alias)
}
func (u *userRolePermissionLink) updateTableName(table string) *userRolePermissionLink {
u.ALL = field.NewAsterisk(table)
u.ID = field.NewInt32(table, "id")
u.RoleID = field.NewInt32(table, "role_id")
u.PermissionID = field.NewInt32(table, "permission_id")
u.CreatedAt = field.NewField(table, "created_at")
u.UpdatedAt = field.NewField(table, "updated_at")
u.DeletedAt = field.NewField(table, "deleted_at")
u.fillFieldMap()
return u
}
func (u *userRolePermissionLink) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := u.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (u *userRolePermissionLink) fillFieldMap() {
u.fieldMap = make(map[string]field.Expr, 6)
u.fieldMap["id"] = u.ID
u.fieldMap["role_id"] = u.RoleID
u.fieldMap["permission_id"] = u.PermissionID
u.fieldMap["created_at"] = u.CreatedAt
u.fieldMap["updated_at"] = u.UpdatedAt
u.fieldMap["deleted_at"] = u.DeletedAt
}
func (u userRolePermissionLink) clone(db *gorm.DB) userRolePermissionLink {
u.userRolePermissionLinkDo.ReplaceConnPool(db.Statement.ConnPool)
return u
}
func (u userRolePermissionLink) replaceDB(db *gorm.DB) userRolePermissionLink {
u.userRolePermissionLinkDo.ReplaceDB(db)
return u
}
type userRolePermissionLinkDo struct{ gen.DO }
func (u userRolePermissionLinkDo) Debug() *userRolePermissionLinkDo {
return u.withDO(u.DO.Debug())
}
func (u userRolePermissionLinkDo) WithContext(ctx context.Context) *userRolePermissionLinkDo {
return u.withDO(u.DO.WithContext(ctx))
}
func (u userRolePermissionLinkDo) ReadDB() *userRolePermissionLinkDo {
return u.Clauses(dbresolver.Read)
}
func (u userRolePermissionLinkDo) WriteDB() *userRolePermissionLinkDo {
return u.Clauses(dbresolver.Write)
}
func (u userRolePermissionLinkDo) Session(config *gorm.Session) *userRolePermissionLinkDo {
return u.withDO(u.DO.Session(config))
}
func (u userRolePermissionLinkDo) Clauses(conds ...clause.Expression) *userRolePermissionLinkDo {
return u.withDO(u.DO.Clauses(conds...))
}
func (u userRolePermissionLinkDo) Returning(value interface{}, columns ...string) *userRolePermissionLinkDo {
return u.withDO(u.DO.Returning(value, columns...))
}
func (u userRolePermissionLinkDo) Not(conds ...gen.Condition) *userRolePermissionLinkDo {
return u.withDO(u.DO.Not(conds...))
}
func (u userRolePermissionLinkDo) Or(conds ...gen.Condition) *userRolePermissionLinkDo {
return u.withDO(u.DO.Or(conds...))
}
func (u userRolePermissionLinkDo) Select(conds ...field.Expr) *userRolePermissionLinkDo {
return u.withDO(u.DO.Select(conds...))
}
func (u userRolePermissionLinkDo) Where(conds ...gen.Condition) *userRolePermissionLinkDo {
return u.withDO(u.DO.Where(conds...))
}
func (u userRolePermissionLinkDo) Order(conds ...field.Expr) *userRolePermissionLinkDo {
return u.withDO(u.DO.Order(conds...))
}
func (u userRolePermissionLinkDo) Distinct(cols ...field.Expr) *userRolePermissionLinkDo {
return u.withDO(u.DO.Distinct(cols...))
}
func (u userRolePermissionLinkDo) Omit(cols ...field.Expr) *userRolePermissionLinkDo {
return u.withDO(u.DO.Omit(cols...))
}
func (u userRolePermissionLinkDo) Join(table schema.Tabler, on ...field.Expr) *userRolePermissionLinkDo {
return u.withDO(u.DO.Join(table, on...))
}
func (u userRolePermissionLinkDo) LeftJoin(table schema.Tabler, on ...field.Expr) *userRolePermissionLinkDo {
return u.withDO(u.DO.LeftJoin(table, on...))
}
func (u userRolePermissionLinkDo) RightJoin(table schema.Tabler, on ...field.Expr) *userRolePermissionLinkDo {
return u.withDO(u.DO.RightJoin(table, on...))
}
func (u userRolePermissionLinkDo) Group(cols ...field.Expr) *userRolePermissionLinkDo {
return u.withDO(u.DO.Group(cols...))
}
func (u userRolePermissionLinkDo) Having(conds ...gen.Condition) *userRolePermissionLinkDo {
return u.withDO(u.DO.Having(conds...))
}
func (u userRolePermissionLinkDo) Limit(limit int) *userRolePermissionLinkDo {
return u.withDO(u.DO.Limit(limit))
}
func (u userRolePermissionLinkDo) Offset(offset int) *userRolePermissionLinkDo {
return u.withDO(u.DO.Offset(offset))
}
func (u userRolePermissionLinkDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *userRolePermissionLinkDo {
return u.withDO(u.DO.Scopes(funcs...))
}
func (u userRolePermissionLinkDo) Unscoped() *userRolePermissionLinkDo {
return u.withDO(u.DO.Unscoped())
}
func (u userRolePermissionLinkDo) Create(values ...*models.UserRolePermissionLink) error {
if len(values) == 0 {
return nil
}
return u.DO.Create(values)
}
func (u userRolePermissionLinkDo) CreateInBatches(values []*models.UserRolePermissionLink, batchSize int) error {
return u.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (u userRolePermissionLinkDo) Save(values ...*models.UserRolePermissionLink) error {
if len(values) == 0 {
return nil
}
return u.DO.Save(values)
}
func (u userRolePermissionLinkDo) First() (*models.UserRolePermissionLink, error) {
if result, err := u.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.UserRolePermissionLink), nil
}
}
func (u userRolePermissionLinkDo) Take() (*models.UserRolePermissionLink, error) {
if result, err := u.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.UserRolePermissionLink), nil
}
}
func (u userRolePermissionLinkDo) Last() (*models.UserRolePermissionLink, error) {
if result, err := u.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.UserRolePermissionLink), nil
}
}
func (u userRolePermissionLinkDo) Find() ([]*models.UserRolePermissionLink, error) {
result, err := u.DO.Find()
return result.([]*models.UserRolePermissionLink), err
}
func (u userRolePermissionLinkDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.UserRolePermissionLink, err error) {
buf := make([]*models.UserRolePermissionLink, 0, batchSize)
err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (u userRolePermissionLinkDo) FindInBatches(result *[]*models.UserRolePermissionLink, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return u.DO.FindInBatches(result, batchSize, fc)
}
func (u userRolePermissionLinkDo) Attrs(attrs ...field.AssignExpr) *userRolePermissionLinkDo {
return u.withDO(u.DO.Attrs(attrs...))
}
func (u userRolePermissionLinkDo) Assign(attrs ...field.AssignExpr) *userRolePermissionLinkDo {
return u.withDO(u.DO.Assign(attrs...))
}
func (u userRolePermissionLinkDo) Joins(fields ...field.RelationField) *userRolePermissionLinkDo {
for _, _f := range fields {
u = *u.withDO(u.DO.Joins(_f))
}
return &u
}
func (u userRolePermissionLinkDo) Preload(fields ...field.RelationField) *userRolePermissionLinkDo {
for _, _f := range fields {
u = *u.withDO(u.DO.Preload(_f))
}
return &u
}
func (u userRolePermissionLinkDo) FirstOrInit() (*models.UserRolePermissionLink, error) {
if result, err := u.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.UserRolePermissionLink), nil
}
}
func (u userRolePermissionLinkDo) FirstOrCreate() (*models.UserRolePermissionLink, error) {
if result, err := u.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.UserRolePermissionLink), nil
}
}
func (u userRolePermissionLinkDo) FindByPage(offset int, limit int) (result []*models.UserRolePermissionLink, count int64, err error) {
result, err = u.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = u.Offset(-1).Limit(-1).Count()
return
}
func (u userRolePermissionLinkDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = u.Count()
if err != nil {
return
}
err = u.Offset(offset).Limit(limit).Scan(result)
return
}
func (u userRolePermissionLinkDo) Scan(result interface{}) (err error) {
return u.DO.Scan(result)
}
func (u userRolePermissionLinkDo) Delete(models ...*models.UserRolePermissionLink) (result gen.ResultInfo, err error) {
return u.DO.Delete(models)
}
func (u *userRolePermissionLinkDo) withDO(do gen.Dao) *userRolePermissionLinkDo {
u.DO = *do.(*gen.DO)
return u
}

40
web/queries/whitelist.gen.go
View File

@@ -28,12 +28,12 @@ func newWhitelist(db *gorm.DB, opts ...gen.DOOption) whitelist {
tableName := _whitelist.whitelistDo.TableName()
_whitelist.ALL = field.NewAsterisk(tableName)
_whitelist.ID = field.NewInt32(tableName, "id")
_whitelist.UserID = field.NewInt32(tableName, "user_id")
_whitelist.Host = field.NewString(tableName, "host")
_whitelist.Remark = field.NewString(tableName, "remark")
_whitelist.CreatedAt = field.NewField(tableName, "created_at")
_whitelist.UpdatedAt = field.NewField(tableName, "updated_at")
_whitelist.CreatedAt = field.NewTime(tableName, "created_at")
_whitelist.UpdatedAt = field.NewTime(tableName, "updated_at")
_whitelist.DeletedAt = field.NewField(tableName, "deleted_at")
_whitelist.UserID = field.NewInt32(tableName, "user_id")
_whitelist.IP = field.NewField(tableName, "ip")
_whitelist.Remark = field.NewString(tableName, "remark")
_whitelist.fillFieldMap()
@@ -44,13 +44,13 @@ type whitelist struct {
whitelistDo
ALL field.Asterisk
ID field.Int32 // 白名单ID
UserID field.Int32 // 用户ID
Host field.String // IP地址
Remark field.String // 备注
CreatedAt field.Field // 创建时间
UpdatedAt field.Field // 更新时间
DeletedAt field.Field // 删除时间
ID field.Int32
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
UserID field.Int32
IP field.Field
Remark field.String
fieldMap map[string]field.Expr
}
@@ -68,12 +68,12 @@ func (w whitelist) As(alias string) *whitelist {
func (w *whitelist) updateTableName(table string) *whitelist {
w.ALL = field.NewAsterisk(table)
w.ID = field.NewInt32(table, "id")
w.UserID = field.NewInt32(table, "user_id")
w.Host = field.NewString(table, "host")
w.Remark = field.NewString(table, "remark")
w.CreatedAt = field.NewField(table, "created_at")
w.UpdatedAt = field.NewField(table, "updated_at")
w.CreatedAt = field.NewTime(table, "created_at")
w.UpdatedAt = field.NewTime(table, "updated_at")
w.DeletedAt = field.NewField(table, "deleted_at")
w.UserID = field.NewInt32(table, "user_id")
w.IP = field.NewField(table, "ip")
w.Remark = field.NewString(table, "remark")
w.fillFieldMap()
@@ -92,12 +92,12 @@ func (w *whitelist) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
func (w *whitelist) fillFieldMap() {
w.fieldMap = make(map[string]field.Expr, 7)
w.fieldMap["id"] = w.ID
w.fieldMap["user_id"] = w.UserID
w.fieldMap["host"] = w.Host
w.fieldMap["remark"] = w.Remark
w.fieldMap["created_at"] = w.CreatedAt
w.fieldMap["updated_at"] = w.UpdatedAt
w.fieldMap["deleted_at"] = w.DeletedAt
w.fieldMap["user_id"] = w.UserID
w.fieldMap["ip"] = w.IP
w.fieldMap["remark"] = w.Remark
}
func (w whitelist) clone(db *gorm.DB) whitelist {