SCHISANDRA/schisandra-album-cloud-microservices
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🏗️ microservice fabric splitting

Browse Source
This commit is contained in:
landaiqing
2024-12-24 00:38:41 +08:00
parent 462e811742
commit 89d64336f5
311 changed files with 18384 additions and 2428 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
app/auth/api/model/mysql/generate/generate.go Normal file
View File

@@ -0,0 +1,107 @@
package main
import (
"os"
"path/filepath"
"strings"
"gorm.io/driver/mysql"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/gorm"
)
const MySQLDSN = "root:1611@(localhost:3306)/schisandra-cloud-album?charset=utf8mb4&parseTime=True&loc=Local"
func main() {
// 连接数据库
db, err := gorm.Open(mysql.Open(MySQLDSN))
if err != nil {
panic(err)
}
dir, err := os.Getwd()
if err != nil {
panic(err)
}
path := filepath.Join(dir, "app/auth/api/model/mysql/", "query")
// 生成实例
g := gen.NewGenerator(gen.Config{
// 相对执行`go run`时的路径, 会自动创建目录
OutPath: path,
// 生成的文件名，默认gen.go
OutFile: "gen.go",
// 生成DAO代码的包名，默认是：model
ModelPkgPath: "model",
// 是否为DAO包生成单元测试代码，默认：false
WithUnitTest: false,
// WithDefaultQuery 生成默认查询结构体(作为全局变量使用), 即`Q`结构体和其字段(各表模型)
// WithoutContext 生成没有context调用限制的代码供查询
// WithQueryInterface 生成interface形式的查询代码(可导出), 如`Where()`方法返回的就是一个可导出的接口类型
Mode: gen.WithDefaultQuery | gen.WithQueryInterface | gen.WithoutContext,
// 表字段可为 null 值时, 对应结体字段使用指针类型
FieldNullable: false, // generate pointer when field is nullable
// 表字段默认值与模型结构体字段零值不一致的字段, 在插入数据时需要赋值该字段值为零值的, 结构体字段须是指针类型才能成功, 即`FieldCoverable:true`配置下生成的结构体字段.
// 因为在插入时遇到字段为零值的会被GORM赋予默认值. 如字段`age`表默认值为10, 即使你显式设置为0最后也会被GORM设为10提交.
// 如果该字段没有上面提到的插入时赋零值的特殊需要, 则字段为非指针类型使用起来会比较方便.
FieldCoverable: true,
// 模型结构体字段的数字类型的符号表示是否与表字段的一致, `false`指示都用有符号类型
FieldSignable: false,
// 生成 gorm 标签的字段索引属性
FieldWithIndexTag: true,
// 生成 gorm 标签的字段类型属性
FieldWithTypeTag: true,
})
// 设置目标 db
g.UseDB(db)
// 自定义字段的数据类型
// 统一数字类型为int64,兼容protobuf
dataMap := map[string]func(columnType gorm.ColumnType) (dataType string){
"tinyint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
"smallint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
"mediumint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
"bigint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
"int": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
}
// 要先于`ApplyBasic`执行
g.WithDataTypeMap(dataMap)
// 自定义模型结体字段的标签
// 将特定字段名的 json 标签加上`string`属性,即 MarshalJSON 时该字段由数字类型转成字符串类型
jsonField := gen.FieldJSONTagWithNS(func(columnName string) (tagContent string) {
toStringField := `id, `
if strings.Contains(toStringField, columnName) {
return columnName + ",string"
}
return columnName
})
// 将非默认字段名的字段定义为自动时间戳和软删除字段;
// 自动时间戳默认字段名为:`updated_at`、`created_at, 表字段数据类型为: INT 或 DATETIME
// 软删除默认字段名为:`deleted_at`, 表字段数据类型为: DATETIME
idField := gen.FieldGORMTag("id", func(tag field.GormTag) field.GormTag {
return tag.Append("primary_key")
})
autoUpdateTimeField := gen.FieldGORMTag("updated_at", func(tag field.GormTag) field.GormTag {
return tag.Append("autoUpdateTime")
})
autoCreateTimeField := gen.FieldGORMTag("created_at", func(tag field.GormTag) field.GormTag {
return tag.Append("autoCreateTime")
})
softDeleteField := gen.FieldType("delete_at", "gorm.DeletedAt")
versionField := gen.FieldType("version", "optimisticlock.Version")
// 模型自定义选项组
fieldOpts := []gen.ModelOpt{jsonField, idField, autoUpdateTimeField, autoCreateTimeField, softDeleteField, versionField}
// 创建全部模型文件, 并覆盖前面创建的同名模型
allModel := g.GenerateAllTable(fieldOpts...)
g.ApplyBasic(allModel...)
g.Execute()
}

35
app/auth/api/model/mysql/model/sca_auth_menu.gen.go Normal file
View File

@@ -0,0 +1,35 @@
// 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 model
import (
"time"
"gorm.io/gorm"
)
const TableNameScaAuthMenu = "sca_auth_menu"
// ScaAuthMenu mapped from table <sca_auth_menu>
type ScaAuthMenu struct {
ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键ID;primary_key" json:"id,string"` // 主键ID
MenuName string `gorm:"column:menu_name;type:varchar(64);comment:名称" json:"menu_name"` // 名称
ParentID int64 `gorm:"column:parent_id;type:bigint;comment:父ID" json:"parent_id"` // 父ID
Type int64 `gorm:"column:type;type:tinyint;comment:类型" json:"type"` // 类型
Path string `gorm:"column:path;type:varchar(30);comment:路径" json:"path"` // 路径
Status int64 `gorm:"column:status;type:tinyint;comment:状态 0 启用 1 停用" json:"status"` // 状态 0 启用 1 停用
Icon string `gorm:"column:icon;type:varchar(128);comment:图标" json:"icon"` // 图标
MenuKey string `gorm:"column:menu_key;type:varchar(64);comment:关键字" json:"menu_key"` // 关键字
Order_ int64 `gorm:"column:order;type:int;comment:排序" json:"order"` // 排序
CreatedAt time.Time `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
Remark string `gorm:"column:remark;type:varchar(255);comment:备注 描述" json:"remark"` // 备注 描述
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"` // 删除时间
}
// TableName ScaAuthMenu's table name
func (*ScaAuthMenu) TableName() string {
return TableNameScaAuthMenu
}

24
app/auth/api/model/mysql/model/sca_auth_permission_rule.gen.go Normal file
View File

@@ -0,0 +1,24 @@
// 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 model
const TableNameScaAuthPermissionRule = "sca_auth_permission_rule"
// ScaAuthPermissionRule mapped from table <sca_auth_permission_rule>
type ScaAuthPermissionRule struct {
ID int64 `gorm:"column:id;type:int;primaryKey;autoIncrement:true;primary_key" json:"id,string"`
Ptype string `gorm:"column:ptype;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:1;index:IDX_sca_auth_permission_rule_ptype,priority:1" json:"ptype"`
V0 string `gorm:"column:v0;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:2;index:IDX_sca_auth_permission_rule_v0,priority:1" json:"v0"`
V1 string `gorm:"column:v1;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:3;index:IDX_sca_auth_permission_rule_v1,priority:1" json:"v1"`
V2 string `gorm:"column:v2;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:4;index:IDX_sca_auth_permission_rule_v2,priority:1" json:"v2"`
V3 string `gorm:"column:v3;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:5;index:IDX_sca_auth_permission_rule_v3,priority:1" json:"v3"`
V4 string `gorm:"column:v4;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:6;index:IDX_sca_auth_permission_rule_v4,priority:1" json:"v4"`
V5 string `gorm:"column:v5;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:7;index:IDX_sca_auth_permission_rule_v5,priority:1" json:"v5"`
}
// TableName ScaAuthPermissionRule's table name
func (*ScaAuthPermissionRule) TableName() string {
return TableNameScaAuthPermissionRule
}

28
app/auth/api/model/mysql/model/sca_auth_role.gen.go Normal file
View File

@@ -0,0 +1,28 @@
// 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 model
import (
"time"
"gorm.io/gorm"
)
const TableNameScaAuthRole = "sca_auth_role"
// ScaAuthRole mapped from table <sca_auth_role>
type ScaAuthRole struct {
ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键ID;primary_key" json:"id,string"` // 主键ID
RoleName string `gorm:"column:role_name;type:varchar(32);not null;comment:角色名称" json:"role_name"` // 角色名称
RoleKey string `gorm:"column:role_key;type:varchar(64);not null;comment:角色关键字" json:"role_key"` // 角色关键字
CreatedAt time.Time `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"` // 删除时间
}
// TableName ScaAuthRole's table name
func (*ScaAuthRole) TableName() string {
return TableNameScaAuthRole
}

39
app/auth/api/model/mysql/model/sca_auth_user.gen.go Normal file
View File

@@ -0,0 +1,39 @@
// 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 model
import (
"time"
"gorm.io/gorm"
)
const TableNameScaAuthUser = "sca_auth_user"
// ScaAuthUser mapped from table <sca_auth_user>
type ScaAuthUser struct {
ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;uniqueIndex:id,priority:1;comment:自增ID;primary_key" json:"id,string"` // 自增ID
UID string `gorm:"column:uid;type:varchar(50);not null;uniqueIndex:uid,priority:1;comment:唯一ID" json:"uid"` // 唯一ID
Username string `gorm:"column:username;type:varchar(32);comment:用户名" json:"username"` // 用户名
Nickname string `gorm:"column:nickname;type:varchar(32);comment:昵称" json:"nickname"` // 昵称
Email string `gorm:"column:email;type:varchar(32);comment:邮箱" json:"email"` // 邮箱
Phone string `gorm:"column:phone;type:varchar(32);comment:电话" json:"phone"` // 电话
Password string `gorm:"column:password;type:varchar(64);comment:密码" json:"password"` // 密码
Gender int64 `gorm:"column:gender;type:tinyint;comment:性别" json:"gender"` // 性别
Avatar string `gorm:"column:avatar;type:longtext;comment:头像" json:"avatar"` // 头像
Status int64 `gorm:"column:status;type:tinyint;comment:状态 0 正常 1 封禁" json:"status"` // 状态 0 正常 1 封禁
Introduce string `gorm:"column:introduce;type:varchar(255);comment:介绍" json:"introduce"` // 介绍
CreatedAt time.Time `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
Blog string `gorm:"column:blog;type:varchar(30);comment:博客" json:"blog"` // 博客
Location string `gorm:"column:location;type:varchar(50);comment:地址" json:"location"` // 地址
Company string `gorm:"column:company;type:varchar(50);comment:公司" json:"company"` // 公司
UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"` // 删除时间
}
// TableName ScaAuthUser's table name
func (*ScaAuthUser) TableName() string {
return TableNameScaAuthUser
}

39
app/auth/api/model/mysql/model/sca_auth_user_device.gen.go Normal file
View File

@@ -0,0 +1,39 @@
// 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 model
import (
"time"
"gorm.io/gorm"
)
const TableNameScaAuthUserDevice = "sca_auth_user_device"
// ScaAuthUserDevice mapped from table <sca_auth_user_device>
type ScaAuthUserDevice struct {
ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键ID;primary_key" json:"id,string"` // 主键ID
UserID string `gorm:"column:user_id;type:varchar(20);not null;comment:用户ID" json:"user_id"` // 用户ID
IP string `gorm:"column:ip;type:varchar(20);comment:登录IP" json:"ip"` // 登录IP
Location string `gorm:"column:location;type:varchar(20);comment:地址" json:"location"` // 地址
Agent string `gorm:"column:agent;type:varchar(255);comment:设备信息" json:"agent"` // 设备信息
CreatedAt time.Time `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
Browser string `gorm:"column:browser;type:varchar(20);comment:浏览器" json:"browser"` // 浏览器
OperatingSystem string `gorm:"column:operating_system;type:varchar(20);comment:操作系统" json:"operating_system"` // 操作系统
BrowserVersion string `gorm:"column:browser_version;type:varchar(20);comment:浏览器版本" json:"browser_version"` // 浏览器版本
Mobile int64 `gorm:"column:mobile;type:tinyint(1);comment:是否为手机 0否1是" json:"mobile"` // 是否为手机 0否1是
Bot int64 `gorm:"column:bot;type:tinyint(1);comment:是否为bot 0否1是" json:"bot"` // 是否为bot 0否1是
Mozilla string `gorm:"column:mozilla;type:varchar(10);comment:火狐版本" json:"mozilla"` // 火狐版本
Platform string `gorm:"column:platform;type:varchar(20);comment:平台" json:"platform"` // 平台
EngineName string `gorm:"column:engine_name;type:varchar(20);comment:引擎名称" json:"engine_name"` // 引擎名称
EngineVersion string `gorm:"column:engine_version;type:varchar(20);comment:引擎版本" json:"engine_version"` // 引擎版本
UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"` // 删除时间
}
// TableName ScaAuthUserDevice's table name
func (*ScaAuthUserDevice) TableName() string {
return TableNameScaAuthUserDevice
}

