ThatGuyJack/nginx-proxy-manager
1
0
Fork 0
mirror of https://github.com/NginxProxyManager/nginx-proxy-manager.git synced 2025-06-18 18:16:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Convert db backend to use Gorm, with basis for support

Browse Source 
for Mysql and Postgres in addition to existing Sqlite
This commit is contained in:
Jamie Curnow
2023-05-26 11:04:43 +10:00
parent b4e5b8b6db
commit 29990110b1
93 changed files with 1215 additions and 3075 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
backend/internal/entity/user/filters.go
View File

@ -1,25 +0,0 @@
package user
import (
"npm/internal/entity"
)
var filterMapFunctions = make(map[string]entity.FilterMapFunction)
// getFilterMapFunctions is a map of functions that should be executed
// during the filtering process, if a field is defined here then the value in
// the filter will be given to the defined function and it will return a new
// value for use in the sql query.
func getFilterMapFunctions() map[string]entity.FilterMapFunction {
// if len(filterMapFunctions) == 0 {
// TODO: See internal/model/file_item.go:620 for an example
// }
return filterMapFunctions
}
// GetFilterSchema returns filter schema
func GetFilterSchema() string {
var m Model
return entity.GetFilterSchema(m)
}

180
backend/internal/entity/user/methods.go
View File

