mirrors/nginx-ui
1
0
Fork 0
mirror of https://github.com/0xJacky/nginx-ui.git synced 2025-05-11 02:15:48 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

chore: rm unused functions in model.go

Browse source
This commit is contained in:
0xJacky 2023-12-20 10:15:39 +08:00
parent 38c9727e15
commit 18f2b4aba8
No known key found for this signature in database
GPG key ID: B6E4A6E4A561BAF0
1 changed files with 66 additions and 270 deletions
Download patch file Download diff file Expand all files Collapse all files

336
model/model.go
View file

@ -1,307 +1,103 @@
package model package model
import ( import (
"fmt" "fmt"
"github.com/0xJacky/Nginx-UI/internal/logger" "github.com/0xJacky/Nginx-UI/internal/logger"
"github.com/0xJacky/Nginx-UI/settings" "github.com/0xJacky/Nginx-UI/settings"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/spf13/cast" "gorm.io/driver/sqlite"
"gorm.io/driver/sqlite" "gorm.io/gen"
"gorm.io/gen" "gorm.io/gorm"
"gorm.io/gorm" gormlogger "gorm.io/gorm/logger"
gormlogger "gorm.io/gorm/logger" "path"
"gorm.io/gorm/schema" "time"
"path"
"strings"
"sync"
"time"
) )
var db *gorm.DB var db *gorm.DB
type Model struct { type Model struct {
ID int `gorm:"primary_key" json:"id"` ID int `gorm:"primary_key" json:"id"`
CreatedAt time.Time `json:"created_at"` CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"` UpdatedAt time.Time `json:"updated_at"`
DeletedAt *gorm.DeletedAt `gorm:"index" json:"deleted_at"` DeletedAt *gorm.DeletedAt `gorm:"index" json:"deleted_at"`
} }
func GenerateAllModel() []any { func GenerateAllModel() []any {
return []any{ return []any{
ConfigBackup{}, ConfigBackup{},
Auth{}, Auth{},
AuthToken{}, AuthToken{},
Cert{}, Cert{},
ChatGPTLog{}, ChatGPTLog{},
Site{}, Site{},
Stream{}, Stream{},
DnsCredential{}, DnsCredential{},
Environment{}, Environment{},
Notification{}, Notification{},
} }
} }
func logMode() gormlogger.Interface { func logMode() gormlogger.Interface {
switch settings.ServerSettings.RunMode { switch settings.ServerSettings.RunMode {
case gin.ReleaseMode: case gin.ReleaseMode:
return gormlogger.Default.LogMode(gormlogger.Warn) return gormlogger.Default.LogMode(gormlogger.Warn)
default: default:
fallthrough fallthrough
case gin.DebugMode: case gin.DebugMode:
return gormlogger.Default.LogMode(gormlogger.Info) return gormlogger.Default.LogMode(gormlogger.Info)
} }
} }
func UseDB() *gorm.DB { func UseDB() *gorm.DB {
return db return db
} }
func Init() *gorm.DB { func Init() *gorm.DB {
dbPath := path.Join(path.Dir(settings.ConfPath), fmt.Sprintf("%s.db", settings.ServerSettings.Database)) dbPath := path.Join(path.Dir(settings.ConfPath), fmt.Sprintf("%s.db", settings.ServerSettings.Database))
var err error var err error
db, err = gorm.Open(sqlite.Open(dbPath), &gorm.Config{ db, err = gorm.Open(sqlite.Open(dbPath), &gorm.Config{
Logger: logMode(), Logger: logMode(),
PrepareStmt: true, PrepareStmt: true,
DisableForeignKeyConstraintWhenMigrating: true, DisableForeignKeyConstraintWhenMigrating: true,
}) })
if err != nil { if err != nil {
logger.Fatal(err.Error()) logger.Fatal(err.Error())
} }
// Migrate the schema // Migrate the schema
err = db.AutoMigrate(GenerateAllModel()...) err = db.AutoMigrate(GenerateAllModel()...)
if err != nil { if err != nil {
logger.Fatal(err.Error()) logger.Fatal(err.Error())
} }
return db return db
} }
type Pagination struct { type Pagination struct {
Total int64 `json:"total"` Total int64 `json:"total"`
PerPage int `json:"per_page"` PerPage int `json:"per_page"`
CurrentPage int `json:"current_page"` CurrentPage int `json:"current_page"`
TotalPages int64 `json:"total_pages"` TotalPages int64 `json:"total_pages"`
} }
type DataList struct { type DataList struct {
Data interface{} `json:"data"` Data interface{} `json:"data"`
Pagination Pagination `json:"pagination,omitempty"` Pagination Pagination `json:"pagination,omitempty"`
}
func SortOrder(c *gin.Context) func(db *gorm.DB) *gorm.DB {
return func(db *gorm.DB) *gorm.DB {
sort := c.DefaultQuery("order", "desc")
order := fmt.Sprintf("`%s` %s", DefaultQuery(c, "sort_by", "id"), sort)
return db.Order(order)
}
}
func OrderAndPaginate(c *gin.Context) func(db *gorm.DB) *gorm.DB {
return func(db *gorm.DB) *gorm.DB {
sort := c.DefaultQuery("order", "desc")
if sort != "desc" && sort != "asc" {
sort = "desc"
}
// check if the order field is valid
order := c.DefaultQuery("sort_by", "id")
s, _ := schema.Parse(db.Model, &sync.Map{}, schema.NamingStrategy{})
if _, ok := s.FieldsByName[order]; ok {
order = fmt.Sprintf("%s %s", order, sort)
db = db.Order(order)
} else {
logger.Error("invalid order field: ", order)
}
page := cast.ToInt(c.Query("page"))
if page == 0 {
page = 1
}
pageSize := settings.ServerSettings.PageSize
reqPageSize := c.Query("page_size")
if reqPageSize != "" {
pageSize = cast.ToInt(reqPageSize)
}
offset := (page - 1) * pageSize
return db.Offset(offset).Limit(pageSize)
}
}
func QueryToInSearch(c *gin.Context, db *gorm.DB, keys ...string) *gorm.DB {
for _, v := range keys {
queryArray := c.QueryArray(v + "[]")
if len(queryArray) == 0 {
queryArray = c.QueryArray(v)
}
if len(queryArray) > 0 {
var sb strings.Builder
_, err := fmt.Fprintf(&sb, "`%s` IN ?", v)
if err != nil {
logger.Error(err)
continue
}
db = db.Where(sb.String(), queryArray)
}
}
return db
}
func QueryToEqualSearch(c *gin.Context, db *gorm.DB, keys ...string) *gorm.DB {
for _, v := range keys {
if c.Query(v) != "" {
var sb strings.Builder
_, err := fmt.Fprintf(&sb, "`%s` = ?", v)
if err != nil {
logger.Error(err)
continue
}
db = db.Where(sb.String(), c.Query(v))
}
}
return db
}
func QueryToFussySearch(c *gin.Context, db *gorm.DB, keys ...string) *gorm.DB {
for _, v := range keys {
if c.Query(v) != "" {
var sb strings.Builder
_, err := fmt.Fprintf(&sb, "`%s` LIKE ?", v)
if err != nil {
logger.Error(err)
continue
}
var sbValue strings.Builder
_, err = fmt.Fprintf(&sbValue, "%%%s%%", c.Query(v))
if err != nil {
logger.Error(err)
continue
}
db = db.Where(sb.String(), sbValue.String())
}
}
return db
}
func QueryToFussyKeysSearch(c *gin.Context, db *gorm.DB, value string, keys ...string) *gorm.DB {
if c.Query(value) == "" {
return db
}
var condition *gorm.DB
for i, v := range keys {
sb := v + " LIKE ?"
sv := "%" + c.Query(value) + "%"
switch i {
case 0:
condition = db.Where(db.Where(sb, sv))
default:
condition = condition.Or(sb, sv)
}
}
return db.Where(condition)
}
func QueryToOrInSearch(c *gin.Context, db *gorm.DB, keys ...string) *gorm.DB {
for _, v := range keys {
queryArray := c.QueryArray(v + "[]")
if len(queryArray) == 0 {
queryArray = c.QueryArray(v)
}
if len(queryArray) > 0 {
var sb strings.Builder
_, err := fmt.Fprintf(&sb, "`%s` IN ?", v)
if err != nil {
logger.Error(err)
continue
}
db = db.Or(sb.String(), queryArray)
}
}
return db
}
func QueryToOrEqualSearch(c *gin.Context, db *gorm.DB, keys ...string) *gorm.DB {
for _, v := range keys {
if c.Query(v) != "" {
var sb strings.Builder
_, err := fmt.Fprintf(&sb, "`%s` = ?", v)
if err != nil {
logger.Error(err)
continue
}
db = db.Or(sb.String(), c.Query(v))
}
}
return db
}
func QueryToOrFussySearch(c *gin.Context, db *gorm.DB, keys ...string) *gorm.DB {
for _, v := range keys {
if c.Query(v) != "" {
var sb strings.Builder
_, err := fmt.Fprintf(&sb, "`%s` LIKE ?", v)
if err != nil {
logger.Error(err)
continue
}
var sbValue strings.Builder
_, err = fmt.Fprintf(&sbValue, "%%%s%%", c.Query(v))
if err != nil {
logger.Error(err)
continue
}
db = db.Or(sb.String(), sbValue.String())
}
}
return db
} }
func TotalPage(total int64, pageSize int) int64 { func TotalPage(total int64, pageSize int) int64 {
n := total / int64(pageSize) n := total / int64(pageSize)
if total%int64(pageSize) > 0 { if total%int64(pageSize) > 0 {
n++ n++
} }
return n return n
}
func DefaultValue(c *gin.Context, key string, defaultValue any) any {
if value, ok := c.Get(key); ok {
return value
}
return defaultValue
}
func DefaultQuery(c *gin.Context, key string, defaultValue any) string {
return c.DefaultQuery(key, DefaultValue(c, key, defaultValue).(string))
} }
type Method interface { type Method interface {
// FirstByID Where("id=@id") // FirstByID Where("id=@id")
FirstByID(id int) (*gen.T, error) FirstByID(id int) (*gen.T, error)
// DeleteByID update @@table set deleted_at=strftime('%Y-%m-%d %H:%M:%S','now') where id=@id // DeleteByID update @@table set deleted_at=strftime('%Y-%m-%d %H:%M:%S','now') where id=@id
DeleteByID(id int) error DeleteByID(id int) error
} }