30
app/auth/api/model/mysql/model/sca_auth_user_social.gen.go Normal file
View File

@@ -0,0 +1,30 @@
// 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 model
import (
"time"
"gorm.io/gorm"
)
const TableNameScaAuthUserSocial = "sca_auth_user_social"
// ScaAuthUserSocial mapped from table <sca_auth_user_social>
type ScaAuthUserSocial struct {
ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键ID;primary_key" json:"id,string"` // 主键ID
UserID string `gorm:"column:user_id;type:varchar(50);not null;comment:用户ID" json:"user_id"` // 用户ID
OpenID string `gorm:"column:open_id;type:varchar(50);not null;comment:第三方用户的 open id" json:"open_id"` // 第三方用户的 open id
Source string `gorm:"column:source;type:varchar(10);comment:第三方用户来源" json:"source"` // 第三方用户来源
Status int64 `gorm:"column:status;type:bigint;comment:状态 0正常 1 封禁" json:"status"` // 状态 0正常 1 封禁
CreatedAt time.Time `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"` // 删除时间
}
// TableName ScaAuthUserSocial's table name
func (*ScaAuthUserSocial) TableName() string {
return TableNameScaAuthUserSocial
}

33
app/auth/api/model/mysql/model/sca_user_level.gen.go Normal file
View File

@@ -0,0 +1,33 @@
// 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 model
import (
"time"
"gorm.io/gorm"
)
const TableNameScaUserLevel = "sca_user_level"
// ScaUserLevel mapped from table <sca_user_level>
type ScaUserLevel struct {
ID int64 `gorm:"column:id;type:bigint;primaryKey;comment:主键;primary_key" json:"id,string"` // 主键
UserID string `gorm:"column:user_id;type:varchar(50);comment:用户Id" json:"user_id"` // 用户Id
LevelType int64 `gorm:"column:level_type;type:tinyint unsigned;comment:等级类型" json:"level_type"` // 等级类型
Level int64 `gorm:"column:level;type:int;comment:等级" json:"level"` // 等级
LevelName string `gorm:"column:level_name;type:varchar(50);comment:等级名称" json:"level_name"` // 等级名称
ExpStart int64 `gorm:"column:exp_start;type:bigint;comment:开始经验值" json:"exp_start"` // 开始经验值
ExpEnd int64 `gorm:"column:exp_end;type:bigint;comment:结束经验值" json:"exp_end"` // 结束经验值
Description string `gorm:"column:description;type:text;comment:等级描述" json:"description"` // 等级描述
CreatedAt *time.Time `gorm:"column:created_at;type:timestamp;default:CURRENT_TIMESTAMP;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
UpdatedAt *time.Time `gorm:"column:updated_at;type:timestamp;default:CURRENT_TIMESTAMP;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"` // 删除时间
}
// TableName ScaUserLevel's table name
func (*ScaUserLevel) TableName() string {
return TableNameScaUserLevel
}

31
app/auth/api/model/mysql/model/sca_user_message.gen.go Normal file
View File

@@ -0,0 +1,31 @@
// 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 model
import (
"time"
"gorm.io/gorm"
)
const TableNameScaUserMessage = "sca_user_message"
// ScaUserMessage mapped from table <sca_user_message>
type ScaUserMessage struct {
ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键;primary_key" json:"id,string"` // 主键
TopicID string `gorm:"column:topic_id;type:varchar(50);comment:话题Id" json:"topic_id"` // 话题Id
FromID string `gorm:"column:from_id;type:varchar(50);comment:来自人" json:"from_id"` // 来自人
ToID string `gorm:"column:to_id;type:varchar(50);comment:送达人" json:"to_id"` // 送达人
Content string `gorm:"column:content;type:text;comment:消息内容" json:"content"` // 消息内容
IsRead int64 `gorm:"column:is_read;type:tinyint;comment:是否已读" json:"is_read"` // 是否已读
CreatedAt time.Time `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"` // 删除时间
}
// TableName ScaUserMessage's table name
func (*ScaUserMessage) TableName() string {
return TableNameScaUserMessage
}

64
app/auth/api/model/mysql/mysql.go Normal file
View File

@@ -0,0 +1,64 @@
package mysql
import (
"github.com/asjdf/gorm-cache/cache"
"github.com/asjdf/gorm-cache/config"
"github.com/asjdf/gorm-cache/storage"
"github.com/redis/go-redis/v9"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/logger"
"log"
"os"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/query"
"time"
)
func NewMySQL(url string, maxOpenConn int, maxIdleConn int, client *redis.Client) (*gorm.DB, *query.Query) {
db, err := gorm.Open(mysql.Open(url), &gorm.Config{
SkipDefaultTransaction: true,
PrepareStmt: true,
Logger: logger.New(
log.New(os.Stdout, "\r\n", log.LstdFlags),
logger.Config{
SlowThreshold: time.Second, // 慢sql日志
LogLevel: logger.Error, // 级别
Colorful: true, // 颜色
IgnoreRecordNotFoundError: true, // 忽略RecordNotFoundError
ParameterizedQueries: true, // 格式化SQL语句
}),
})
if err != nil {
panic(err)
}
sqlDB, err := db.DB()
if err != nil {
panic(err)
}
sqlDB.SetMaxOpenConns(maxOpenConn)
sqlDB.SetMaxIdleConns(maxIdleConn)
useDB := query.Use(db)
// cache
gormCache, err := cache.NewGorm2Cache(&config.CacheConfig{
CacheLevel: config.CacheLevelAll,
CacheStorage: storage.NewRedis(&storage.RedisStoreConfig{
KeyPrefix: "cache",
Client: client,
}),
InvalidateWhenUpdate: true, // when you create/update/delete objects, invalidate cache
CacheTTL: 10000, // 5000 ms
CacheMaxItemCnt: 0, // if length of objects retrieved one single time
AsyncWrite: true, // async write to cache
DebugMode: false,
DisableCachePenetrationProtect: true, // disable cache penetration protect
})
if err != nil {
panic(err)
}
err = db.Use(gormCache)
if err != nil {
panic(err)
}
return db, useDB
}

159
app/auth/api/model/mysql/query/gen.go Normal file
View File

@@ -0,0 +1,159 @@
// 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 query
import (
"context"
"database/sql"
"gorm.io/gorm"
"gorm.io/gen"
"gorm.io/plugin/dbresolver"
)
var (
Q = new(Query)
ScaAuthMenu *scaAuthMenu
ScaAuthPermissionRule *scaAuthPermissionRule
ScaAuthRole *scaAuthRole
ScaAuthUser *scaAuthUser
ScaAuthUserDevice *scaAuthUserDevice
ScaAuthUserSocial *scaAuthUserSocial
ScaUserLevel *scaUserLevel
ScaUserMessage *scaUserMessage
)
func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
*Q = *Use(db, opts...)
ScaAuthMenu = &Q.ScaAuthMenu
ScaAuthPermissionRule = &Q.ScaAuthPermissionRule
ScaAuthRole = &Q.ScaAuthRole
ScaAuthUser = &Q.ScaAuthUser
ScaAuthUserDevice = &Q.ScaAuthUserDevice
ScaAuthUserSocial = &Q.ScaAuthUserSocial
ScaUserLevel = &Q.ScaUserLevel
ScaUserMessage = &Q.ScaUserMessage
}
func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
return &Query{
db: db,
ScaAuthMenu: newScaAuthMenu(db, opts...),
ScaAuthPermissionRule: newScaAuthPermissionRule(db, opts...),
ScaAuthRole: newScaAuthRole(db, opts...),
ScaAuthUser: newScaAuthUser(db, opts...),
ScaAuthUserDevice: newScaAuthUserDevice(db, opts...),
ScaAuthUserSocial: newScaAuthUserSocial(db, opts...),
ScaUserLevel: newScaUserLevel(db, opts...),
ScaUserMessage: newScaUserMessage(db, opts...),
}
}
type Query struct {
db *gorm.DB
ScaAuthMenu scaAuthMenu
ScaAuthPermissionRule scaAuthPermissionRule
ScaAuthRole scaAuthRole
ScaAuthUser scaAuthUser
ScaAuthUserDevice scaAuthUserDevice
ScaAuthUserSocial scaAuthUserSocial
ScaUserLevel scaUserLevel
ScaUserMessage scaUserMessage
}
func (q *Query) Available() bool { return q.db != nil }
func (q *Query) clone(db *gorm.DB) *Query {
return &Query{
db: db,
ScaAuthMenu: q.ScaAuthMenu.clone(db),
ScaAuthPermissionRule: q.ScaAuthPermissionRule.clone(db),
ScaAuthRole: q.ScaAuthRole.clone(db),
ScaAuthUser: q.ScaAuthUser.clone(db),
ScaAuthUserDevice: q.ScaAuthUserDevice.clone(db),
ScaAuthUserSocial: q.ScaAuthUserSocial.clone(db),
ScaUserLevel: q.ScaUserLevel.clone(db),
ScaUserMessage: q.ScaUserMessage.clone(db),
}
}
func (q *Query) ReadDB() *Query {
return q.ReplaceDB(q.db.Clauses(dbresolver.Read))
}
func (q *Query) WriteDB() *Query {
return q.ReplaceDB(q.db.Clauses(dbresolver.Write))
}
func (q *Query) ReplaceDB(db *gorm.DB) *Query {
return &Query{
db: db,
ScaAuthMenu: q.ScaAuthMenu.replaceDB(db),
ScaAuthPermissionRule: q.ScaAuthPermissionRule.replaceDB(db),
ScaAuthRole: q.ScaAuthRole.replaceDB(db),
ScaAuthUser: q.ScaAuthUser.replaceDB(db),
ScaAuthUserDevice: q.ScaAuthUserDevice.replaceDB(db),
ScaAuthUserSocial: q.ScaAuthUserSocial.replaceDB(db),
ScaUserLevel: q.ScaUserLevel.replaceDB(db),
ScaUserMessage: q.ScaUserMessage.replaceDB(db),
}
}
type queryCtx struct {
ScaAuthMenu IScaAuthMenuDo
ScaAuthPermissionRule IScaAuthPermissionRuleDo
ScaAuthRole IScaAuthRoleDo
ScaAuthUser IScaAuthUserDo
ScaAuthUserDevice IScaAuthUserDeviceDo
ScaAuthUserSocial IScaAuthUserSocialDo
ScaUserLevel IScaUserLevelDo
ScaUserMessage IScaUserMessageDo
}
func (q *Query) WithContext(ctx context.Context) *queryCtx {
return &queryCtx{
ScaAuthMenu: q.ScaAuthMenu.WithContext(ctx),
ScaAuthPermissionRule: q.ScaAuthPermissionRule.WithContext(ctx),
ScaAuthRole: q.ScaAuthRole.WithContext(ctx),
ScaAuthUser: q.ScaAuthUser.WithContext(ctx),
ScaAuthUserDevice: q.ScaAuthUserDevice.WithContext(ctx),
ScaAuthUserSocial: q.ScaAuthUserSocial.WithContext(ctx),
ScaUserLevel: q.ScaUserLevel.WithContext(ctx),
ScaUserMessage: q.ScaUserMessage.WithContext(ctx),
}
}
func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error {
return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...)
}
func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx {
tx := q.db.Begin(opts...)
return &QueryTx{Query: q.clone(tx), Error: tx.Error}
}
type QueryTx struct {
*Query
Error error
}
func (q *QueryTx) Commit() error {
return q.db.Commit().Error
}
func (q *QueryTx) Rollback() error {
return q.db.Rollback().Error
}
func (q *QueryTx) SavePoint(name string) error {
return q.db.SavePoint(name).Error
}
func (q *QueryTx) RollbackTo(name string) error {
return q.db.RollbackTo(name).Error
}

427
app/auth/api/model/mysql/query/sca_auth_menu.gen.go Normal file
View File

