343 lines
9.1 KiB
Go
343 lines
9.1 KiB
Go
package model
|
||
|
||
import (
|
||
"errors"
|
||
c "git.inspur.com/sbg-jszt/cfn/cfn-schedule/config"
|
||
"git.inspur.com/sbg-jszt/cfn/cfn-schedule/data"
|
||
"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/pkg/request"
|
||
"github.com/google/uuid"
|
||
"gorm.io/gorm"
|
||
"gorm.io/gorm/schema"
|
||
"gorm.io/plugin/soft_delete"
|
||
"strings"
|
||
"time"
|
||
)
|
||
|
||
type BaseIdModel struct {
|
||
Handler ResultHandler `gorm:"-" json:"-"`
|
||
Id string `gorm:"column:id;not null;primarykey" json:"id"`
|
||
}
|
||
|
||
type ResultHandler interface {
|
||
FindResult(*gorm.DB) (interface{}, error)
|
||
}
|
||
|
||
func (b *BaseIdModel) Create(t schema.Tabler) (int64, error) {
|
||
b.GenerateId()
|
||
tx := DB().Table(t.TableName()).Create(t)
|
||
if tx.Error != nil {
|
||
return 0, tx.Error
|
||
}
|
||
return tx.RowsAffected, nil
|
||
}
|
||
|
||
func (b *BaseIdModel) Update(t schema.Tabler, column []string) (int64, error) {
|
||
if b.Id == "" {
|
||
return 0, errors.New("id cannot be null")
|
||
}
|
||
db := DB().Table(t.TableName())
|
||
if column != nil && len(column) > 0 {
|
||
db = db.Select(column)
|
||
}
|
||
tx := db.Updates(t)
|
||
return tx.RowsAffected, tx.Error
|
||
}
|
||
|
||
func (b *BaseIdModel) GetById(t schema.Tabler) error {
|
||
if b.Id == "" {
|
||
return errors.New("id cannot be null")
|
||
}
|
||
tx := DB().Table(t.TableName()).Take(t)
|
||
return tx.Error
|
||
}
|
||
|
||
func (b *BaseIdModel) Delete(t schema.Tabler) (int64, error) {
|
||
if b.Id == "" {
|
||
return 0, errors.New("id cannot be null")
|
||
}
|
||
tx := DB().Table(t.TableName()).Delete(t)
|
||
return tx.RowsAffected, tx.Error
|
||
}
|
||
|
||
func (b *BaseIdModel) GetAll(t schema.Tabler, fields map[string]interface{}, notFields map[string]interface{}) (interface{}, error) {
|
||
query := DB().Table(t.TableName())
|
||
if fields != nil {
|
||
for key := range fields {
|
||
value := fields[key]
|
||
switch value.(type) {
|
||
case []string, []int, []int64, []interface{}:
|
||
query = query.Where(key+" in (?)", value)
|
||
default:
|
||
query = query.Where(key+" = ?", value)
|
||
}
|
||
}
|
||
}
|
||
if notFields != nil {
|
||
for key := range notFields {
|
||
value := notFields[key]
|
||
if items, ok := value.([]interface{}); ok {
|
||
if len(items) > 0 {
|
||
query = query.Where(key+" not in (?)", items)
|
||
} else {
|
||
query = query.Where(key+" <> ?", items[0])
|
||
}
|
||
} else {
|
||
query = query.Where(key+" <> ?", value)
|
||
}
|
||
}
|
||
//query = query.Where(fields)
|
||
}
|
||
return b.Handler.FindResult(query)
|
||
}
|
||
|
||
// IN db.Where("name in (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)
|
||
func (b *BaseIdModel) Page(t schema.Tabler, page *PageConfig, fields map[string]interface{}) (interface{}, error) {
|
||
query := DB()
|
||
if fields != nil {
|
||
//query = query.Where(fields)
|
||
for key := range fields {
|
||
value := fields[key]
|
||
switch value.(type) {
|
||
case []string, []int, []int64, []interface{}:
|
||
query = query.Where(key+" in (?)", value)
|
||
default:
|
||
query = query.Where(key+" = ?", value)
|
||
}
|
||
}
|
||
}
|
||
return b.Handler.FindResult(page.SelectPages(t, query))
|
||
}
|
||
|
||
func (b *BaseIdModel) GenerateId() {
|
||
if b.Id == "" {
|
||
id, _ := uuid.NewUUID()
|
||
b.Id = strings.ReplaceAll(id.String(), "-", "")
|
||
}
|
||
}
|
||
|
||
type BaseDbModel struct {
|
||
BaseIdModel
|
||
CreateTimeMillis int64 `gorm:"column:create_time_millis" json:"createTimeMillis"` //type:timestamptz comment:数据创建时间 version:2024-02-12 14:22
|
||
ModifyTimeMillis int64 `gorm:"column:modify_time_millis" json:"modifyTimeMillis"` //type:timestamptz comment:数据修改时间 version:2024-02-12 14:22
|
||
}
|
||
|
||
func (b *BaseDbModel) Create(t schema.Tabler) (int64, error) {
|
||
b.GenerateTime()
|
||
return b.BaseIdModel.Create(t)
|
||
}
|
||
|
||
func (b *BaseDbModel) Update(t schema.Tabler, column []string) (int64, error) {
|
||
b.GenerateModifyTime()
|
||
return b.BaseIdModel.Update(t, column)
|
||
}
|
||
|
||
func (b *BaseDbModel) GenerateTime() {
|
||
t := time.Now().UnixMilli()
|
||
b.CreateTimeMillis = t
|
||
b.ModifyTimeMillis = t
|
||
}
|
||
|
||
func (b *BaseDbModel) GenerateModifyTime() {
|
||
b.ModifyTimeMillis = time.Now().UnixMilli()
|
||
}
|
||
|
||
type BaseUserModifyDbModel struct {
|
||
BaseDbModel
|
||
CreateUser string `gorm:"column:create_user" json:"createUser"`
|
||
ModifyUser string `gorm:"column:modify_user" json:"modifyUser"`
|
||
}
|
||
|
||
func (b *BaseUserModifyDbModel) SetUserName(userName string) {
|
||
b.CreateUser = userName
|
||
b.ModifyUser = userName
|
||
}
|
||
|
||
func (b *BaseUserModifyDbModel) SetModifyUserName(userName string) {
|
||
b.ModifyUser = userName
|
||
}
|
||
|
||
type BaseWorkspaceModel struct {
|
||
BaseUserModifyDbModel
|
||
WorkspaceId string `gorm:"column:workspace_id" json:"workspaceId"`
|
||
}
|
||
|
||
func (b *BaseWorkspaceModel) CountByWorkspaceId(t schema.Tabler) (int64, error) {
|
||
if b.WorkspaceId == "" {
|
||
return 0, errors.New("id cannot be null")
|
||
}
|
||
var count int64
|
||
tx := DB().Table(t.TableName()).Where("workspace_id = ?", b.WorkspaceId).Count(&count)
|
||
return count, tx.Error
|
||
}
|
||
|
||
func (b *BaseWorkspaceModel) Global() bool {
|
||
return strings.EqualFold(b.WorkspaceId, "GLOBAL")
|
||
}
|
||
|
||
type BaseNodeModel struct {
|
||
BaseWorkspaceModel
|
||
NodeId string `gorm:"column:node_id" json:"nodeId"`
|
||
NodeName string `gorm:"column:node_name" json:"nodeName"`
|
||
WorkspaceName string `gorm:"column:workspace_name" json:"workspaceName"`
|
||
}
|
||
|
||
type BaseGroupModel struct {
|
||
BaseWorkspaceModel
|
||
Group string `gorm:"column:group" json:"group"`
|
||
}
|
||
|
||
type BaseMachineModel struct {
|
||
BaseGroupModel
|
||
MachineId string `gorm:"column:machine_id" json:"machineId"`
|
||
}
|
||
|
||
type BaseModel struct {
|
||
ID string `gorm:"column:id;not null;primarykey" json:"id"`
|
||
CreateTime time.Time `gorm:"column:create_time;type:timestamp;<-:create" json:"createTime"`
|
||
UpdateTime time.Time `gorm:"column:update_time;type:timestamp" json:"updateTime"`
|
||
CreatorID string `gorm:"column:creator_id;type:varchar(64);not null;<-:create" json:"creatorID"`
|
||
Modifier string `gorm:"column:modifier;type:varchar(64);not null;" json:"modifier"`
|
||
}
|
||
|
||
func (model *BaseModel) DB() *gorm.DB {
|
||
return DB()
|
||
}
|
||
|
||
type ContainsDeleteBaseModel struct {
|
||
BaseModel
|
||
DeletedAt soft_delete.DeletedAt `gorm:"column:deleted_at;type:int(11) unsigned;not null;default:0;index" json:"-"`
|
||
}
|
||
|
||
func DB() *gorm.DB {
|
||
if c.Config.DatabaseConfig.Type == "sqlite" {
|
||
return data.SqliteDB
|
||
} else {
|
||
return data.PostgreSqlDB["data"]
|
||
}
|
||
}
|
||
|
||
//func DBAuth() *gorm.DB {
|
||
// return data.PostgreSqlDB["auth"]
|
||
//}
|
||
|
||
type Page[T any] struct {
|
||
CurrentPage int64 `json:"currentPage"`
|
||
PageSize int64 `json:"pageSize"`
|
||
Total int64 `json:"total"`
|
||
Pages int64 `json:"pages"`
|
||
Order string `json:"order"` //db.Order("name DESC")
|
||
Data []T `json:"data"`
|
||
}
|
||
|
||
func (page *Page[T]) SelectPages(query *gorm.DB) (e error) {
|
||
var model T
|
||
query.Model(&model).Count(&page.Total)
|
||
if page.Total == 0 {
|
||
page.Data = []T{}
|
||
return
|
||
}
|
||
e = query.Model(&model).Scopes(Paginate(page)).Find(&page.Data).Error
|
||
return
|
||
}
|
||
|
||
func (page *Page[T]) ScanPages(query *gorm.DB) (e error) {
|
||
var model T
|
||
query.Model(&model).Count(&page.Total)
|
||
if page.Total == 0 {
|
||
page.Data = []T{}
|
||
return
|
||
}
|
||
e = query.Model(&model).Scopes(Paginate(page)).Scan(&page.Data).Error
|
||
return
|
||
}
|
||
|
||
func Paginate[T any](page *Page[T]) func(db *gorm.DB) *gorm.DB {
|
||
return func(db *gorm.DB) *gorm.DB {
|
||
if page.CurrentPage <= 0 {
|
||
page.CurrentPage = 1
|
||
}
|
||
switch {
|
||
case page.PageSize > 1000:
|
||
page.PageSize = 1000 // 限制一下分页大小
|
||
case page.PageSize <= 0:
|
||
page.PageSize = 10
|
||
}
|
||
page.Pages = page.Total / page.PageSize
|
||
if page.Total%page.PageSize != 0 {
|
||
page.Pages++
|
||
}
|
||
size := page.PageSize
|
||
offset := int((page.CurrentPage - 1) * size)
|
||
return db.Order(page.Order).Offset(offset).Limit(int(size))
|
||
}
|
||
}
|
||
|
||
func (page *Page[T]) Covert(pageInfo *request.PageInfo) {
|
||
if pageInfo.CurrentPage <= 0 {
|
||
pageInfo.CurrentPage = 1
|
||
}
|
||
switch {
|
||
case pageInfo.PageSize > 1000:
|
||
pageInfo.PageSize = 1000 // 限制一下分页大小
|
||
case pageInfo.PageSize <= 0:
|
||
pageInfo.PageSize = 10
|
||
}
|
||
page.CurrentPage = pageInfo.CurrentPage
|
||
page.PageSize = pageInfo.PageSize
|
||
page.Order = pageInfo.Order
|
||
}
|
||
|
||
// PageConfig 需要配套实现FindResult，Data需要回填。推荐使用Page[T any]
|
||
type PageConfig struct {
|
||
CurrentPage int64 `json:"currentPage"`
|
||
PageSize int64 `json:"pageSize"`
|
||
Total int64 `json:"total"`
|
||
Pages int64 `json:"pages"`
|
||
Order string `json:"order"` //db.Order("name DESC")
|
||
Data any `json:"data"` // 需要回填，不好用
|
||
}
|
||
|
||
func (page *PageConfig) SelectPages(t schema.Tabler, query *gorm.DB) *gorm.DB {
|
||
query.Table(t.TableName()).Count(&page.Total)
|
||
if page.Total == 0 {
|
||
return nil
|
||
}
|
||
return query.Table(t.TableName()).Scopes(PaginateConfig(page))
|
||
}
|
||
|
||
func PaginateConfig(page *PageConfig) func(db *gorm.DB) *gorm.DB {
|
||
return func(db *gorm.DB) *gorm.DB {
|
||
if page.CurrentPage <= 0 {
|
||
page.CurrentPage = 1
|
||
}
|
||
switch {
|
||
case page.PageSize > 1000:
|
||
page.PageSize = 1000 // 限制一下分页大小
|
||
case page.PageSize <= 0:
|
||
page.PageSize = 10
|
||
}
|
||
page.Pages = page.Total / page.PageSize
|
||
if page.Total%page.PageSize != 0 {
|
||
page.Pages++
|
||
}
|
||
size := page.PageSize
|
||
offset := int((page.CurrentPage - 1) * size)
|
||
return db.Order(page.Order).Offset(offset).Limit(int(size))
|
||
}
|
||
}
|
||
|
||
func (page *PageConfig) Covert(pageInfo *request.PageInfo) {
|
||
if pageInfo.CurrentPage <= 0 {
|
||
pageInfo.CurrentPage = 1
|
||
}
|
||
switch {
|
||
case pageInfo.PageSize > 1000:
|
||
pageInfo.PageSize = 1000 // 限制一下分页大小
|
||
case pageInfo.PageSize <= 0:
|
||
pageInfo.PageSize = 10
|
||
}
|
||
page.CurrentPage = pageInfo.CurrentPage
|
||
page.PageSize = pageInfo.PageSize
|
||
page.Order = pageInfo.Order
|
||
}
|