@ -1,20 +1,14 @@
package user
import (
"database/sql"
"fmt"
"npm/internal/database"
"npm/internal/entity"
"npm/internal/errors"
"npm/internal/logger"
"npm/internal/model"
"github.com/rotisserie/eris"
)
// GetByID finds a user by ID
func GetByID(id int) (Model, error) {
func GetByID(id uint) (Model, error) {
var m Model
err := m.LoadByID(id)
return m, err
@ -27,140 +21,38 @@ func GetByEmail(email string) (Model, error) {
return m, err
}
// Create will create a User from given model
func Create(user *Model) (int, error) {
// We need to ensure that a user can't be created with the same email
// as an existing non-deleted user. Usually you would do this with the
// database schema, but it's a bit more complex because of the is_deleted field.
if user.ID != 0 {
return 0, eris.New("Cannot create user when model already has an ID")
}
// Check if an existing user with this email exists
_, err := GetByEmail(user.Email)
if err == nil {
return 0, errors.ErrDuplicateEmailUser
}
user.Touch(true)
db := database.GetInstance()
// nolint: gosec
result, err := db.NamedExec(`INSERT INTO `+fmt.Sprintf("`%s`", tableName)+` (
created_on,
modified_on,
name,
nickname,
email,
is_disabled
) VALUES (
:created_on,
:modified_on,
:name,
:nickname,
:email,
:is_disabled
)`, user)
if err != nil {
return 0, err
}
last, lastErr := result.LastInsertId()
if lastErr != nil {
return 0, lastErr
}
return int(last), nil
}
// Update will Update a User from this model
func Update(user *Model) error {
if user.ID == 0 {
return eris.New("Cannot update user when model doesn't have an ID")
}
// Check that the email address isn't associated with another user
if existingUser, _ := GetByEmail(user.Email); existingUser.ID != 0 && existingUser.ID != user.ID {
return errors.ErrDuplicateEmailUser
}
user.Touch(false)
db := database.GetInstance()
// nolint: gosec
_, err := db.NamedExec(`UPDATE `+fmt.Sprintf("`%s`", tableName)+` SET
created_on = :created_on,
modified_on = :modified_on,
name = :name,
nickname = :nickname,
email = :email,
is_disabled = :is_disabled,
is_deleted = :is_deleted
WHERE id = :id`, user)
return err
}
// IsEnabled is used by middleware to ensure the user is still enabled
// returns (userExist, isEnabled)
func IsEnabled(userID int) (bool, bool) {
// nolint: gosec
query := `SELECT is_disabled FROM ` + fmt.Sprintf("`%s`", tableName) + ` WHERE id = ? AND is_deleted = ?`
disabled := true
db := database.GetInstance()
err := db.QueryRowx(query, userID, 0).Scan(&disabled)
if err == sql.ErrNoRows {
func IsEnabled(userID uint) (bool, bool) {
var user Model
db := database.GetDB()
if result := db.First(&user, userID); result.Error != nil {
return false, false
} else if err != nil {
logger.Error("QueryError", err)
}
return true, !disabled
return true, !user.IsDisabled
}
// List will return a list of users
func List(pageInfo model.PageInfo, filters []model.Filter, expand []string) (ListResponse, error) {
var result ListResponse
var exampleModel Model
func List(pageInfo model.PageInfo, filters []model.Filter, expand []string) (entity.ListResponse, error) {
var result entity.ListResponse
defaultSort := model.Sort{
Field: "name",
Direction: "ASC",
}
db := database.GetInstance()
if db == nil {
return result, errors.ErrDatabaseUnavailable
}
/*
filters = append(filters, model.Filter{
Field: "is_system",
Modifier: "equals",
Value: []string{"0"},
})
*/
dbo := entity.ListQueryBuilder(&pageInfo, defaultSort, filters)
// Get count of items in this search
query, params := entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), true)
countRow := db.QueryRowx(query, params...)
var totalRows int
queryErr := countRow.Scan(&totalRows)
if queryErr != nil && queryErr != sql.ErrNoRows {
logger.Debug("Query: %s -- %+v", query, params)
return result, queryErr
var totalRows int64
if res := dbo.Model(&Model{}).Count(&totalRows); res.Error != nil {
return result, res.Error
}
// Get rows
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {
logger.Debug("Query: %s -- %+v", query, params)
return result, err
if res := dbo.Find(&items); res.Error != nil {
return result, res.Error
}
for idx := range items {
@ -176,7 +68,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter, expand []string) (Lis
}
}
result = ListResponse{
result = entity.ListResponse{
Items: items,
Total: totalRows,
Limit: pageInfo.Limit,
@ -190,41 +82,21 @@ func List(pageInfo model.PageInfo, filters []model.Filter, expand []string) (Lis
// DeleteAll will do just that, and should only be used for testing purposes.
func DeleteAll() error {
db := database.GetInstance()
_, err := db.Exec(fmt.Sprintf("DELETE FROM `%s`", tableName))
return err
db := database.GetDB()
result := db.Exec("DELETE FROM users")
return result.Error
}
// GetCapabilities gets capabilities for a user
func GetCapabilities(userID int) ([]string, error) {
var capabilities []string
db := database.GetInstance()
if db == nil {
return []string{}, errors.ErrDatabaseUnavailable
func GetCapabilities(userID uint) ([]string, error) {
capabilities := make([]string, 0)
var hasCapabilities []UserHasCapabilityModel
db := database.GetDB()
if result := db.Where("user_id = ?", userID).Find(&hasCapabilities); result.Error != nil {
return nil, result.Error
}
query := `SELECT c.name FROM "user_has_capability" h
INNER JOIN "capability" c ON c.id = h.capability_id
WHERE h.user_id = ?`
rows, err := db.Query(query, userID)
if err != nil && err != sql.ErrNoRows {
logger.Debug("QUERY: %v -- %v", query, userID)
return []string{}, err
for _, obj := range hasCapabilities {
capabilities = append(capabilities, obj.CapabilityName)
}
// nolint: errcheck
defer rows.Close()
for rows.Next() {
var name string
err := rows.Scan(&name)
if err != nil {
return []string{}, err
}
capabilities = append(capabilities, name)
}
return capabilities, nil
}

131
backend/internal/entity/user/model.go
View File

@ -1,62 +1,67 @@
package user
import (
"fmt"
"strings"
"time"
"npm/internal/database"
"npm/internal/entity"
"npm/internal/entity/auth"
"npm/internal/errors"
"npm/internal/logger"
"npm/internal/types"
"npm/internal/util"
"github.com/drexedam/gravatar"
"github.com/rotisserie/eris"
)
const (
tableName = "user"
)
// Model is the user model
// Model is the model
type Model struct {
ID int `json:"id" db:"id" filter:"id,integer"`
Name string `json:"name" db:"name" filter:"name,string"`
Nickname string `json:"nickname" db:"nickname" filter:"nickname,string"`
Email string `json:"email" db:"email" filter:"email,email"`
CreatedOn types.DBDate `json:"created_on" db:"created_on" filter:"created_on,integer"`
ModifiedOn types.DBDate `json:"modified_on" db:"modified_on" filter:"modified_on,integer"`
GravatarURL string `json:"gravatar_url"`
IsDisabled bool `json:"is_disabled" db:"is_disabled" filter:"is_disabled,boolean"`
IsSystem bool `json:"is_system,omitempty" db:"is_system"`
IsDeleted bool `json:"is_deleted,omitempty" db:"is_deleted"`
entity.ModelBase
Name string `json:"name" gorm:"column:name" filter:"name,string"`
Nickname string `json:"nickname" gorm:"column:nickname" filter:"nickname,string"`
Email string `json:"email" gorm:"column:email" filter:"email,email"`
IsDisabled bool `json:"is_disabled" gorm:"column:is_disabled" filter:"is_disabled,boolean"`
IsSystem bool `json:"is_system,omitempty" gorm:"column:is_system"`
// Other
GravatarURL string `json:"gravatar_url" gorm:"-"`
// Expansions
Auth *auth.Model `json:"auth,omitempty" db:"-"`
Capabilities []string `json:"capabilities,omitempty"`
Auth *auth.Model `json:"auth,omitempty" gorm:"-"`
Capabilities []string `json:"capabilities,omitempty" gorm:"-"`
}
func (m *Model) getByQuery(query string, params []interface{}) error {
err := database.GetByQuery(m, query, params)
m.generateGravatar()
return err
// TableName overrides the table name used by gorm
func (Model) TableName() string {
return "user"
}
// UserHasCapabilityModel is the model
type UserHasCapabilityModel struct {
UserID uint `json:"user_id" gorm:"column:user_id"`
CapabilityName string `json:"name" gorm:"column:capability_name"`
}
// TableName overrides the table name used by gorm
func (UserHasCapabilityModel) TableName() string {
return "user_has_capability"
}
// LoadByID will load from an ID
func (m *Model) LoadByID(id int) error {
query := fmt.Sprintf("SELECT * FROM `%s` WHERE id = ? AND is_deleted = ? LIMIT 1", tableName)
params := []interface{}{id, false}
return m.getByQuery(query, params)
func (m *Model) LoadByID(id uint) error {
db := database.GetDB()
result := db.First(&m, id)
return result.Error
}
// LoadByEmail will load from an Email
func (m *Model) LoadByEmail(email string) error {
query := fmt.Sprintf("SELECT * FROM `%s` WHERE email = ? AND is_deleted = ? AND is_system = ? LIMIT 1", tableName)
params := []interface{}{strings.TrimSpace(strings.ToLower(email)), false, false}
return m.getByQuery(query, params)
db := database.GetDB()
result := db.
Where("email = ?", strings.TrimSpace(strings.ToLower(email))).
Where("is_system = ?", false).
First(&m)
return result.Error
}
/*
// Touch will update model's timestamp(s)
func (m *Model) Touch(created bool) {
var d types.DBDate
@ -67,34 +72,31 @@ func (m *Model) Touch(created bool) {
m.ModifiedOn = d
m.generateGravatar()
}
*/
// Save will save this model to the DB
func (m *Model) Save() error {
var err error
// Ensure email is nice
m.Email = strings.TrimSpace(strings.ToLower(m.Email))
if m.IsSystem {
return errors.ErrSystemUserReadonly
}
if m.ID == 0 {
m.ID, err = Create(m)
} else {
err = Update(m)
}
return err
db := database.GetDB()
// todo: touch? not sure that save does this or not?
result := db.Save(m)
return result.Error
}
// Delete will mark a user as deleted
func (m *Model) Delete() bool {
m.Touch(false)
m.IsDeleted = true
if err := m.Save(); err != nil {
if m.ID == 0 {
// Can't delete a new object
return false
}
return true
db := database.GetDB()
result := db.Delete(m)
return result.Error == nil
}
// SetPermissions will wipe out any existing permissions and add new ones for this user
@ -103,30 +105,20 @@ func (m *Model) SetPermissions(permissions []string) error {
return eris.Errorf("Cannot set permissions without first saving the User")
}
db := database.GetInstance()
db := database.GetDB()
// Wipe out previous permissions
query := `DELETE FROM "user_has_capability" WHERE "user_id" = ?`
if _, err := db.Exec(query, m.ID); err != nil {
logger.Debug("QUERY: %v -- %v", query, m.ID)
return err
if result := db.Where("user_id = ?", m.ID).Delete(&UserHasCapabilityModel{}); result.Error != nil {
return result.Error
}
if len(permissions) > 0 {
// Add new permissions
objs := []*UserHasCapabilityModel{}
for _, permission := range permissions {
query = `INSERT INTO "user_has_capability" (
"user_id", "capability_id"
) VALUES (
?,
(SELECT id FROM capability WHERE name = ?)
)`
_, err := db.Exec(query, m.ID, permission)
if err != nil {
logger.Debug("QUERY: %v -- %v -- %v", query, m.ID, permission)
return err
}
objs = append(objs, &UserHasCapabilityModel{UserID: m.ID, CapabilityName: permission})
}
if result := db.Create(objs); result.Error != nil {
return result.Error
}
}
@ -164,21 +156,18 @@ func (m *Model) SaveCapabilities() error {
return eris.New("At least 1 capability required for a user")
}
db := database.GetInstance()
db := database.GetDB()
// Get a full list of capabilities
var capabilities []string
query := `SELECT "name" from "capability"`
err := db.Select(&capabilities, query)
if err != nil {
return err
var capabilities []entity.Capability
if result := db.Find(&capabilities); result.Error != nil {
return result.Error
}
// Check that the capabilities defined exist in the db
for _, cap := range m.Capabilities {
found := false
for _, a := range capabilities {
if a == cap {
if a.Name == cap {
found = true
}
}

15
backend/internal/entity/user/structs.go
View File

@ -1,15 +0,0 @@
package user
import (
"npm/internal/model"
)
// ListResponse is the JSON response for users list
type ListResponse struct {
Total int `json:"total"`
Offset int `json:"offset"`
Limit int `json:"limit"`
Sort []model.Sort `json:"sort"`
Filter []model.Filter `json:"filter,omitempty"`
Items []Model `json:"items,omitempty"`
}