@@ -0,0 +1,427 @@
// 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 query
import (
"context"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newScaAuthMenu(db *gorm.DB, opts ...gen.DOOption) scaAuthMenu {
_scaAuthMenu := scaAuthMenu{}
_scaAuthMenu.scaAuthMenuDo.UseDB(db, opts...)
_scaAuthMenu.scaAuthMenuDo.UseModel(&model.ScaAuthMenu{})
tableName := _scaAuthMenu.scaAuthMenuDo.TableName()
_scaAuthMenu.ALL = field.NewAsterisk(tableName)
_scaAuthMenu.ID = field.NewInt64(tableName, "id")
_scaAuthMenu.MenuName = field.NewString(tableName, "menu_name")
_scaAuthMenu.ParentID = field.NewInt64(tableName, "parent_id")
_scaAuthMenu.Type = field.NewInt64(tableName, "type")
_scaAuthMenu.Path = field.NewString(tableName, "path")
_scaAuthMenu.Status = field.NewInt64(tableName, "status")
_scaAuthMenu.Icon = field.NewString(tableName, "icon")
_scaAuthMenu.MenuKey = field.NewString(tableName, "menu_key")
_scaAuthMenu.Order_ = field.NewInt64(tableName, "order")
_scaAuthMenu.CreatedAt = field.NewTime(tableName, "created_at")
_scaAuthMenu.UpdatedAt = field.NewTime(tableName, "updated_at")
_scaAuthMenu.Remark = field.NewString(tableName, "remark")
_scaAuthMenu.DeletedAt = field.NewField(tableName, "deleted_at")
_scaAuthMenu.fillFieldMap()
return _scaAuthMenu
}
type scaAuthMenu struct {
scaAuthMenuDo
ALL field.Asterisk
ID field.Int64 // 主键ID
MenuName field.String // 名称
ParentID field.Int64 // 父ID
Type field.Int64 // 类型
Path field.String // 路径
Status field.Int64 // 状态 0 启用 1 停用
Icon field.String // 图标
MenuKey field.String // 关键字
Order_ field.Int64 // 排序
CreatedAt field.Time // 创建时间
UpdatedAt field.Time // 更新时间
Remark field.String // 备注 描述
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (s scaAuthMenu) Table(newTableName string) *scaAuthMenu {
s.scaAuthMenuDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaAuthMenu) As(alias string) *scaAuthMenu {
s.scaAuthMenuDo.DO = *(s.scaAuthMenuDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaAuthMenu) updateTableName(table string) *scaAuthMenu {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.MenuName = field.NewString(table, "menu_name")
s.ParentID = field.NewInt64(table, "parent_id")
s.Type = field.NewInt64(table, "type")
s.Path = field.NewString(table, "path")
s.Status = field.NewInt64(table, "status")
s.Icon = field.NewString(table, "icon")
s.MenuKey = field.NewString(table, "menu_key")
s.Order_ = field.NewInt64(table, "order")
s.CreatedAt = field.NewTime(table, "created_at")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.Remark = field.NewString(table, "remark")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
return s
}
func (s *scaAuthMenu) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaAuthMenu) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 13)
s.fieldMap["id"] = s.ID
s.fieldMap["menu_name"] = s.MenuName
s.fieldMap["parent_id"] = s.ParentID
s.fieldMap["type"] = s.Type
s.fieldMap["path"] = s.Path
s.fieldMap["status"] = s.Status
s.fieldMap["icon"] = s.Icon
s.fieldMap["menu_key"] = s.MenuKey
s.fieldMap["order"] = s.Order_
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["remark"] = s.Remark
s.fieldMap["deleted_at"] = s.DeletedAt
}
func (s scaAuthMenu) clone(db *gorm.DB) scaAuthMenu {
s.scaAuthMenuDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaAuthMenu) replaceDB(db *gorm.DB) scaAuthMenu {
s.scaAuthMenuDo.ReplaceDB(db)
return s
}
type scaAuthMenuDo struct{ gen.DO }
type IScaAuthMenuDo interface {
gen.SubQuery
Debug() IScaAuthMenuDo
WithContext(ctx context.Context) IScaAuthMenuDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaAuthMenuDo
WriteDB() IScaAuthMenuDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaAuthMenuDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaAuthMenuDo
Not(conds ...gen.Condition) IScaAuthMenuDo
Or(conds ...gen.Condition) IScaAuthMenuDo
Select(conds ...field.Expr) IScaAuthMenuDo
Where(conds ...gen.Condition) IScaAuthMenuDo
Order(conds ...field.Expr) IScaAuthMenuDo
Distinct(cols ...field.Expr) IScaAuthMenuDo
Omit(cols ...field.Expr) IScaAuthMenuDo
Join(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo
Group(cols ...field.Expr) IScaAuthMenuDo
Having(conds ...gen.Condition) IScaAuthMenuDo
Limit(limit int) IScaAuthMenuDo
Offset(offset int) IScaAuthMenuDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthMenuDo
Unscoped() IScaAuthMenuDo
Create(values ...*model.ScaAuthMenu) error
CreateInBatches(values []*model.ScaAuthMenu, batchSize int) error
Save(values ...*model.ScaAuthMenu) error
First() (*model.ScaAuthMenu, error)
Take() (*model.ScaAuthMenu, error)
Last() (*model.ScaAuthMenu, error)
Find() ([]*model.ScaAuthMenu, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthMenu, err error)
FindInBatches(result *[]*model.ScaAuthMenu, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaAuthMenu) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaAuthMenuDo
Assign(attrs ...field.AssignExpr) IScaAuthMenuDo
Joins(fields ...field.RelationField) IScaAuthMenuDo
Preload(fields ...field.RelationField) IScaAuthMenuDo
FirstOrInit() (*model.ScaAuthMenu, error)
FirstOrCreate() (*model.ScaAuthMenu, error)
FindByPage(offset int, limit int) (result []*model.ScaAuthMenu, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaAuthMenuDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaAuthMenuDo) Debug() IScaAuthMenuDo {
return s.withDO(s.DO.Debug())
}
func (s scaAuthMenuDo) WithContext(ctx context.Context) IScaAuthMenuDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaAuthMenuDo) ReadDB() IScaAuthMenuDo {
return s.Clauses(dbresolver.Read)
}
func (s scaAuthMenuDo) WriteDB() IScaAuthMenuDo {
return s.Clauses(dbresolver.Write)
}
func (s scaAuthMenuDo) Session(config *gorm.Session) IScaAuthMenuDo {
return s.withDO(s.DO.Session(config))
}
func (s scaAuthMenuDo) Clauses(conds ...clause.Expression) IScaAuthMenuDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaAuthMenuDo) Returning(value interface{}, columns ...string) IScaAuthMenuDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaAuthMenuDo) Not(conds ...gen.Condition) IScaAuthMenuDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaAuthMenuDo) Or(conds ...gen.Condition) IScaAuthMenuDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaAuthMenuDo) Select(conds ...field.Expr) IScaAuthMenuDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaAuthMenuDo) Where(conds ...gen.Condition) IScaAuthMenuDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaAuthMenuDo) Order(conds ...field.Expr) IScaAuthMenuDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaAuthMenuDo) Distinct(cols ...field.Expr) IScaAuthMenuDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaAuthMenuDo) Omit(cols ...field.Expr) IScaAuthMenuDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaAuthMenuDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaAuthMenuDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaAuthMenuDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaAuthMenuDo) Group(cols ...field.Expr) IScaAuthMenuDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaAuthMenuDo) Having(conds ...gen.Condition) IScaAuthMenuDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaAuthMenuDo) Limit(limit int) IScaAuthMenuDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaAuthMenuDo) Offset(offset int) IScaAuthMenuDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaAuthMenuDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthMenuDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaAuthMenuDo) Unscoped() IScaAuthMenuDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaAuthMenuDo) Create(values ...*model.ScaAuthMenu) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaAuthMenuDo) CreateInBatches(values []*model.ScaAuthMenu, batchSize int) error {
return s.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 (s scaAuthMenuDo) Save(values ...*model.ScaAuthMenu) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaAuthMenuDo) First() (*model.ScaAuthMenu, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthMenu), nil
}
}
func (s scaAuthMenuDo) Take() (*model.ScaAuthMenu, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthMenu), nil
}
}
func (s scaAuthMenuDo) Last() (*model.ScaAuthMenu, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthMenu), nil
}
}
func (s scaAuthMenuDo) Find() ([]*model.ScaAuthMenu, error) {
result, err := s.DO.Find()
return result.([]*model.ScaAuthMenu), err
}
func (s scaAuthMenuDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthMenu, err error) {
buf := make([]*model.ScaAuthMenu, 0, batchSize)
err = s.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 (s scaAuthMenuDo) FindInBatches(result *[]*model.ScaAuthMenu, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaAuthMenuDo) Attrs(attrs ...field.AssignExpr) IScaAuthMenuDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaAuthMenuDo) Assign(attrs ...field.AssignExpr) IScaAuthMenuDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaAuthMenuDo) Joins(fields ...field.RelationField) IScaAuthMenuDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaAuthMenuDo) Preload(fields ...field.RelationField) IScaAuthMenuDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaAuthMenuDo) FirstOrInit() (*model.ScaAuthMenu, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthMenu), nil
}
}
func (s scaAuthMenuDo) FirstOrCreate() (*model.ScaAuthMenu, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthMenu), nil
}
}
func (s scaAuthMenuDo) FindByPage(offset int, limit int) (result []*model.ScaAuthMenu, count int64, err error) {
result, err = s.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 = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaAuthMenuDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaAuthMenuDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaAuthMenuDo) Delete(models ...*model.ScaAuthMenu) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaAuthMenuDo) withDO(do gen.Dao) *scaAuthMenuDo {
s.DO = *do.(*gen.DO)
return s
}

407
app/auth/api/model/mysql/query/sca_auth_permission_rule.gen.go Normal file
View File

@@ -0,0 +1,407 @@
// 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 query
import (
"context"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newScaAuthPermissionRule(db *gorm.DB, opts ...gen.DOOption) scaAuthPermissionRule {
_scaAuthPermissionRule := scaAuthPermissionRule{}
_scaAuthPermissionRule.scaAuthPermissionRuleDo.UseDB(db, opts...)
_scaAuthPermissionRule.scaAuthPermissionRuleDo.UseModel(&model.ScaAuthPermissionRule{})
tableName := _scaAuthPermissionRule.scaAuthPermissionRuleDo.TableName()
_scaAuthPermissionRule.ALL = field.NewAsterisk(tableName)
_scaAuthPermissionRule.ID = field.NewInt64(tableName, "id")
_scaAuthPermissionRule.Ptype = field.NewString(tableName, "ptype")
_scaAuthPermissionRule.V0 = field.NewString(tableName, "v0")
_scaAuthPermissionRule.V1 = field.NewString(tableName, "v1")
_scaAuthPermissionRule.V2 = field.NewString(tableName, "v2")
_scaAuthPermissionRule.V3 = field.NewString(tableName, "v3")
_scaAuthPermissionRule.V4 = field.NewString(tableName, "v4")
_scaAuthPermissionRule.V5 = field.NewString(tableName, "v5")
_scaAuthPermissionRule.fillFieldMap()
return _scaAuthPermissionRule
}
type scaAuthPermissionRule struct {
scaAuthPermissionRuleDo
ALL field.Asterisk
ID field.Int64
Ptype field.String
V0 field.String
V1 field.String
V2 field.String
V3 field.String
V4 field.String
V5 field.String
fieldMap map[string]field.Expr
}
func (s scaAuthPermissionRule) Table(newTableName string) *scaAuthPermissionRule {
s.scaAuthPermissionRuleDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaAuthPermissionRule) As(alias string) *scaAuthPermissionRule {
s.scaAuthPermissionRuleDo.DO = *(s.scaAuthPermissionRuleDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaAuthPermissionRule) updateTableName(table string) *scaAuthPermissionRule {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.Ptype = field.NewString(table, "ptype")
s.V0 = field.NewString(table, "v0")
s.V1 = field.NewString(table, "v1")
s.V2 = field.NewString(table, "v2")
s.V3 = field.NewString(table, "v3")
s.V4 = field.NewString(table, "v4")
s.V5 = field.NewString(table, "v5")
s.fillFieldMap()
return s
}
func (s *scaAuthPermissionRule) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaAuthPermissionRule) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 8)
s.fieldMap["id"] = s.ID
s.fieldMap["ptype"] = s.Ptype
s.fieldMap["v0"] = s.V0
s.fieldMap["v1"] = s.V1
s.fieldMap["v2"] = s.V2
s.fieldMap["v3"] = s.V3
s.fieldMap["v4"] = s.V4
s.fieldMap["v5"] = s.V5
}
func (s scaAuthPermissionRule) clone(db *gorm.DB) scaAuthPermissionRule {
s.scaAuthPermissionRuleDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaAuthPermissionRule) replaceDB(db *gorm.DB) scaAuthPermissionRule {
s.scaAuthPermissionRuleDo.ReplaceDB(db)
return s
}
type scaAuthPermissionRuleDo struct{ gen.DO }
type IScaAuthPermissionRuleDo interface {
gen.SubQuery
Debug() IScaAuthPermissionRuleDo
WithContext(ctx context.Context) IScaAuthPermissionRuleDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaAuthPermissionRuleDo
WriteDB() IScaAuthPermissionRuleDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaAuthPermissionRuleDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaAuthPermissionRuleDo
Not(conds ...gen.Condition) IScaAuthPermissionRuleDo
Or(conds ...gen.Condition) IScaAuthPermissionRuleDo
Select(conds ...field.Expr) IScaAuthPermissionRuleDo
Where(conds ...gen.Condition) IScaAuthPermissionRuleDo
Order(conds ...field.Expr) IScaAuthPermissionRuleDo
Distinct(cols ...field.Expr) IScaAuthPermissionRuleDo
Omit(cols ...field.Expr) IScaAuthPermissionRuleDo
Join(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo
Group(cols ...field.Expr) IScaAuthPermissionRuleDo
Having(conds ...gen.Condition) IScaAuthPermissionRuleDo
Limit(limit int) IScaAuthPermissionRuleDo
Offset(offset int) IScaAuthPermissionRuleDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthPermissionRuleDo
Unscoped() IScaAuthPermissionRuleDo
Create(values ...*model.ScaAuthPermissionRule) error
CreateInBatches(values []*model.ScaAuthPermissionRule, batchSize int) error
Save(values ...*model.ScaAuthPermissionRule) error
First() (*model.ScaAuthPermissionRule, error)
Take() (*model.ScaAuthPermissionRule, error)
Last() (*model.ScaAuthPermissionRule, error)
Find() ([]*model.ScaAuthPermissionRule, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthPermissionRule, err error)
FindInBatches(result *[]*model.ScaAuthPermissionRule, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaAuthPermissionRule) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaAuthPermissionRuleDo
Assign(attrs ...field.AssignExpr) IScaAuthPermissionRuleDo
Joins(fields ...field.RelationField) IScaAuthPermissionRuleDo
Preload(fields ...field.RelationField) IScaAuthPermissionRuleDo
FirstOrInit() (*model.ScaAuthPermissionRule, error)
FirstOrCreate() (*model.ScaAuthPermissionRule, error)
FindByPage(offset int, limit int) (result []*model.ScaAuthPermissionRule, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaAuthPermissionRuleDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaAuthPermissionRuleDo) Debug() IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Debug())
}
func (s scaAuthPermissionRuleDo) WithContext(ctx context.Context) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaAuthPermissionRuleDo) ReadDB() IScaAuthPermissionRuleDo {
return s.Clauses(dbresolver.Read)
}
func (s scaAuthPermissionRuleDo) WriteDB() IScaAuthPermissionRuleDo {
return s.Clauses(dbresolver.Write)
}
func (s scaAuthPermissionRuleDo) Session(config *gorm.Session) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Session(config))
}
func (s scaAuthPermissionRuleDo) Clauses(conds ...clause.Expression) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaAuthPermissionRuleDo) Returning(value interface{}, columns ...string) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaAuthPermissionRuleDo) Not(conds ...gen.Condition) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaAuthPermissionRuleDo) Or(conds ...gen.Condition) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaAuthPermissionRuleDo) Select(conds ...field.Expr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaAuthPermissionRuleDo) Where(conds ...gen.Condition) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaAuthPermissionRuleDo) Order(conds ...field.Expr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaAuthPermissionRuleDo) Distinct(cols ...field.Expr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaAuthPermissionRuleDo) Omit(cols ...field.Expr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaAuthPermissionRuleDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaAuthPermissionRuleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaAuthPermissionRuleDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaAuthPermissionRuleDo) Group(cols ...field.Expr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaAuthPermissionRuleDo) Having(conds ...gen.Condition) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaAuthPermissionRuleDo) Limit(limit int) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaAuthPermissionRuleDo) Offset(offset int) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaAuthPermissionRuleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaAuthPermissionRuleDo) Unscoped() IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaAuthPermissionRuleDo) Create(values ...*model.ScaAuthPermissionRule) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaAuthPermissionRuleDo) CreateInBatches(values []*model.ScaAuthPermissionRule, batchSize int) error {
return s.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 (s scaAuthPermissionRuleDo) Save(values ...*model.ScaAuthPermissionRule) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaAuthPermissionRuleDo) First() (*model.ScaAuthPermissionRule, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthPermissionRule), nil
}
}
func (s scaAuthPermissionRuleDo) Take() (*model.ScaAuthPermissionRule, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthPermissionRule), nil
}
}
func (s scaAuthPermissionRuleDo) Last() (*model.ScaAuthPermissionRule, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthPermissionRule), nil
}
}
func (s scaAuthPermissionRuleDo) Find() ([]*model.ScaAuthPermissionRule, error) {
result, err := s.DO.Find()
return result.([]*model.ScaAuthPermissionRule), err
}
func (s scaAuthPermissionRuleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthPermissionRule, err error) {
buf := make([]*model.ScaAuthPermissionRule, 0, batchSize)
err = s.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 (s scaAuthPermissionRuleDo) FindInBatches(result *[]*model.ScaAuthPermissionRule, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaAuthPermissionRuleDo) Attrs(attrs ...field.AssignExpr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaAuthPermissionRuleDo) Assign(attrs ...field.AssignExpr) IScaAuthPermissionRuleDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaAuthPermissionRuleDo) Joins(fields ...field.RelationField) IScaAuthPermissionRuleDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaAuthPermissionRuleDo) Preload(fields ...field.RelationField) IScaAuthPermissionRuleDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaAuthPermissionRuleDo) FirstOrInit() (*model.ScaAuthPermissionRule, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthPermissionRule), nil
}
}
func (s scaAuthPermissionRuleDo) FirstOrCreate() (*model.ScaAuthPermissionRule, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthPermissionRule), nil
}
}
func (s scaAuthPermissionRuleDo) FindByPage(offset int, limit int) (result []*model.ScaAuthPermissionRule, count int64, err error) {
result, err = s.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 = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaAuthPermissionRuleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaAuthPermissionRuleDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaAuthPermissionRuleDo) Delete(models ...*model.ScaAuthPermissionRule) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaAuthPermissionRuleDo) withDO(do gen.Dao) *scaAuthPermissionRuleDo {
s.DO = *do.(*gen.DO)
return s
}

399
app/auth/api/model/mysql/query/sca_auth_role.gen.go Normal file
View File

@@ -0,0 +1,399 @@
// 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 query
import (
"context"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newScaAuthRole(db *gorm.DB, opts ...gen.DOOption) scaAuthRole {
_scaAuthRole := scaAuthRole{}
_scaAuthRole.scaAuthRoleDo.UseDB(db, opts...)
_scaAuthRole.scaAuthRoleDo.UseModel(&model.ScaAuthRole{})
tableName := _scaAuthRole.scaAuthRoleDo.TableName()
_scaAuthRole.ALL = field.NewAsterisk(tableName)
_scaAuthRole.ID = field.NewInt64(tableName, "id")
_scaAuthRole.RoleName = field.NewString(tableName, "role_name")
_scaAuthRole.RoleKey = field.NewString(tableName, "role_key")
_scaAuthRole.CreatedAt = field.NewTime(tableName, "created_at")
_scaAuthRole.UpdatedAt = field.NewTime(tableName, "updated_at")
_scaAuthRole.DeletedAt = field.NewField(tableName, "deleted_at")
_scaAuthRole.fillFieldMap()
return _scaAuthRole
}
type scaAuthRole struct {
scaAuthRoleDo
ALL field.Asterisk
ID field.Int64 // 主键ID
RoleName field.String // 角色名称
RoleKey field.String // 角色关键字
CreatedAt field.Time // 创建时间
UpdatedAt field.Time // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (s scaAuthRole) Table(newTableName string) *scaAuthRole {
s.scaAuthRoleDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaAuthRole) As(alias string) *scaAuthRole {
s.scaAuthRoleDo.DO = *(s.scaAuthRoleDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaAuthRole) updateTableName(table string) *scaAuthRole {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.RoleName = field.NewString(table, "role_name")
s.RoleKey = field.NewString(table, "role_key")
s.CreatedAt = field.NewTime(table, "created_at")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
return s
}
func (s *scaAuthRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaAuthRole) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 6)
s.fieldMap["id"] = s.ID
s.fieldMap["role_name"] = s.RoleName
s.fieldMap["role_key"] = s.RoleKey
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
}
func (s scaAuthRole) clone(db *gorm.DB) scaAuthRole {
s.scaAuthRoleDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaAuthRole) replaceDB(db *gorm.DB) scaAuthRole {
s.scaAuthRoleDo.ReplaceDB(db)
return s
}
type scaAuthRoleDo struct{ gen.DO }
type IScaAuthRoleDo interface {
gen.SubQuery
Debug() IScaAuthRoleDo
WithContext(ctx context.Context) IScaAuthRoleDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaAuthRoleDo
WriteDB() IScaAuthRoleDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaAuthRoleDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaAuthRoleDo
Not(conds ...gen.Condition) IScaAuthRoleDo
Or(conds ...gen.Condition) IScaAuthRoleDo
Select(conds ...field.Expr) IScaAuthRoleDo
Where(conds ...gen.Condition) IScaAuthRoleDo
Order(conds ...field.Expr) IScaAuthRoleDo
Distinct(cols ...field.Expr) IScaAuthRoleDo
Omit(cols ...field.Expr) IScaAuthRoleDo
Join(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo
Group(cols ...field.Expr) IScaAuthRoleDo
Having(conds ...gen.Condition) IScaAuthRoleDo
Limit(limit int) IScaAuthRoleDo
Offset(offset int) IScaAuthRoleDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthRoleDo
Unscoped() IScaAuthRoleDo
Create(values ...*model.ScaAuthRole) error
CreateInBatches(values []*model.ScaAuthRole, batchSize int) error
Save(values ...*model.ScaAuthRole) error
First() (*model.ScaAuthRole, error)
Take() (*model.ScaAuthRole, error)
Last() (*model.ScaAuthRole, error)
Find() ([]*model.ScaAuthRole, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthRole, err error)
FindInBatches(result *[]*model.ScaAuthRole, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaAuthRole) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaAuthRoleDo
Assign(attrs ...field.AssignExpr) IScaAuthRoleDo
Joins(fields ...field.RelationField) IScaAuthRoleDo
Preload(fields ...field.RelationField) IScaAuthRoleDo
FirstOrInit() (*model.ScaAuthRole, error)
FirstOrCreate() (*model.ScaAuthRole, error)
FindByPage(offset int, limit int) (result []*model.ScaAuthRole, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaAuthRoleDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaAuthRoleDo) Debug() IScaAuthRoleDo {
return s.withDO(s.DO.Debug())
}
func (s scaAuthRoleDo) WithContext(ctx context.Context) IScaAuthRoleDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaAuthRoleDo) ReadDB() IScaAuthRoleDo {
return s.Clauses(dbresolver.Read)
}
func (s scaAuthRoleDo) WriteDB() IScaAuthRoleDo {
return s.Clauses(dbresolver.Write)
}
func (s scaAuthRoleDo) Session(config *gorm.Session) IScaAuthRoleDo {
return s.withDO(s.DO.Session(config))
}
func (s scaAuthRoleDo) Clauses(conds ...clause.Expression) IScaAuthRoleDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaAuthRoleDo) Returning(value interface{}, columns ...string) IScaAuthRoleDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaAuthRoleDo) Not(conds ...gen.Condition) IScaAuthRoleDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaAuthRoleDo) Or(conds ...gen.Condition) IScaAuthRoleDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaAuthRoleDo) Select(conds ...field.Expr) IScaAuthRoleDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaAuthRoleDo) Where(conds ...gen.Condition) IScaAuthRoleDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaAuthRoleDo) Order(conds ...field.Expr) IScaAuthRoleDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaAuthRoleDo) Distinct(cols ...field.Expr) IScaAuthRoleDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaAuthRoleDo) Omit(cols ...field.Expr) IScaAuthRoleDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaAuthRoleDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaAuthRoleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaAuthRoleDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaAuthRoleDo) Group(cols ...field.Expr) IScaAuthRoleDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaAuthRoleDo) Having(conds ...gen.Condition) IScaAuthRoleDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaAuthRoleDo) Limit(limit int) IScaAuthRoleDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaAuthRoleDo) Offset(offset int) IScaAuthRoleDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaAuthRoleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthRoleDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaAuthRoleDo) Unscoped() IScaAuthRoleDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaAuthRoleDo) Create(values ...*model.ScaAuthRole) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaAuthRoleDo) CreateInBatches(values []*model.ScaAuthRole, batchSize int) error {
return s.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 (s scaAuthRoleDo) Save(values ...*model.ScaAuthRole) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaAuthRoleDo) First() (*model.ScaAuthRole, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthRole), nil
}
}
func (s scaAuthRoleDo) Take() (*model.ScaAuthRole, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthRole), nil
}
}
func (s scaAuthRoleDo) Last() (*model.ScaAuthRole, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthRole), nil
}
}
func (s scaAuthRoleDo) Find() ([]*model.ScaAuthRole, error) {
result, err := s.DO.Find()
return result.([]*model.ScaAuthRole), err
}
func (s scaAuthRoleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthRole, err error) {
buf := make([]*model.ScaAuthRole, 0, batchSize)
err = s.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 (s scaAuthRoleDo) FindInBatches(result *[]*model.ScaAuthRole, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaAuthRoleDo) Attrs(attrs ...field.AssignExpr) IScaAuthRoleDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaAuthRoleDo) Assign(attrs ...field.AssignExpr) IScaAuthRoleDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaAuthRoleDo) Joins(fields ...field.RelationField) IScaAuthRoleDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaAuthRoleDo) Preload(fields ...field.RelationField) IScaAuthRoleDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaAuthRoleDo) FirstOrInit() (*model.ScaAuthRole, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthRole), nil
}
}
func (s scaAuthRoleDo) FirstOrCreate() (*model.ScaAuthRole, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthRole), nil
}
}
func (s scaAuthRoleDo) FindByPage(offset int, limit int) (result []*model.ScaAuthRole, count int64, err error) {
result, err = s.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 = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaAuthRoleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaAuthRoleDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaAuthRoleDo) Delete(models ...*model.ScaAuthRole) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaAuthRoleDo) withDO(do gen.Dao) *scaAuthRoleDo {
s.DO = *do.(*gen.DO)
return s
}

443
app/auth/api/model/mysql/query/sca_auth_user.gen.go Normal file
View File

@@ -0,0 +1,443 @@
// 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 query
import (
"context"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newScaAuthUser(db *gorm.DB, opts ...gen.DOOption) scaAuthUser {
_scaAuthUser := scaAuthUser{}
_scaAuthUser.scaAuthUserDo.UseDB(db, opts...)
_scaAuthUser.scaAuthUserDo.UseModel(&model.ScaAuthUser{})
tableName := _scaAuthUser.scaAuthUserDo.TableName()
_scaAuthUser.ALL = field.NewAsterisk(tableName)
_scaAuthUser.ID = field.NewInt64(tableName, "id")
_scaAuthUser.UID = field.NewString(tableName, "uid")
_scaAuthUser.Username = field.NewString(tableName, "username")
_scaAuthUser.Nickname = field.NewString(tableName, "nickname")
_scaAuthUser.Email = field.NewString(tableName, "email")
_scaAuthUser.Phone = field.NewString(tableName, "phone")
_scaAuthUser.Password = field.NewString(tableName, "password")
_scaAuthUser.Gender = field.NewInt64(tableName, "gender")
_scaAuthUser.Avatar = field.NewString(tableName, "avatar")
_scaAuthUser.Status = field.NewInt64(tableName, "status")
_scaAuthUser.Introduce = field.NewString(tableName, "introduce")
_scaAuthUser.CreatedAt = field.NewTime(tableName, "created_at")
_scaAuthUser.Blog = field.NewString(tableName, "blog")
_scaAuthUser.Location = field.NewString(tableName, "location")
_scaAuthUser.Company = field.NewString(tableName, "company")
_scaAuthUser.UpdatedAt = field.NewTime(tableName, "updated_at")
_scaAuthUser.DeletedAt = field.NewField(tableName, "deleted_at")
_scaAuthUser.fillFieldMap()
return _scaAuthUser
}
type scaAuthUser struct {
scaAuthUserDo
ALL field.Asterisk
ID field.Int64 // 自增ID
UID field.String // 唯一ID
Username field.String // 用户名
Nickname field.String // 昵称
Email field.String // 邮箱
Phone field.String // 电话
Password field.String // 密码
Gender field.Int64 // 性别
Avatar field.String // 头像
Status field.Int64 // 状态 0 正常 1 封禁
Introduce field.String // 介绍
CreatedAt field.Time // 创建时间
Blog field.String // 博客
Location field.String // 地址
Company field.String // 公司
UpdatedAt field.Time // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (s scaAuthUser) Table(newTableName string) *scaAuthUser {
s.scaAuthUserDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaAuthUser) As(alias string) *scaAuthUser {
s.scaAuthUserDo.DO = *(s.scaAuthUserDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaAuthUser) updateTableName(table string) *scaAuthUser {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.UID = field.NewString(table, "uid")
s.Username = field.NewString(table, "username")
s.Nickname = field.NewString(table, "nickname")
s.Email = field.NewString(table, "email")
s.Phone = field.NewString(table, "phone")
s.Password = field.NewString(table, "password")
s.Gender = field.NewInt64(table, "gender")
s.Avatar = field.NewString(table, "avatar")
s.Status = field.NewInt64(table, "status")
s.Introduce = field.NewString(table, "introduce")
s.CreatedAt = field.NewTime(table, "created_at")
s.Blog = field.NewString(table, "blog")
s.Location = field.NewString(table, "location")
s.Company = field.NewString(table, "company")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
return s
}
func (s *scaAuthUser) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaAuthUser) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 17)
s.fieldMap["id"] = s.ID
s.fieldMap["uid"] = s.UID
s.fieldMap["username"] = s.Username
s.fieldMap["nickname"] = s.Nickname
s.fieldMap["email"] = s.Email
s.fieldMap["phone"] = s.Phone
s.fieldMap["password"] = s.Password
s.fieldMap["gender"] = s.Gender
s.fieldMap["avatar"] = s.Avatar
s.fieldMap["status"] = s.Status
s.fieldMap["introduce"] = s.Introduce
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["blog"] = s.Blog
s.fieldMap["location"] = s.Location
s.fieldMap["company"] = s.Company
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
}
func (s scaAuthUser) clone(db *gorm.DB) scaAuthUser {
s.scaAuthUserDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaAuthUser) replaceDB(db *gorm.DB) scaAuthUser {
s.scaAuthUserDo.ReplaceDB(db)
return s
}
type scaAuthUserDo struct{ gen.DO }
type IScaAuthUserDo interface {
gen.SubQuery
Debug() IScaAuthUserDo
WithContext(ctx context.Context) IScaAuthUserDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaAuthUserDo
WriteDB() IScaAuthUserDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaAuthUserDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaAuthUserDo
Not(conds ...gen.Condition) IScaAuthUserDo
Or(conds ...gen.Condition) IScaAuthUserDo
Select(conds ...field.Expr) IScaAuthUserDo
Where(conds ...gen.Condition) IScaAuthUserDo
Order(conds ...field.Expr) IScaAuthUserDo
Distinct(cols ...field.Expr) IScaAuthUserDo
Omit(cols ...field.Expr) IScaAuthUserDo
Join(table schema.Tabler, on ...field.Expr) IScaAuthUserDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDo
Group(cols ...field.Expr) IScaAuthUserDo
Having(conds ...gen.Condition) IScaAuthUserDo
Limit(limit int) IScaAuthUserDo
Offset(offset int) IScaAuthUserDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserDo
Unscoped() IScaAuthUserDo
Create(values ...*model.ScaAuthUser) error
CreateInBatches(values []*model.ScaAuthUser, batchSize int) error
Save(values ...*model.ScaAuthUser) error
First() (*model.ScaAuthUser, error)
Take() (*model.ScaAuthUser, error)
Last() (*model.ScaAuthUser, error)
Find() ([]*model.ScaAuthUser, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUser, err error)
FindInBatches(result *[]*model.ScaAuthUser, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaAuthUser) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaAuthUserDo
Assign(attrs ...field.AssignExpr) IScaAuthUserDo
Joins(fields ...field.RelationField) IScaAuthUserDo
Preload(fields ...field.RelationField) IScaAuthUserDo
FirstOrInit() (*model.ScaAuthUser, error)
FirstOrCreate() (*model.ScaAuthUser, error)
FindByPage(offset int, limit int) (result []*model.ScaAuthUser, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaAuthUserDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaAuthUserDo) Debug() IScaAuthUserDo {
return s.withDO(s.DO.Debug())
}
func (s scaAuthUserDo) WithContext(ctx context.Context) IScaAuthUserDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaAuthUserDo) ReadDB() IScaAuthUserDo {
return s.Clauses(dbresolver.Read)
}
func (s scaAuthUserDo) WriteDB() IScaAuthUserDo {
return s.Clauses(dbresolver.Write)
}
func (s scaAuthUserDo) Session(config *gorm.Session) IScaAuthUserDo {
return s.withDO(s.DO.Session(config))
}
func (s scaAuthUserDo) Clauses(conds ...clause.Expression) IScaAuthUserDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaAuthUserDo) Returning(value interface{}, columns ...string) IScaAuthUserDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaAuthUserDo) Not(conds ...gen.Condition) IScaAuthUserDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaAuthUserDo) Or(conds ...gen.Condition) IScaAuthUserDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaAuthUserDo) Select(conds ...field.Expr) IScaAuthUserDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaAuthUserDo) Where(conds ...gen.Condition) IScaAuthUserDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaAuthUserDo) Order(conds ...field.Expr) IScaAuthUserDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaAuthUserDo) Distinct(cols ...field.Expr) IScaAuthUserDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaAuthUserDo) Omit(cols ...field.Expr) IScaAuthUserDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaAuthUserDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthUserDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaAuthUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaAuthUserDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaAuthUserDo) Group(cols ...field.Expr) IScaAuthUserDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaAuthUserDo) Having(conds ...gen.Condition) IScaAuthUserDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaAuthUserDo) Limit(limit int) IScaAuthUserDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaAuthUserDo) Offset(offset int) IScaAuthUserDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaAuthUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaAuthUserDo) Unscoped() IScaAuthUserDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaAuthUserDo) Create(values ...*model.ScaAuthUser) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaAuthUserDo) CreateInBatches(values []*model.ScaAuthUser, batchSize int) error {
return s.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 (s scaAuthUserDo) Save(values ...*model.ScaAuthUser) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaAuthUserDo) First() (*model.ScaAuthUser, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUser), nil
}
}
func (s scaAuthUserDo) Take() (*model.ScaAuthUser, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUser), nil
}
}
func (s scaAuthUserDo) Last() (*model.ScaAuthUser, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUser), nil
}
}
func (s scaAuthUserDo) Find() ([]*model.ScaAuthUser, error) {
result, err := s.DO.Find()
return result.([]*model.ScaAuthUser), err
}
func (s scaAuthUserDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUser, err error) {
buf := make([]*model.ScaAuthUser, 0, batchSize)
err = s.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 (s scaAuthUserDo) FindInBatches(result *[]*model.ScaAuthUser, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaAuthUserDo) Attrs(attrs ...field.AssignExpr) IScaAuthUserDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaAuthUserDo) Assign(attrs ...field.AssignExpr) IScaAuthUserDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaAuthUserDo) Joins(fields ...field.RelationField) IScaAuthUserDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaAuthUserDo) Preload(fields ...field.RelationField) IScaAuthUserDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaAuthUserDo) FirstOrInit() (*model.ScaAuthUser, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUser), nil
}
}
func (s scaAuthUserDo) FirstOrCreate() (*model.ScaAuthUser, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUser), nil
}
}
func (s scaAuthUserDo) FindByPage(offset int, limit int) (result []*model.ScaAuthUser, count int64, err error) {
result, err = s.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 = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaAuthUserDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaAuthUserDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaAuthUserDo) Delete(models ...*model.ScaAuthUser) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaAuthUserDo) withDO(do gen.Dao) *scaAuthUserDo {
s.DO = *do.(*gen.DO)
return s
}

443
app/auth/api/model/mysql/query/sca_auth_user_device.gen.go Normal file
View File

@@ -0,0 +1,443 @@
// 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 query
import (
"context"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newScaAuthUserDevice(db *gorm.DB, opts ...gen.DOOption) scaAuthUserDevice {
_scaAuthUserDevice := scaAuthUserDevice{}
_scaAuthUserDevice.scaAuthUserDeviceDo.UseDB(db, opts...)
_scaAuthUserDevice.scaAuthUserDeviceDo.UseModel(&model.ScaAuthUserDevice{})
tableName := _scaAuthUserDevice.scaAuthUserDeviceDo.TableName()
_scaAuthUserDevice.ALL = field.NewAsterisk(tableName)
_scaAuthUserDevice.ID = field.NewInt64(tableName, "id")
_scaAuthUserDevice.UserID = field.NewString(tableName, "user_id")
_scaAuthUserDevice.IP = field.NewString(tableName, "ip")
_scaAuthUserDevice.Location = field.NewString(tableName, "location")
_scaAuthUserDevice.Agent = field.NewString(tableName, "agent")
_scaAuthUserDevice.CreatedAt = field.NewTime(tableName, "created_at")
_scaAuthUserDevice.Browser = field.NewString(tableName, "browser")
_scaAuthUserDevice.OperatingSystem = field.NewString(tableName, "operating_system")
_scaAuthUserDevice.BrowserVersion = field.NewString(tableName, "browser_version")
_scaAuthUserDevice.Mobile = field.NewInt64(tableName, "mobile")
_scaAuthUserDevice.Bot = field.NewInt64(tableName, "bot")
_scaAuthUserDevice.Mozilla = field.NewString(tableName, "mozilla")
_scaAuthUserDevice.Platform = field.NewString(tableName, "platform")
_scaAuthUserDevice.EngineName = field.NewString(tableName, "engine_name")
_scaAuthUserDevice.EngineVersion = field.NewString(tableName, "engine_version")
_scaAuthUserDevice.UpdatedAt = field.NewTime(tableName, "updated_at")
_scaAuthUserDevice.DeletedAt = field.NewField(tableName, "deleted_at")
_scaAuthUserDevice.fillFieldMap()
return _scaAuthUserDevice
}
type scaAuthUserDevice struct {
scaAuthUserDeviceDo
ALL field.Asterisk
ID field.Int64 // 主键ID
UserID field.String // 用户ID
IP field.String // 登录IP
Location field.String // 地址
Agent field.String // 设备信息
CreatedAt field.Time // 创建时间
Browser field.String // 浏览器
OperatingSystem field.String // 操作系统
BrowserVersion field.String // 浏览器版本
Mobile field.Int64 // 是否为手机 0否1是
Bot field.Int64 // 是否为bot 0否1是
Mozilla field.String // 火狐版本
Platform field.String // 平台
EngineName field.String // 引擎名称
EngineVersion field.String // 引擎版本
UpdatedAt field.Time // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (s scaAuthUserDevice) Table(newTableName string) *scaAuthUserDevice {
s.scaAuthUserDeviceDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaAuthUserDevice) As(alias string) *scaAuthUserDevice {
s.scaAuthUserDeviceDo.DO = *(s.scaAuthUserDeviceDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaAuthUserDevice) updateTableName(table string) *scaAuthUserDevice {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.UserID = field.NewString(table, "user_id")
s.IP = field.NewString(table, "ip")
s.Location = field.NewString(table, "location")
s.Agent = field.NewString(table, "agent")
s.CreatedAt = field.NewTime(table, "created_at")
s.Browser = field.NewString(table, "browser")
s.OperatingSystem = field.NewString(table, "operating_system")
s.BrowserVersion = field.NewString(table, "browser_version")
s.Mobile = field.NewInt64(table, "mobile")
s.Bot = field.NewInt64(table, "bot")
s.Mozilla = field.NewString(table, "mozilla")
s.Platform = field.NewString(table, "platform")
s.EngineName = field.NewString(table, "engine_name")
s.EngineVersion = field.NewString(table, "engine_version")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
return s
}
func (s *scaAuthUserDevice) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaAuthUserDevice) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 17)
s.fieldMap["id"] = s.ID
s.fieldMap["user_id"] = s.UserID
s.fieldMap["ip"] = s.IP
s.fieldMap["location"] = s.Location
s.fieldMap["agent"] = s.Agent
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["browser"] = s.Browser
s.fieldMap["operating_system"] = s.OperatingSystem
s.fieldMap["browser_version"] = s.BrowserVersion
s.fieldMap["mobile"] = s.Mobile
s.fieldMap["bot"] = s.Bot
s.fieldMap["mozilla"] = s.Mozilla
s.fieldMap["platform"] = s.Platform
s.fieldMap["engine_name"] = s.EngineName
s.fieldMap["engine_version"] = s.EngineVersion
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
}
func (s scaAuthUserDevice) clone(db *gorm.DB) scaAuthUserDevice {
s.scaAuthUserDeviceDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaAuthUserDevice) replaceDB(db *gorm.DB) scaAuthUserDevice {
s.scaAuthUserDeviceDo.ReplaceDB(db)
return s
}
type scaAuthUserDeviceDo struct{ gen.DO }
type IScaAuthUserDeviceDo interface {
gen.SubQuery
Debug() IScaAuthUserDeviceDo
WithContext(ctx context.Context) IScaAuthUserDeviceDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaAuthUserDeviceDo
WriteDB() IScaAuthUserDeviceDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaAuthUserDeviceDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaAuthUserDeviceDo
Not(conds ...gen.Condition) IScaAuthUserDeviceDo
Or(conds ...gen.Condition) IScaAuthUserDeviceDo
Select(conds ...field.Expr) IScaAuthUserDeviceDo
Where(conds ...gen.Condition) IScaAuthUserDeviceDo
Order(conds ...field.Expr) IScaAuthUserDeviceDo
Distinct(cols ...field.Expr) IScaAuthUserDeviceDo
Omit(cols ...field.Expr) IScaAuthUserDeviceDo
Join(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo
Group(cols ...field.Expr) IScaAuthUserDeviceDo
Having(conds ...gen.Condition) IScaAuthUserDeviceDo
Limit(limit int) IScaAuthUserDeviceDo
Offset(offset int) IScaAuthUserDeviceDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserDeviceDo
Unscoped() IScaAuthUserDeviceDo
Create(values ...*model.ScaAuthUserDevice) error
CreateInBatches(values []*model.ScaAuthUserDevice, batchSize int) error
Save(values ...*model.ScaAuthUserDevice) error
First() (*model.ScaAuthUserDevice, error)
Take() (*model.ScaAuthUserDevice, error)
Last() (*model.ScaAuthUserDevice, error)
Find() ([]*model.ScaAuthUserDevice, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUserDevice, err error)
FindInBatches(result *[]*model.ScaAuthUserDevice, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaAuthUserDevice) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaAuthUserDeviceDo
Assign(attrs ...field.AssignExpr) IScaAuthUserDeviceDo
Joins(fields ...field.RelationField) IScaAuthUserDeviceDo
Preload(fields ...field.RelationField) IScaAuthUserDeviceDo
FirstOrInit() (*model.ScaAuthUserDevice, error)
FirstOrCreate() (*model.ScaAuthUserDevice, error)
FindByPage(offset int, limit int) (result []*model.ScaAuthUserDevice, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaAuthUserDeviceDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaAuthUserDeviceDo) Debug() IScaAuthUserDeviceDo {
return s.withDO(s.DO.Debug())
}
func (s scaAuthUserDeviceDo) WithContext(ctx context.Context) IScaAuthUserDeviceDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaAuthUserDeviceDo) ReadDB() IScaAuthUserDeviceDo {
return s.Clauses(dbresolver.Read)
}
func (s scaAuthUserDeviceDo) WriteDB() IScaAuthUserDeviceDo {
return s.Clauses(dbresolver.Write)
}
func (s scaAuthUserDeviceDo) Session(config *gorm.Session) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Session(config))
}
func (s scaAuthUserDeviceDo) Clauses(conds ...clause.Expression) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaAuthUserDeviceDo) Returning(value interface{}, columns ...string) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaAuthUserDeviceDo) Not(conds ...gen.Condition) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaAuthUserDeviceDo) Or(conds ...gen.Condition) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaAuthUserDeviceDo) Select(conds ...field.Expr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaAuthUserDeviceDo) Where(conds ...gen.Condition) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaAuthUserDeviceDo) Order(conds ...field.Expr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaAuthUserDeviceDo) Distinct(cols ...field.Expr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaAuthUserDeviceDo) Omit(cols ...field.Expr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaAuthUserDeviceDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaAuthUserDeviceDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaAuthUserDeviceDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaAuthUserDeviceDo) Group(cols ...field.Expr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaAuthUserDeviceDo) Having(conds ...gen.Condition) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaAuthUserDeviceDo) Limit(limit int) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaAuthUserDeviceDo) Offset(offset int) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaAuthUserDeviceDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaAuthUserDeviceDo) Unscoped() IScaAuthUserDeviceDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaAuthUserDeviceDo) Create(values ...*model.ScaAuthUserDevice) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaAuthUserDeviceDo) CreateInBatches(values []*model.ScaAuthUserDevice, batchSize int) error {
return s.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 (s scaAuthUserDeviceDo) Save(values ...*model.ScaAuthUserDevice) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaAuthUserDeviceDo) First() (*model.ScaAuthUserDevice, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserDevice), nil
}
}
func (s scaAuthUserDeviceDo) Take() (*model.ScaAuthUserDevice, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserDevice), nil
}
}
func (s scaAuthUserDeviceDo) Last() (*model.ScaAuthUserDevice, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserDevice), nil
}
}
func (s scaAuthUserDeviceDo) Find() ([]*model.ScaAuthUserDevice, error) {
result, err := s.DO.Find()
return result.([]*model.ScaAuthUserDevice), err
}
func (s scaAuthUserDeviceDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUserDevice, err error) {
buf := make([]*model.ScaAuthUserDevice, 0, batchSize)
err = s.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 (s scaAuthUserDeviceDo) FindInBatches(result *[]*model.ScaAuthUserDevice, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaAuthUserDeviceDo) Attrs(attrs ...field.AssignExpr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaAuthUserDeviceDo) Assign(attrs ...field.AssignExpr) IScaAuthUserDeviceDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaAuthUserDeviceDo) Joins(fields ...field.RelationField) IScaAuthUserDeviceDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaAuthUserDeviceDo) Preload(fields ...field.RelationField) IScaAuthUserDeviceDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaAuthUserDeviceDo) FirstOrInit() (*model.ScaAuthUserDevice, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserDevice), nil
}
}
func (s scaAuthUserDeviceDo) FirstOrCreate() (*model.ScaAuthUserDevice, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserDevice), nil
}
}
func (s scaAuthUserDeviceDo) FindByPage(offset int, limit int) (result []*model.ScaAuthUserDevice, count int64, err error) {
result, err = s.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 = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaAuthUserDeviceDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaAuthUserDeviceDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaAuthUserDeviceDo) Delete(models ...*model.ScaAuthUserDevice) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaAuthUserDeviceDo) withDO(do gen.Dao) *scaAuthUserDeviceDo {
s.DO = *do.(*gen.DO)
return s
}

407
app/auth/api/model/mysql/query/sca_auth_user_social.gen.go Normal file
View File

@@ -0,0 +1,407 @@
// 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 query
import (
"context"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newScaAuthUserSocial(db *gorm.DB, opts ...gen.DOOption) scaAuthUserSocial {
_scaAuthUserSocial := scaAuthUserSocial{}
_scaAuthUserSocial.scaAuthUserSocialDo.UseDB(db, opts...)
_scaAuthUserSocial.scaAuthUserSocialDo.UseModel(&model.ScaAuthUserSocial{})
tableName := _scaAuthUserSocial.scaAuthUserSocialDo.TableName()
_scaAuthUserSocial.ALL = field.NewAsterisk(tableName)
_scaAuthUserSocial.ID = field.NewInt64(tableName, "id")
_scaAuthUserSocial.UserID = field.NewString(tableName, "user_id")
_scaAuthUserSocial.OpenID = field.NewString(tableName, "open_id")
_scaAuthUserSocial.Source = field.NewString(tableName, "source")
_scaAuthUserSocial.Status = field.NewInt64(tableName, "status")
_scaAuthUserSocial.CreatedAt = field.NewTime(tableName, "created_at")
_scaAuthUserSocial.UpdatedAt = field.NewTime(tableName, "updated_at")
_scaAuthUserSocial.DeletedAt = field.NewField(tableName, "deleted_at")
_scaAuthUserSocial.fillFieldMap()
return _scaAuthUserSocial
}
type scaAuthUserSocial struct {
scaAuthUserSocialDo
ALL field.Asterisk
ID field.Int64 // 主键ID
UserID field.String // 用户ID
OpenID field.String // 第三方用户的 open id
Source field.String // 第三方用户来源
Status field.Int64 // 状态 0正常 1 封禁
CreatedAt field.Time // 创建时间
UpdatedAt field.Time // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (s scaAuthUserSocial) Table(newTableName string) *scaAuthUserSocial {
s.scaAuthUserSocialDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaAuthUserSocial) As(alias string) *scaAuthUserSocial {
s.scaAuthUserSocialDo.DO = *(s.scaAuthUserSocialDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaAuthUserSocial) updateTableName(table string) *scaAuthUserSocial {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.UserID = field.NewString(table, "user_id")
s.OpenID = field.NewString(table, "open_id")
s.Source = field.NewString(table, "source")
s.Status = field.NewInt64(table, "status")
s.CreatedAt = field.NewTime(table, "created_at")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
return s
}
func (s *scaAuthUserSocial) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaAuthUserSocial) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 8)
s.fieldMap["id"] = s.ID
s.fieldMap["user_id"] = s.UserID
s.fieldMap["open_id"] = s.OpenID
s.fieldMap["source"] = s.Source
s.fieldMap["status"] = s.Status
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
}
func (s scaAuthUserSocial) clone(db *gorm.DB) scaAuthUserSocial {
s.scaAuthUserSocialDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaAuthUserSocial) replaceDB(db *gorm.DB) scaAuthUserSocial {
s.scaAuthUserSocialDo.ReplaceDB(db)
return s
}
type scaAuthUserSocialDo struct{ gen.DO }
type IScaAuthUserSocialDo interface {
gen.SubQuery
Debug() IScaAuthUserSocialDo
WithContext(ctx context.Context) IScaAuthUserSocialDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaAuthUserSocialDo
WriteDB() IScaAuthUserSocialDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaAuthUserSocialDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaAuthUserSocialDo
Not(conds ...gen.Condition) IScaAuthUserSocialDo
Or(conds ...gen.Condition) IScaAuthUserSocialDo
Select(conds ...field.Expr) IScaAuthUserSocialDo
Where(conds ...gen.Condition) IScaAuthUserSocialDo
Order(conds ...field.Expr) IScaAuthUserSocialDo
Distinct(cols ...field.Expr) IScaAuthUserSocialDo
Omit(cols ...field.Expr) IScaAuthUserSocialDo
Join(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo
Group(cols ...field.Expr) IScaAuthUserSocialDo
Having(conds ...gen.Condition) IScaAuthUserSocialDo
Limit(limit int) IScaAuthUserSocialDo
Offset(offset int) IScaAuthUserSocialDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserSocialDo
Unscoped() IScaAuthUserSocialDo
Create(values ...*model.ScaAuthUserSocial) error
CreateInBatches(values []*model.ScaAuthUserSocial, batchSize int) error
Save(values ...*model.ScaAuthUserSocial) error
First() (*model.ScaAuthUserSocial, error)
Take() (*model.ScaAuthUserSocial, error)
Last() (*model.ScaAuthUserSocial, error)
Find() ([]*model.ScaAuthUserSocial, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUserSocial, err error)
FindInBatches(result *[]*model.ScaAuthUserSocial, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaAuthUserSocial) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaAuthUserSocialDo
Assign(attrs ...field.AssignExpr) IScaAuthUserSocialDo
Joins(fields ...field.RelationField) IScaAuthUserSocialDo
Preload(fields ...field.RelationField) IScaAuthUserSocialDo
FirstOrInit() (*model.ScaAuthUserSocial, error)
FirstOrCreate() (*model.ScaAuthUserSocial, error)
FindByPage(offset int, limit int) (result []*model.ScaAuthUserSocial, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaAuthUserSocialDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaAuthUserSocialDo) Debug() IScaAuthUserSocialDo {
return s.withDO(s.DO.Debug())
}
func (s scaAuthUserSocialDo) WithContext(ctx context.Context) IScaAuthUserSocialDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaAuthUserSocialDo) ReadDB() IScaAuthUserSocialDo {
return s.Clauses(dbresolver.Read)
}
func (s scaAuthUserSocialDo) WriteDB() IScaAuthUserSocialDo {
return s.Clauses(dbresolver.Write)
}
func (s scaAuthUserSocialDo) Session(config *gorm.Session) IScaAuthUserSocialDo {
return s.withDO(s.DO.Session(config))
}
func (s scaAuthUserSocialDo) Clauses(conds ...clause.Expression) IScaAuthUserSocialDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaAuthUserSocialDo) Returning(value interface{}, columns ...string) IScaAuthUserSocialDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaAuthUserSocialDo) Not(conds ...gen.Condition) IScaAuthUserSocialDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaAuthUserSocialDo) Or(conds ...gen.Condition) IScaAuthUserSocialDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaAuthUserSocialDo) Select(conds ...field.Expr) IScaAuthUserSocialDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaAuthUserSocialDo) Where(conds ...gen.Condition) IScaAuthUserSocialDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaAuthUserSocialDo) Order(conds ...field.Expr) IScaAuthUserSocialDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaAuthUserSocialDo) Distinct(cols ...field.Expr) IScaAuthUserSocialDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaAuthUserSocialDo) Omit(cols ...field.Expr) IScaAuthUserSocialDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaAuthUserSocialDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaAuthUserSocialDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaAuthUserSocialDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaAuthUserSocialDo) Group(cols ...field.Expr) IScaAuthUserSocialDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaAuthUserSocialDo) Having(conds ...gen.Condition) IScaAuthUserSocialDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaAuthUserSocialDo) Limit(limit int) IScaAuthUserSocialDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaAuthUserSocialDo) Offset(offset int) IScaAuthUserSocialDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaAuthUserSocialDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserSocialDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaAuthUserSocialDo) Unscoped() IScaAuthUserSocialDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaAuthUserSocialDo) Create(values ...*model.ScaAuthUserSocial) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaAuthUserSocialDo) CreateInBatches(values []*model.ScaAuthUserSocial, batchSize int) error {
return s.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 (s scaAuthUserSocialDo) Save(values ...*model.ScaAuthUserSocial) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaAuthUserSocialDo) First() (*model.ScaAuthUserSocial, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserSocial), nil
}
}
func (s scaAuthUserSocialDo) Take() (*model.ScaAuthUserSocial, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserSocial), nil
}
}
func (s scaAuthUserSocialDo) Last() (*model.ScaAuthUserSocial, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserSocial), nil
}
}
func (s scaAuthUserSocialDo) Find() ([]*model.ScaAuthUserSocial, error) {
result, err := s.DO.Find()
return result.([]*model.ScaAuthUserSocial), err
}
func (s scaAuthUserSocialDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUserSocial, err error) {
buf := make([]*model.ScaAuthUserSocial, 0, batchSize)
err = s.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 (s scaAuthUserSocialDo) FindInBatches(result *[]*model.ScaAuthUserSocial, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaAuthUserSocialDo) Attrs(attrs ...field.AssignExpr) IScaAuthUserSocialDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaAuthUserSocialDo) Assign(attrs ...field.AssignExpr) IScaAuthUserSocialDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaAuthUserSocialDo) Joins(fields ...field.RelationField) IScaAuthUserSocialDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaAuthUserSocialDo) Preload(fields ...field.RelationField) IScaAuthUserSocialDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaAuthUserSocialDo) FirstOrInit() (*model.ScaAuthUserSocial, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserSocial), nil
}
}
func (s scaAuthUserSocialDo) FirstOrCreate() (*model.ScaAuthUserSocial, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaAuthUserSocial), nil
}
}
func (s scaAuthUserSocialDo) FindByPage(offset int, limit int) (result []*model.ScaAuthUserSocial, count int64, err error) {
result, err = s.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 = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaAuthUserSocialDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaAuthUserSocialDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaAuthUserSocialDo) Delete(models ...*model.ScaAuthUserSocial) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaAuthUserSocialDo) withDO(do gen.Dao) *scaAuthUserSocialDo {
s.DO = *do.(*gen.DO)
return s
}

419
app/auth/api/model/mysql/query/sca_user_level.gen.go Normal file
View File

@@ -0,0 +1,419 @@
// 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 query
import (
"context"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newScaUserLevel(db *gorm.DB, opts ...gen.DOOption) scaUserLevel {
_scaUserLevel := scaUserLevel{}
_scaUserLevel.scaUserLevelDo.UseDB(db, opts...)
_scaUserLevel.scaUserLevelDo.UseModel(&model.ScaUserLevel{})
tableName := _scaUserLevel.scaUserLevelDo.TableName()
_scaUserLevel.ALL = field.NewAsterisk(tableName)
_scaUserLevel.ID = field.NewInt64(tableName, "id")
_scaUserLevel.UserID = field.NewString(tableName, "user_id")
_scaUserLevel.LevelType = field.NewInt64(tableName, "level_type")
_scaUserLevel.Level = field.NewInt64(tableName, "level")
_scaUserLevel.LevelName = field.NewString(tableName, "level_name")
_scaUserLevel.ExpStart = field.NewInt64(tableName, "exp_start")
_scaUserLevel.ExpEnd = field.NewInt64(tableName, "exp_end")
_scaUserLevel.Description = field.NewString(tableName, "description")
_scaUserLevel.CreatedAt = field.NewTime(tableName, "created_at")
_scaUserLevel.UpdatedAt = field.NewTime(tableName, "updated_at")
_scaUserLevel.DeletedAt = field.NewField(tableName, "deleted_at")
_scaUserLevel.fillFieldMap()
return _scaUserLevel
}
type scaUserLevel struct {
scaUserLevelDo
ALL field.Asterisk
ID field.Int64 // 主键
UserID field.String // 用户Id
LevelType field.Int64 // 等级类型
Level field.Int64 // 等级
LevelName field.String // 等级名称
ExpStart field.Int64 // 开始经验值
ExpEnd field.Int64 // 结束经验值
Description field.String // 等级描述
CreatedAt field.Time // 创建时间
UpdatedAt field.Time // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (s scaUserLevel) Table(newTableName string) *scaUserLevel {
s.scaUserLevelDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaUserLevel) As(alias string) *scaUserLevel {
s.scaUserLevelDo.DO = *(s.scaUserLevelDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaUserLevel) updateTableName(table string) *scaUserLevel {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.UserID = field.NewString(table, "user_id")
s.LevelType = field.NewInt64(table, "level_type")
s.Level = field.NewInt64(table, "level")
s.LevelName = field.NewString(table, "level_name")
s.ExpStart = field.NewInt64(table, "exp_start")
s.ExpEnd = field.NewInt64(table, "exp_end")
s.Description = field.NewString(table, "description")
s.CreatedAt = field.NewTime(table, "created_at")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
return s
}
func (s *scaUserLevel) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaUserLevel) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 11)
s.fieldMap["id"] = s.ID
s.fieldMap["user_id"] = s.UserID
s.fieldMap["level_type"] = s.LevelType
s.fieldMap["level"] = s.Level
s.fieldMap["level_name"] = s.LevelName
s.fieldMap["exp_start"] = s.ExpStart
s.fieldMap["exp_end"] = s.ExpEnd
s.fieldMap["description"] = s.Description
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
}
func (s scaUserLevel) clone(db *gorm.DB) scaUserLevel {
s.scaUserLevelDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaUserLevel) replaceDB(db *gorm.DB) scaUserLevel {
s.scaUserLevelDo.ReplaceDB(db)
return s
}
type scaUserLevelDo struct{ gen.DO }
type IScaUserLevelDo interface {
gen.SubQuery
Debug() IScaUserLevelDo
WithContext(ctx context.Context) IScaUserLevelDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaUserLevelDo
WriteDB() IScaUserLevelDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaUserLevelDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaUserLevelDo
Not(conds ...gen.Condition) IScaUserLevelDo
Or(conds ...gen.Condition) IScaUserLevelDo
Select(conds ...field.Expr) IScaUserLevelDo
Where(conds ...gen.Condition) IScaUserLevelDo
Order(conds ...field.Expr) IScaUserLevelDo
Distinct(cols ...field.Expr) IScaUserLevelDo
Omit(cols ...field.Expr) IScaUserLevelDo
Join(table schema.Tabler, on ...field.Expr) IScaUserLevelDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaUserLevelDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaUserLevelDo
Group(cols ...field.Expr) IScaUserLevelDo
Having(conds ...gen.Condition) IScaUserLevelDo
Limit(limit int) IScaUserLevelDo
Offset(offset int) IScaUserLevelDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaUserLevelDo
Unscoped() IScaUserLevelDo
Create(values ...*model.ScaUserLevel) error
CreateInBatches(values []*model.ScaUserLevel, batchSize int) error
Save(values ...*model.ScaUserLevel) error
First() (*model.ScaUserLevel, error)
Take() (*model.ScaUserLevel, error)
Last() (*model.ScaUserLevel, error)
Find() ([]*model.ScaUserLevel, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaUserLevel, err error)
FindInBatches(result *[]*model.ScaUserLevel, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaUserLevel) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaUserLevelDo
Assign(attrs ...field.AssignExpr) IScaUserLevelDo
Joins(fields ...field.RelationField) IScaUserLevelDo
Preload(fields ...field.RelationField) IScaUserLevelDo
FirstOrInit() (*model.ScaUserLevel, error)
FirstOrCreate() (*model.ScaUserLevel, error)
FindByPage(offset int, limit int) (result []*model.ScaUserLevel, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaUserLevelDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaUserLevelDo) Debug() IScaUserLevelDo {
return s.withDO(s.DO.Debug())
}
func (s scaUserLevelDo) WithContext(ctx context.Context) IScaUserLevelDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaUserLevelDo) ReadDB() IScaUserLevelDo {
return s.Clauses(dbresolver.Read)
}
func (s scaUserLevelDo) WriteDB() IScaUserLevelDo {
return s.Clauses(dbresolver.Write)
}
func (s scaUserLevelDo) Session(config *gorm.Session) IScaUserLevelDo {
return s.withDO(s.DO.Session(config))
}
func (s scaUserLevelDo) Clauses(conds ...clause.Expression) IScaUserLevelDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaUserLevelDo) Returning(value interface{}, columns ...string) IScaUserLevelDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaUserLevelDo) Not(conds ...gen.Condition) IScaUserLevelDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaUserLevelDo) Or(conds ...gen.Condition) IScaUserLevelDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaUserLevelDo) Select(conds ...field.Expr) IScaUserLevelDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaUserLevelDo) Where(conds ...gen.Condition) IScaUserLevelDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaUserLevelDo) Order(conds ...field.Expr) IScaUserLevelDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaUserLevelDo) Distinct(cols ...field.Expr) IScaUserLevelDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaUserLevelDo) Omit(cols ...field.Expr) IScaUserLevelDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaUserLevelDo) Join(table schema.Tabler, on ...field.Expr) IScaUserLevelDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaUserLevelDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaUserLevelDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaUserLevelDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaUserLevelDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaUserLevelDo) Group(cols ...field.Expr) IScaUserLevelDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaUserLevelDo) Having(conds ...gen.Condition) IScaUserLevelDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaUserLevelDo) Limit(limit int) IScaUserLevelDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaUserLevelDo) Offset(offset int) IScaUserLevelDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaUserLevelDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaUserLevelDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaUserLevelDo) Unscoped() IScaUserLevelDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaUserLevelDo) Create(values ...*model.ScaUserLevel) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaUserLevelDo) CreateInBatches(values []*model.ScaUserLevel, batchSize int) error {
return s.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 (s scaUserLevelDo) Save(values ...*model.ScaUserLevel) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaUserLevelDo) First() (*model.ScaUserLevel, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserLevel), nil
}
}
func (s scaUserLevelDo) Take() (*model.ScaUserLevel, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserLevel), nil
}
}
func (s scaUserLevelDo) Last() (*model.ScaUserLevel, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserLevel), nil
}
}
func (s scaUserLevelDo) Find() ([]*model.ScaUserLevel, error) {
result, err := s.DO.Find()
return result.([]*model.ScaUserLevel), err
}
func (s scaUserLevelDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaUserLevel, err error) {
buf := make([]*model.ScaUserLevel, 0, batchSize)
err = s.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 (s scaUserLevelDo) FindInBatches(result *[]*model.ScaUserLevel, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaUserLevelDo) Attrs(attrs ...field.AssignExpr) IScaUserLevelDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaUserLevelDo) Assign(attrs ...field.AssignExpr) IScaUserLevelDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaUserLevelDo) Joins(fields ...field.RelationField) IScaUserLevelDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaUserLevelDo) Preload(fields ...field.RelationField) IScaUserLevelDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaUserLevelDo) FirstOrInit() (*model.ScaUserLevel, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserLevel), nil
}
}
func (s scaUserLevelDo) FirstOrCreate() (*model.ScaUserLevel, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserLevel), nil
}
}
func (s scaUserLevelDo) FindByPage(offset int, limit int) (result []*model.ScaUserLevel, count int64, err error) {
result, err = s.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 = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaUserLevelDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaUserLevelDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaUserLevelDo) Delete(models ...*model.ScaUserLevel) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaUserLevelDo) withDO(do gen.Dao) *scaUserLevelDo {
s.DO = *do.(*gen.DO)
return s
}

411
app/auth/api/model/mysql/query/sca_user_message.gen.go Normal file
View File

@@ -0,0 +1,411 @@
// 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 query
import (
"context"
"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newScaUserMessage(db *gorm.DB, opts ...gen.DOOption) scaUserMessage {
_scaUserMessage := scaUserMessage{}
_scaUserMessage.scaUserMessageDo.UseDB(db, opts...)
_scaUserMessage.scaUserMessageDo.UseModel(&model.ScaUserMessage{})
tableName := _scaUserMessage.scaUserMessageDo.TableName()
_scaUserMessage.ALL = field.NewAsterisk(tableName)
_scaUserMessage.ID = field.NewInt64(tableName, "id")
_scaUserMessage.TopicID = field.NewString(tableName, "topic_id")
_scaUserMessage.FromID = field.NewString(tableName, "from_id")
_scaUserMessage.ToID = field.NewString(tableName, "to_id")
_scaUserMessage.Content = field.NewString(tableName, "content")
_scaUserMessage.IsRead = field.NewInt64(tableName, "is_read")
_scaUserMessage.CreatedAt = field.NewTime(tableName, "created_at")
_scaUserMessage.UpdatedAt = field.NewTime(tableName, "updated_at")
_scaUserMessage.DeletedAt = field.NewField(tableName, "deleted_at")
_scaUserMessage.fillFieldMap()
return _scaUserMessage
}
type scaUserMessage struct {
scaUserMessageDo
ALL field.Asterisk
ID field.Int64 // 主键
TopicID field.String // 话题Id
FromID field.String // 来自人
ToID field.String // 送达人
Content field.String // 消息内容
IsRead field.Int64 // 是否已读
CreatedAt field.Time // 创建时间
UpdatedAt field.Time // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (s scaUserMessage) Table(newTableName string) *scaUserMessage {
s.scaUserMessageDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaUserMessage) As(alias string) *scaUserMessage {
s.scaUserMessageDo.DO = *(s.scaUserMessageDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaUserMessage) updateTableName(table string) *scaUserMessage {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.TopicID = field.NewString(table, "topic_id")
s.FromID = field.NewString(table, "from_id")
s.ToID = field.NewString(table, "to_id")
s.Content = field.NewString(table, "content")
s.IsRead = field.NewInt64(table, "is_read")
s.CreatedAt = field.NewTime(table, "created_at")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
return s
}
func (s *scaUserMessage) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaUserMessage) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 9)
s.fieldMap["id"] = s.ID
s.fieldMap["topic_id"] = s.TopicID
s.fieldMap["from_id"] = s.FromID
s.fieldMap["to_id"] = s.ToID
s.fieldMap["content"] = s.Content
s.fieldMap["is_read"] = s.IsRead
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
}
func (s scaUserMessage) clone(db *gorm.DB) scaUserMessage {
s.scaUserMessageDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaUserMessage) replaceDB(db *gorm.DB) scaUserMessage {
s.scaUserMessageDo.ReplaceDB(db)
return s
}
type scaUserMessageDo struct{ gen.DO }
type IScaUserMessageDo interface {
gen.SubQuery
Debug() IScaUserMessageDo
WithContext(ctx context.Context) IScaUserMessageDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaUserMessageDo
WriteDB() IScaUserMessageDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaUserMessageDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaUserMessageDo
Not(conds ...gen.Condition) IScaUserMessageDo
Or(conds ...gen.Condition) IScaUserMessageDo
Select(conds ...field.Expr) IScaUserMessageDo
Where(conds ...gen.Condition) IScaUserMessageDo
Order(conds ...field.Expr) IScaUserMessageDo
Distinct(cols ...field.Expr) IScaUserMessageDo
Omit(cols ...field.Expr) IScaUserMessageDo
Join(table schema.Tabler, on ...field.Expr) IScaUserMessageDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaUserMessageDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaUserMessageDo
Group(cols ...field.Expr) IScaUserMessageDo
Having(conds ...gen.Condition) IScaUserMessageDo
Limit(limit int) IScaUserMessageDo
Offset(offset int) IScaUserMessageDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaUserMessageDo
Unscoped() IScaUserMessageDo
Create(values ...*model.ScaUserMessage) error
CreateInBatches(values []*model.ScaUserMessage, batchSize int) error
Save(values ...*model.ScaUserMessage) error
First() (*model.ScaUserMessage, error)
Take() (*model.ScaUserMessage, error)
Last() (*model.ScaUserMessage, error)
Find() ([]*model.ScaUserMessage, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaUserMessage, err error)
FindInBatches(result *[]*model.ScaUserMessage, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaUserMessage) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaUserMessageDo
Assign(attrs ...field.AssignExpr) IScaUserMessageDo
Joins(fields ...field.RelationField) IScaUserMessageDo
Preload(fields ...field.RelationField) IScaUserMessageDo
FirstOrInit() (*model.ScaUserMessage, error)
FirstOrCreate() (*model.ScaUserMessage, error)
FindByPage(offset int, limit int) (result []*model.ScaUserMessage, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaUserMessageDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaUserMessageDo) Debug() IScaUserMessageDo {
return s.withDO(s.DO.Debug())
}
func (s scaUserMessageDo) WithContext(ctx context.Context) IScaUserMessageDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaUserMessageDo) ReadDB() IScaUserMessageDo {
return s.Clauses(dbresolver.Read)
}
func (s scaUserMessageDo) WriteDB() IScaUserMessageDo {
return s.Clauses(dbresolver.Write)
}
func (s scaUserMessageDo) Session(config *gorm.Session) IScaUserMessageDo {
return s.withDO(s.DO.Session(config))
}
func (s scaUserMessageDo) Clauses(conds ...clause.Expression) IScaUserMessageDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaUserMessageDo) Returning(value interface{}, columns ...string) IScaUserMessageDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaUserMessageDo) Not(conds ...gen.Condition) IScaUserMessageDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaUserMessageDo) Or(conds ...gen.Condition) IScaUserMessageDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaUserMessageDo) Select(conds ...field.Expr) IScaUserMessageDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaUserMessageDo) Where(conds ...gen.Condition) IScaUserMessageDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaUserMessageDo) Order(conds ...field.Expr) IScaUserMessageDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaUserMessageDo) Distinct(cols ...field.Expr) IScaUserMessageDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaUserMessageDo) Omit(cols ...field.Expr) IScaUserMessageDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaUserMessageDo) Join(table schema.Tabler, on ...field.Expr) IScaUserMessageDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaUserMessageDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaUserMessageDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaUserMessageDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaUserMessageDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaUserMessageDo) Group(cols ...field.Expr) IScaUserMessageDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaUserMessageDo) Having(conds ...gen.Condition) IScaUserMessageDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaUserMessageDo) Limit(limit int) IScaUserMessageDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaUserMessageDo) Offset(offset int) IScaUserMessageDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaUserMessageDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaUserMessageDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaUserMessageDo) Unscoped() IScaUserMessageDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaUserMessageDo) Create(values ...*model.ScaUserMessage) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaUserMessageDo) CreateInBatches(values []*model.ScaUserMessage, batchSize int) error {
return s.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 (s scaUserMessageDo) Save(values ...*model.ScaUserMessage) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaUserMessageDo) First() (*model.ScaUserMessage, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserMessage), nil
}
}
func (s scaUserMessageDo) Take() (*model.ScaUserMessage, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserMessage), nil
}
}
func (s scaUserMessageDo) Last() (*model.ScaUserMessage, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserMessage), nil
}
}
func (s scaUserMessageDo) Find() ([]*model.ScaUserMessage, error) {
result, err := s.DO.Find()
return result.([]*model.ScaUserMessage), err
}
func (s scaUserMessageDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaUserMessage, err error) {
buf := make([]*model.ScaUserMessage, 0, batchSize)
err = s.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 (s scaUserMessageDo) FindInBatches(result *[]*model.ScaUserMessage, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaUserMessageDo) Attrs(attrs ...field.AssignExpr) IScaUserMessageDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaUserMessageDo) Assign(attrs ...field.AssignExpr) IScaUserMessageDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaUserMessageDo) Joins(fields ...field.RelationField) IScaUserMessageDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaUserMessageDo) Preload(fields ...field.RelationField) IScaUserMessageDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaUserMessageDo) FirstOrInit() (*model.ScaUserMessage, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserMessage), nil
}
}
func (s scaUserMessageDo) FirstOrCreate() (*model.ScaUserMessage, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaUserMessage), nil
}
}
func (s scaUserMessageDo) FindByPage(offset int, limit int) (result []*model.ScaUserMessage, count int64, err error) {
result, err = s.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 = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaUserMessageDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaUserMessageDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaUserMessageDo) Delete(models ...*model.ScaUserMessage) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaUserMessageDo) withDO(do gen.Dao) *scaUserMessageDo {
s.DO = *do.(*gen.DO)
return s
}