mirror of
https://github.com/1Panel-dev/1Panel.git
synced 2026-11-20 00:01:06 +00:00
feat(postgresql): add user and database authorization management (#14460)
* feat(postgresql): add user and database authorization management * fix(postgresql): reuse existing roles during app recovery
This commit is contained in:
@@ -232,3 +232,139 @@ func (b *BaseApi) DeletePostgresql(c *gin.Context) {
|
||||
tx.Commit()
|
||||
helper.Success(c)
|
||||
}
|
||||
|
||||
func (b *BaseApi) ListPostgresqlUsers(c *gin.Context) {
|
||||
var req dto.PostgresqlUserSearch
|
||||
if err := helper.CheckBindAndValidate(&req, c); err != nil {
|
||||
return
|
||||
}
|
||||
result, err := postgresqlService.ListUsers(req)
|
||||
if err != nil {
|
||||
helper.InternalServer(c, err)
|
||||
return
|
||||
}
|
||||
helper.SuccessWithData(c, result)
|
||||
}
|
||||
|
||||
// @Router /databases/pg/users [post]
|
||||
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"formatZH":"创建 PostgreSQL 实例 [database] 用户 [username]","formatEN":"create PostgreSQL instance [database] user [username]","BeforeFunctions":[]}
|
||||
func (b *BaseApi) CreatePostgresqlUser(c *gin.Context) {
|
||||
var req dto.PostgresqlUserCreate
|
||||
if err := helper.CheckBindAndValidate(&req, c); err != nil {
|
||||
return
|
||||
}
|
||||
password, err := base64.StdEncoding.DecodeString(req.Password)
|
||||
if err != nil {
|
||||
helper.BadRequest(c, err)
|
||||
return
|
||||
}
|
||||
req.Password = string(password)
|
||||
if err := postgresqlService.CreateUser(req); err != nil {
|
||||
helper.InternalServer(c, err)
|
||||
return
|
||||
}
|
||||
helper.Success(c)
|
||||
}
|
||||
|
||||
// @Router /databases/pg/users/update [post]
|
||||
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"formatZH":"修改 PostgreSQL 实例 [database] 用户 [username]","formatEN":"update PostgreSQL instance [database] user [username]","BeforeFunctions":[]}
|
||||
func (b *BaseApi) UpdatePostgresqlUser(c *gin.Context) {
|
||||
var req dto.PostgresqlUserUpdate
|
||||
if err := helper.CheckBindAndValidate(&req, c); err != nil {
|
||||
return
|
||||
}
|
||||
if err := postgresqlService.UpdateUser(req); err != nil {
|
||||
helper.InternalServer(c, err)
|
||||
return
|
||||
}
|
||||
helper.Success(c)
|
||||
}
|
||||
|
||||
// @Router /databases/pg/users/password [post]
|
||||
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"formatZH":"修改 PostgreSQL 实例 [database] 用户 [username] 密码","formatEN":"change PostgreSQL instance [database] user [username] password","BeforeFunctions":[]}
|
||||
func (b *BaseApi) ChangePostgresqlUserPassword(c *gin.Context) {
|
||||
var req dto.PostgresqlUserPassword
|
||||
if err := helper.CheckBindAndValidate(&req, c); err != nil {
|
||||
return
|
||||
}
|
||||
password, err := base64.StdEncoding.DecodeString(req.Password)
|
||||
if err != nil {
|
||||
helper.BadRequest(c, err)
|
||||
return
|
||||
}
|
||||
req.Password = string(password)
|
||||
if err := postgresqlService.ChangeUserPassword(req); err != nil {
|
||||
helper.InternalServer(c, err)
|
||||
return
|
||||
}
|
||||
helper.Success(c)
|
||||
}
|
||||
|
||||
// @Tags Database PostgreSQL
|
||||
// @Summary Save postgresql user password locally
|
||||
// @Accept json
|
||||
// @Param request body dto.PostgresqlUserPassword true "request"
|
||||
// @Success 200
|
||||
// @Security ApiKeyAuth
|
||||
// @Security Timestamp
|
||||
// @Router /databases/pg/users/password/save [post]
|
||||
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"补充 PostgreSQL 实例 [database] 用户 [username] 密码","formatEN":"save PostgreSQL instance [database] user [username] password locally"}
|
||||
func (b *BaseApi) SavePostgresqlUserPassword(c *gin.Context) {
|
||||
var req dto.PostgresqlUserPassword
|
||||
if err := helper.CheckBindAndValidate(&req, c); err != nil {
|
||||
return
|
||||
}
|
||||
password, err := base64.StdEncoding.DecodeString(req.Password)
|
||||
if err != nil {
|
||||
helper.BadRequest(c, err)
|
||||
return
|
||||
}
|
||||
req.Password = string(password)
|
||||
if err := postgresqlService.SaveUserPassword(req); err != nil {
|
||||
helper.InternalServer(c, err)
|
||||
return
|
||||
}
|
||||
helper.Success(c)
|
||||
}
|
||||
|
||||
// @Router /databases/pg/users/del [post]
|
||||
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"formatZH":"删除 PostgreSQL 实例 [database] 用户 [username]","formatEN":"delete PostgreSQL instance [database] user [username]","BeforeFunctions":[]}
|
||||
func (b *BaseApi) DeletePostgresqlUser(c *gin.Context) {
|
||||
var req dto.PostgresqlUserDelete
|
||||
if err := helper.CheckBindAndValidate(&req, c); err != nil {
|
||||
return
|
||||
}
|
||||
if err := postgresqlService.DeleteUser(req); err != nil {
|
||||
helper.InternalServer(c, err)
|
||||
return
|
||||
}
|
||||
helper.Success(c)
|
||||
}
|
||||
|
||||
// @Router /databases/pg/grants [post]
|
||||
// @x-panel-log {"bodyKeys":["database","username","name"],"paramKeys":[],"formatZH":"绑定 PostgreSQL 实例 [database] 数据库 [name] 用户 [username]","formatEN":"bind PostgreSQL instance [database] database [name] user [username]","BeforeFunctions":[]}
|
||||
func (b *BaseApi) GrantPostgresqlUser(c *gin.Context) {
|
||||
var req dto.PostgresqlUserGrant
|
||||
if err := helper.CheckBindAndValidate(&req, c); err != nil {
|
||||
return
|
||||
}
|
||||
if err := postgresqlService.GrantUser(req); err != nil {
|
||||
helper.InternalServer(c, err)
|
||||
return
|
||||
}
|
||||
helper.Success(c)
|
||||
}
|
||||
|
||||
// @Router /databases/pg/grants/del [post]
|
||||
// @x-panel-log {"bodyKeys":["database","username","name"],"paramKeys":[],"formatZH":"撤销 PostgreSQL 实例 [database] 数据库 [name] 用户 [username] 绑定","formatEN":"revoke PostgreSQL instance [database] database [name] user [username] binding","BeforeFunctions":[]}
|
||||
func (b *BaseApi) RevokePostgresqlUser(c *gin.Context) {
|
||||
var req dto.PostgresqlUserGrant
|
||||
if err := helper.CheckBindAndValidate(&req, c); err != nil {
|
||||
return
|
||||
}
|
||||
if err := postgresqlService.RevokeUser(req); err != nil {
|
||||
helper.InternalServer(c, err)
|
||||
return
|
||||
}
|
||||
helper.Success(c)
|
||||
}
|
||||
|
||||
@@ -33,14 +33,15 @@ type PostgresqlOption struct {
|
||||
}
|
||||
|
||||
type PostgresqlDBCreate struct {
|
||||
Name string `json:"name" validate:"required"`
|
||||
From string `json:"from" validate:"required,oneof=local remote"`
|
||||
Database string `json:"database" validate:"required"`
|
||||
Format string `json:"format"`
|
||||
Username string `json:"username" validate:"required"`
|
||||
Password string `json:"password" validate:"required"`
|
||||
SuperUser bool `json:"superUser"`
|
||||
Description string `json:"description"`
|
||||
ExistingUser bool `json:"existingUser"`
|
||||
Name string `json:"name" validate:"required"`
|
||||
From string `json:"from" validate:"required,oneof=local remote"`
|
||||
Database string `json:"database" validate:"required"`
|
||||
Format string `json:"format"`
|
||||
Username string `json:"username" validate:"required"`
|
||||
Password string `json:"password"`
|
||||
SuperUser bool `json:"superUser"`
|
||||
Description string `json:"description"`
|
||||
}
|
||||
|
||||
type PostgresqlBindUser struct {
|
||||
@@ -77,3 +78,48 @@ type PostgresqlDBDelete struct {
|
||||
ForceDelete bool `json:"forceDelete"`
|
||||
DeleteBackup bool `json:"deleteBackup"`
|
||||
}
|
||||
|
||||
type PostgresqlUserSearch struct {
|
||||
Database string `json:"database" validate:"required"`
|
||||
}
|
||||
|
||||
type PostgresqlUser struct {
|
||||
Username string `json:"username"`
|
||||
Password string `json:"password"`
|
||||
Description string `json:"description"`
|
||||
SuperUser bool `json:"superUser"`
|
||||
Protected bool `json:"protected"`
|
||||
Databases []string `json:"databases"`
|
||||
}
|
||||
|
||||
type PostgresqlUserCreate struct {
|
||||
Database string `json:"database" validate:"required"`
|
||||
Username string `json:"username" validate:"required"`
|
||||
Password string `json:"password" validate:"required"`
|
||||
Description string `json:"description"`
|
||||
SuperUser bool `json:"superUser"`
|
||||
}
|
||||
|
||||
type PostgresqlUserUpdate struct {
|
||||
Database string `json:"database" validate:"required"`
|
||||
Username string `json:"username" validate:"required"`
|
||||
Description string `json:"description"`
|
||||
SuperUser bool `json:"superUser"`
|
||||
}
|
||||
|
||||
type PostgresqlUserPassword struct {
|
||||
Database string `json:"database" validate:"required"`
|
||||
Username string `json:"username" validate:"required"`
|
||||
Password string `json:"password" validate:"required"`
|
||||
}
|
||||
|
||||
type PostgresqlUserDelete struct {
|
||||
Database string `json:"database" validate:"required"`
|
||||
Username string `json:"username" validate:"required"`
|
||||
}
|
||||
|
||||
type PostgresqlUserGrant struct {
|
||||
Database string `json:"database" validate:"required"`
|
||||
Name string `json:"name" validate:"required"`
|
||||
Username string `json:"username" validate:"required"`
|
||||
}
|
||||
|
||||
@@ -20,6 +20,7 @@ type IPostgresqlRepo interface {
|
||||
Create(ctx context.Context, postgresql *model.DatabasePostgresql) error
|
||||
Delete(ctx context.Context, opts ...DBOption) error
|
||||
Update(id uint, vars map[string]interface{}) error
|
||||
SaveUserPassword(user *model.DatabaseUser) error
|
||||
DeleteLocal(ctx context.Context) error
|
||||
}
|
||||
|
||||
@@ -106,6 +107,20 @@ func (u *PostgresqlRepo) Update(id uint, vars map[string]interface{}) error {
|
||||
return global.DB.Model(&model.DatabasePostgresql{}).Where("id = ?", id).Updates(vars).Error
|
||||
}
|
||||
|
||||
func (u *PostgresqlRepo) SaveUserPassword(user *model.DatabaseUser) error {
|
||||
password, err := encrypt.StringEncrypt(user.Password)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
user.Password = password
|
||||
return global.DB.Transaction(func(tx *gorm.DB) error {
|
||||
if err := tx.Save(user).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Model(&model.DatabasePostgresql{}).Where("postgresql_name = ? AND username = ?", user.Database, user.Username).Update("password", password).Error
|
||||
})
|
||||
}
|
||||
|
||||
func (u *PostgresqlRepo) WithByPostgresqlName(postgresqlName string) DBOption {
|
||||
return func(g *gorm.DB) *gorm.DB {
|
||||
return g.Where("postgresql_name = ?", postgresqlName)
|
||||
|
||||
@@ -46,6 +46,7 @@ import (
|
||||
"github.com/sirupsen/logrus"
|
||||
"github.com/subosito/gotenv"
|
||||
"gopkg.in/yaml.v3"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
type DatabaseOp string
|
||||
@@ -268,14 +269,14 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
|
||||
if dbConfig.DbName != "" && dbConfig.DbUser != "" && dbConfig.Password != "" {
|
||||
switch database.Type {
|
||||
case constant.AppPostgresql, constant.AppPostgres, constant.AppPostgresqlCluster:
|
||||
oldPostgresqlDb, _ := postgresqlRepo.Get(repo.WithByName(dbConfig.DbName), repo.WithByFrom(constant.ResourceLocal))
|
||||
if oldPostgresqlDb.ID == 0 {
|
||||
oldPostgresqlDb, _ = postgresqlRepo.Get(repo.WithByName(dbConfig.DbName), postgresqlRepo.WithByPostgresqlName(dbConfig.DatabaseName), repo.WithByFrom(constant.AppResourceRemote))
|
||||
oldPostgresqlDb, err := postgresqlRepo.Get(repo.WithByName(dbConfig.DbName), postgresqlRepo.WithByPostgresqlName(database.Name), repo.WithByFrom(database.From))
|
||||
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return err
|
||||
}
|
||||
resourceId = oldPostgresqlDb.ID
|
||||
if oldPostgresqlDb.ID > 0 {
|
||||
if oldPostgresqlDb.Username != dbConfig.DbUser || oldPostgresqlDb.Password != dbConfig.Password {
|
||||
return buserr.New("ErrDbUserNotValid")
|
||||
if err := ensureAppPostgresqlDBUser(database, dbConfig); err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
var createPostgresql dto.PostgresqlDBCreate
|
||||
@@ -463,6 +464,9 @@ func deleteAppInstall(deleteReq request.AppInstallDelete) error {
|
||||
case constant.AppMongodb:
|
||||
_ = mongodbRepo.Delete(ctx, mongodbRepo.WithByMongodbName(install.Name))
|
||||
case constant.AppPostgresql, constant.AppPostgresqlCluster:
|
||||
if err := databaseUserRepo.DeleteBy(ctx, repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(install.Name)); err != nil {
|
||||
return err
|
||||
}
|
||||
_ = postgresqlRepo.Delete(ctx, postgresqlRepo.WithByPostgresqlName(install.Name))
|
||||
}
|
||||
|
||||
@@ -619,6 +623,32 @@ func ensureAppMysqlDBUser(database model.Database, dbConfig dto.AppDatabase) err
|
||||
})
|
||||
}
|
||||
|
||||
func ensureAppPostgresqlDBUser(database model.Database, dbConfig dto.AppDatabase) error {
|
||||
pgService := NewIPostgresqlService()
|
||||
users, err := pgService.ListUsers(dto.PostgresqlUserSearch{Database: database.Name})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, user := range users {
|
||||
if user.Username != dbConfig.DbUser {
|
||||
continue
|
||||
}
|
||||
if user.Password == "" || user.Password != dbConfig.Password {
|
||||
return buserr.New("ErrDbUserNotValid")
|
||||
}
|
||||
if user.SuperUser {
|
||||
return nil
|
||||
}
|
||||
for _, name := range user.Databases {
|
||||
if name == dbConfig.DbName {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return pgService.GrantUser(dto.PostgresqlUserGrant{Database: database.Name, Name: dbConfig.DbName, Username: dbConfig.DbUser})
|
||||
}
|
||||
return buserr.New("ErrDbUserNotValid")
|
||||
}
|
||||
|
||||
func deleteLink(del dto.DelAppLink) error {
|
||||
install := del.Install
|
||||
resources, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithAppInstallId(install.ID))
|
||||
|
||||
@@ -11,6 +11,7 @@ import (
|
||||
"time"
|
||||
|
||||
"github.com/1Panel-dev/1Panel/agent/app/repo"
|
||||
"github.com/compose-spec/compose-go/v2/dotenv"
|
||||
"github.com/subosito/gotenv"
|
||||
|
||||
"github.com/1Panel-dev/1Panel/agent/app/task"
|
||||
@@ -538,27 +539,58 @@ func ensureMysqlDBUser(mysqlService IMysqlService, database model.Database, dbIn
|
||||
|
||||
func reCreatePostgresqlDB(dbID uint, database model.Database, envMap map[string]interface{}) (*model.DatabasePostgresql, error) {
|
||||
postgresqlService := NewIPostgresqlService()
|
||||
_ = postgresqlService.Delete(context.Background(), dto.PostgresqlDBDelete{
|
||||
dbInfo := getDBCreateInfoFromEnv(envMap, "UTF8")
|
||||
users, err := postgresqlService.ListUsers(dto.PostgresqlUserSearch{Database: database.Name})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
existingUser := false
|
||||
for _, user := range users {
|
||||
if user.Username != dbInfo.User {
|
||||
continue
|
||||
}
|
||||
if user.Password == "" {
|
||||
return nil, buserr.New("ErrDbUserNotValid")
|
||||
}
|
||||
dbInfo.Password = user.Password
|
||||
existingUser = true
|
||||
break
|
||||
}
|
||||
if err := postgresqlService.Delete(context.Background(), dto.PostgresqlDBDelete{
|
||||
ID: dbID,
|
||||
Type: database.Type,
|
||||
Database: database.Name,
|
||||
DeleteBackup: false,
|
||||
ForceDelete: true,
|
||||
})
|
||||
ForceDelete: false,
|
||||
}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
dbInfo := getDBCreateInfoFromEnv(envMap, "UTF8")
|
||||
createDB, err := postgresqlService.Create(context.Background(), dto.PostgresqlDBCreate{
|
||||
Name: dbInfo.Name,
|
||||
From: database.From,
|
||||
Database: database.Name,
|
||||
Format: dbInfo.Format,
|
||||
Username: dbInfo.User,
|
||||
Password: dbInfo.Password,
|
||||
SuperUser: true,
|
||||
ExistingUser: existingUser,
|
||||
Name: dbInfo.Name,
|
||||
From: database.From,
|
||||
Database: database.Name,
|
||||
Format: dbInfo.Format,
|
||||
Username: dbInfo.User,
|
||||
Password: dbInfo.Password,
|
||||
SuperUser: true,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
oldPassword, _ := envMap["PANEL_DB_USER_PASSWORD"].(string)
|
||||
if oldPassword != "" && oldPassword != dbInfo.Password {
|
||||
if datasource, ok := envMap["CASDOOR_DATASOURCE_NAME"].(string); ok {
|
||||
escape := strings.NewReplacer(`\`, `\\`, "'", `\'`)
|
||||
password := "password='" + escape.Replace(dbInfo.Password) + "'"
|
||||
envMap["CASDOOR_DATASOURCE_NAME"] = strings.NewReplacer(
|
||||
"password='"+escape.Replace(oldPassword)+"'", password,
|
||||
"password="+oldPassword, password,
|
||||
).Replace(datasource)
|
||||
}
|
||||
}
|
||||
envMap["PANEL_DB_USER_PASSWORD"] = dbInfo.Password
|
||||
updateCronjobsDBRef(dbID, createDB.ID)
|
||||
return createDB, nil
|
||||
}
|
||||
@@ -594,11 +626,12 @@ func updateCronjobsDBRef(oldDBID, newDBID uint) {
|
||||
}
|
||||
|
||||
func buildRecoverEnv(appEnv string, backupEnvMap, installedEnvMap map[string]interface{}) (string, string, error) {
|
||||
var appEnvMap map[string]interface{}
|
||||
if err := json.Unmarshal([]byte(appEnv), &appEnvMap); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
currentHostVal, hasCurrentHost := installedEnvMap["PANEL_DB_HOST"]
|
||||
if hasCurrentHost && fmt.Sprintf("%v", currentHostVal) != "" {
|
||||
backupHost := fmt.Sprintf("\"PANEL_DB_HOST\":\"%v\"", backupEnvMap["PANEL_DB_HOST"])
|
||||
currentHost := fmt.Sprintf("\"PANEL_DB_HOST\":\"%v\"", currentHostVal)
|
||||
appEnv = strings.ReplaceAll(appEnv, backupHost, currentHost)
|
||||
if _, ok := backupEnvMap["CASDOOR_DATASOURCE_NAME"]; ok {
|
||||
backupEnvMap["CASDOOR_DATASOURCE_NAME"] = strings.ReplaceAll(
|
||||
fmt.Sprintf("%v", backupEnvMap["CASDOOR_DATASOURCE_NAME"]),
|
||||
@@ -608,37 +641,45 @@ func buildRecoverEnv(appEnv string, backupEnvMap, installedEnvMap map[string]int
|
||||
}
|
||||
backupEnvMap["PANEL_DB_HOST"] = currentHostVal
|
||||
}
|
||||
if appEnvMap == nil {
|
||||
return "", "", buserr.New("ErrInvalidParams")
|
||||
}
|
||||
for _, key := range []string{"PANEL_DB_HOST", "PANEL_DB_USER_PASSWORD", "CASDOOR_DATASOURCE_NAME"} {
|
||||
if value, ok := backupEnvMap[key]; ok {
|
||||
appEnvMap[key] = value
|
||||
}
|
||||
}
|
||||
mergedAppEnv, err := json.Marshal(appEnvMap)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
appEnv = string(mergedAppEnv)
|
||||
newEnvMap := make(map[string]string, len(backupEnvMap))
|
||||
MergeAppEnvironment(backupEnvMap, newEnvMap)
|
||||
mergedEnvContent, err := gotenv.Marshal(newEnvMap)
|
||||
if err != nil {
|
||||
return appEnv, "", err
|
||||
}
|
||||
return appEnv, mergedEnvContent, nil
|
||||
lines := strings.Split(mergedEnvContent, "\n")
|
||||
for i, line := range lines {
|
||||
for _, key := range []string{"PANEL_DB_USER_PASSWORD", "CASDOOR_DATASOURCE_NAME"} {
|
||||
if strings.HasPrefix(line, key+"=") {
|
||||
lines[i] = fmt.Sprintf("%s=%q", key, strings.ReplaceAll(newEnvMap[key], "$", "$$"))
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return appEnv, strings.Join(lines, "\n"), nil
|
||||
}
|
||||
|
||||
func getEnvMapByPath(envPath string) (map[string]interface{}, error) {
|
||||
envMap := make(map[string]interface{})
|
||||
envFile, err := os.ReadFile(envPath)
|
||||
values, err := dotenv.ReadWithLookup(func(string) (string, bool) { return "", false }, envPath)
|
||||
if err != nil {
|
||||
return envMap, err
|
||||
return nil, err
|
||||
}
|
||||
lines := strings.Split(string(envFile), "\n")
|
||||
for _, line := range lines {
|
||||
line = strings.TrimSpace(line)
|
||||
if line == "" || strings.HasPrefix(line, "#") {
|
||||
continue
|
||||
}
|
||||
parts := strings.SplitN(line, "=", 2)
|
||||
if len(parts) == 2 {
|
||||
value := strings.TrimSpace(parts[1])
|
||||
if len(value) >= 2 {
|
||||
if (value[0] == '"' && value[len(value)-1] == '"') || (value[0] == '\'' && value[len(value)-1] == '\'') {
|
||||
value = value[1 : len(value)-1]
|
||||
}
|
||||
}
|
||||
envMap[parts[0]] = value
|
||||
}
|
||||
envMap := make(map[string]interface{}, len(values))
|
||||
for key, value := range values {
|
||||
envMap[key] = value
|
||||
}
|
||||
return envMap, nil
|
||||
}
|
||||
|
||||
@@ -137,7 +137,7 @@ func (u *DatabaseService) CheckDatabase(req dto.DatabaseCreate) bool {
|
||||
var err error
|
||||
switch req.Type {
|
||||
case constant.AppPostgresql:
|
||||
_, err = postgresql.NewPostgresqlClient(pgclient.DBInfo{
|
||||
pgClient, connectErr := postgresql.NewPostgresqlClient(pgclient.DBInfo{
|
||||
From: "remote",
|
||||
Address: req.Address,
|
||||
Port: req.Port,
|
||||
@@ -146,6 +146,10 @@ func (u *DatabaseService) CheckDatabase(req dto.DatabaseCreate) bool {
|
||||
Password: req.Password,
|
||||
Timeout: req.Timeout,
|
||||
})
|
||||
if connectErr == nil {
|
||||
pgClient.Close()
|
||||
}
|
||||
err = connectErr
|
||||
case constant.AppRedis:
|
||||
_, err = redisclient.NewRedisClient(redisclient.DBInfo{
|
||||
Address: req.Address,
|
||||
@@ -200,7 +204,7 @@ func (u *DatabaseService) Create(req dto.DatabaseCreate) error {
|
||||
}
|
||||
switch req.Type {
|
||||
case constant.AppPostgresql:
|
||||
if _, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
|
||||
pgClient, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
|
||||
From: "remote",
|
||||
Address: req.Address,
|
||||
Port: req.Port,
|
||||
@@ -208,9 +212,11 @@ func (u *DatabaseService) Create(req dto.DatabaseCreate) error {
|
||||
Username: req.Username,
|
||||
Password: req.Password,
|
||||
Timeout: req.Timeout,
|
||||
}); err != nil {
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
pgClient.Close()
|
||||
case constant.AppRedis:
|
||||
if _, err := redisclient.NewRedisClient(redisclient.DBInfo{
|
||||
Address: req.Address,
|
||||
@@ -302,6 +308,9 @@ func (u *DatabaseService) Delete(req dto.DatabaseDelete) error {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
if err := databaseUserRepo.Delete(repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(db.Name)); err != nil && !req.ForceDelete {
|
||||
return err
|
||||
}
|
||||
if err := postgresqlRepo.Delete(context.Background(), postgresqlRepo.WithByPostgresqlName(db.Name)); err != nil && !req.ForceDelete {
|
||||
return err
|
||||
}
|
||||
@@ -316,7 +325,7 @@ func (u *DatabaseService) Update(req dto.DatabaseUpdate) error {
|
||||
}
|
||||
switch req.Type {
|
||||
case constant.AppPostgresql:
|
||||
if _, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
|
||||
pgClient, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
|
||||
From: "remote",
|
||||
Address: req.Address,
|
||||
Port: req.Port,
|
||||
@@ -324,9 +333,11 @@ func (u *DatabaseService) Update(req dto.DatabaseUpdate) error {
|
||||
Username: req.Username,
|
||||
Password: req.Password,
|
||||
Timeout: req.Timeout,
|
||||
}); err != nil {
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
pgClient.Close()
|
||||
case constant.AppRedis:
|
||||
if _, err := redisclient.NewRedisClient(redisclient.DBInfo{
|
||||
Address: req.Address,
|
||||
|
||||
@@ -2,6 +2,7 @@ package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path"
|
||||
@@ -21,21 +22,30 @@ import (
|
||||
"github.com/1Panel-dev/1Panel/agent/utils/postgresql/client"
|
||||
_ "github.com/jackc/pgx/v5/stdlib"
|
||||
"github.com/jinzhu/copier"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
type PostgresqlService struct{}
|
||||
|
||||
type IPostgresqlService interface {
|
||||
ListUsers(req dto.PostgresqlUserSearch) ([]dto.PostgresqlUser, error)
|
||||
CreateUser(req dto.PostgresqlUserCreate) error
|
||||
UpdateUser(req dto.PostgresqlUserUpdate) error
|
||||
ChangeUserPassword(req dto.PostgresqlUserPassword) error
|
||||
SaveUserPassword(req dto.PostgresqlUserPassword) error
|
||||
DeleteUser(req dto.PostgresqlUserDelete) error
|
||||
GrantUser(req dto.PostgresqlUserGrant) error
|
||||
RevokeUser(req dto.PostgresqlUserGrant) error
|
||||
SearchWithPage(search dto.PostgresqlDBSearch) (int64, interface{}, error)
|
||||
ListDBOption() ([]dto.PostgresqlOption, error)
|
||||
BindUser(req dto.PostgresqlBindUser) error
|
||||
Create(ctx context.Context, req dto.PostgresqlDBCreate) (*model.DatabasePostgresql, error)
|
||||
LoadFromRemote(database string) error
|
||||
ChangePrivileges(req dto.PostgresqlPrivileges) error
|
||||
ChangePassword(info dto.ChangeDBInfo) error
|
||||
UpdateDescription(req dto.UpdateDescription) error
|
||||
DeleteCheck(req dto.PostgresqlDBDeleteCheck) ([]dto.DBResource, error)
|
||||
Delete(ctx context.Context, req dto.PostgresqlDBDelete) error
|
||||
ChangePrivileges(req dto.PostgresqlPrivileges) error
|
||||
ChangePassword(info dto.ChangeDBInfo) error
|
||||
}
|
||||
|
||||
func NewIPostgresqlService() IPostgresqlService {
|
||||
@@ -87,43 +97,30 @@ func (u *PostgresqlService) ListDBOption() ([]dto.PostgresqlOption, error) {
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) BindUser(req dto.PostgresqlBindUser) error {
|
||||
if cmd.CheckIllegal(req.Name, req.Username, req.Password) || strings.Contains(req.Password, " ") {
|
||||
return buserr.New("ErrCmdIllegal")
|
||||
}
|
||||
dbItem, err := postgresqlRepo.Get(postgresqlRepo.WithByPostgresqlName(req.Database), repo.WithByName(req.Name))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
pgClient, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err := u.CreateUser(dto.PostgresqlUserCreate{Database: req.Database, Username: req.Username, Password: req.Password, SuperUser: req.SuperUser}); err != nil {
|
||||
return err
|
||||
}
|
||||
if !req.SuperUser {
|
||||
if err := u.GrantUser(dto.PostgresqlUserGrant{Database: req.Database, Name: req.Name, Username: req.Username}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if dbItem.Username != "" {
|
||||
return nil
|
||||
}
|
||||
password, err := encrypt.StringEncrypt(req.Password)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := pgClient.CreateUser(client.CreateInfo{
|
||||
Name: req.Name,
|
||||
Username: req.Username,
|
||||
Password: req.Password,
|
||||
SuperUser: req.SuperUser,
|
||||
Timeout: 300,
|
||||
}, false); err != nil {
|
||||
return err
|
||||
}
|
||||
pass, err := encrypt.StringEncrypt(req.Password)
|
||||
if err != nil {
|
||||
return fmt.Errorf("decrypt database db password failed, err: %v", err)
|
||||
}
|
||||
if err := postgresqlRepo.Update(dbItem.ID, map[string]interface{}{
|
||||
"username": req.Username,
|
||||
"password": pass,
|
||||
"super_user": req.SuperUser,
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
return postgresqlRepo.Update(dbItem.ID, map[string]interface{}{"username": req.Username, "password": password, "super_user": req.SuperUser})
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) Create(ctx context.Context, req dto.PostgresqlDBCreate) (*model.DatabasePostgresql, error) {
|
||||
if cmd.CheckIllegal(req.Name, req.Username, req.Password, req.Format) || strings.Contains(req.Password, " ") {
|
||||
if cmd.CheckIllegal(req.Name, req.Format) || (!req.ExistingUser && (cmd.CheckIllegal(req.Username, req.Password) || strings.Contains(req.Password, " "))) {
|
||||
return nil, buserr.New("ErrCmdIllegal")
|
||||
}
|
||||
|
||||
@@ -132,6 +129,26 @@ func (u *PostgresqlService) Create(ctx context.Context, req dto.PostgresqlDBCrea
|
||||
return nil, buserr.New("ErrRecordExist")
|
||||
}
|
||||
|
||||
if req.ExistingUser {
|
||||
users, err := u.ListUsers(dto.PostgresqlUserSearch{Database: req.Database})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
found := false
|
||||
for _, user := range users {
|
||||
if user.Username == req.Username {
|
||||
req.Password, req.SuperUser = user.Password, user.SuperUser
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
return nil, buserr.New("ErrRecordNotFound")
|
||||
}
|
||||
} else if req.Password == "" {
|
||||
return nil, buserr.New("ErrInvalidParams")
|
||||
}
|
||||
|
||||
var createItem model.DatabasePostgresql
|
||||
if err := copier.Copy(&createItem, &req); err != nil {
|
||||
return nil, buserr.WithDetail("ErrStructTransform", err.Error(), nil)
|
||||
@@ -144,13 +161,13 @@ func (u *PostgresqlService) Create(ctx context.Context, req dto.PostgresqlDBCrea
|
||||
defer cli.Close()
|
||||
|
||||
createItem.PostgresqlName = req.Database
|
||||
defer cli.Close()
|
||||
if err := cli.Create(client.CreateInfo{
|
||||
Name: req.Name,
|
||||
Username: req.Username,
|
||||
Password: req.Password,
|
||||
SuperUser: req.SuperUser,
|
||||
Timeout: 300,
|
||||
ExistingUser: req.ExistingUser,
|
||||
Name: req.Name,
|
||||
Username: req.Username,
|
||||
Password: req.Password,
|
||||
SuperUser: req.SuperUser,
|
||||
Timeout: 300,
|
||||
}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -159,45 +176,18 @@ func (u *PostgresqlService) Create(ctx context.Context, req dto.PostgresqlDBCrea
|
||||
if err := postgresqlRepo.Create(ctx, &createItem); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &createItem, nil
|
||||
}
|
||||
|
||||
func LoadPostgresqlClientByFrom(database string) (postgresql.PostgresqlClient, error) {
|
||||
var (
|
||||
dbInfo client.DBInfo
|
||||
err error
|
||||
)
|
||||
|
||||
dbInfo.Timeout = 300
|
||||
databaseItem, err := databaseRepo.Get(repo.WithByName(database))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
dbInfo.From = databaseItem.From
|
||||
dbInfo.Database = database
|
||||
if dbInfo.From != "local" {
|
||||
dbInfo.Address = databaseItem.Address
|
||||
dbInfo.Port = databaseItem.Port
|
||||
dbInfo.Username = databaseItem.Username
|
||||
dbInfo.Password = databaseItem.Password
|
||||
dbInfo.InitialDB = databaseItem.InitialDB
|
||||
} else {
|
||||
app, err := appInstallRepo.LoadBaseInfo(databaseItem.Type, database)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
if !req.ExistingUser {
|
||||
user, err := databaseUserRepo.GetEncryptedWithContext(ctx, repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database), databaseUserRepo.WithByUser(req.Username, ""))
|
||||
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return &createItem, err
|
||||
}
|
||||
user.Type, user.Database, user.Username, user.Host = "postgresql", req.Database, req.Username, ""
|
||||
user.Password, user.Description, user.IsDelete = createItem.Password, "", false
|
||||
if err := databaseUserRepo.SaveEncryptedWithContext(ctx, &user); err != nil {
|
||||
return &createItem, err
|
||||
}
|
||||
dbInfo.From = "local"
|
||||
dbInfo.Address = app.ContainerName
|
||||
dbInfo.Username = app.UserName
|
||||
dbInfo.Password = app.Password
|
||||
dbInfo.Port = uint(app.Port)
|
||||
}
|
||||
|
||||
cli, err := postgresql.NewPostgresqlClient(dbInfo)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return cli, nil
|
||||
return &createItem, nil
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) LoadFromRemote(database string) error {
|
||||
@@ -302,8 +292,8 @@ func (u *PostgresqlService) DeleteCheck(req dto.PostgresqlDBDeleteCheck) ([]dto.
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) Delete(ctx context.Context, req dto.PostgresqlDBDelete) error {
|
||||
db, err := postgresqlRepo.Get(repo.WithByID(req.ID))
|
||||
if err != nil && !req.ForceDelete {
|
||||
db, err := postgresqlRepo.Get(repo.WithByID(req.ID), postgresqlRepo.WithByPostgresqlName(req.Database))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
@@ -311,15 +301,26 @@ func (u *PostgresqlService) Delete(ctx context.Context, req dto.PostgresqlDBDele
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
if db.Username != "" {
|
||||
user, err := databaseUserRepo.GetEncryptedWithContext(ctx, repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database), databaseUserRepo.WithByUser(db.Username, ""))
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
password, encryptErr := encrypt.StringEncrypt(db.Password)
|
||||
if encryptErr != nil {
|
||||
return encryptErr
|
||||
}
|
||||
user = model.DatabaseUser{Type: "postgresql", Database: req.Database, Username: db.Username, Password: password}
|
||||
if err := databaseUserRepo.SaveEncryptedWithContext(ctx, &user); err != nil {
|
||||
return err
|
||||
}
|
||||
} else if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := cli.Delete(client.DeleteInfo{
|
||||
Name: db.Name,
|
||||
Username: db.Username,
|
||||
ForceDelete: req.ForceDelete,
|
||||
Timeout: 300,
|
||||
}); err != nil && !req.ForceDelete {
|
||||
if strings.HasPrefix(err.Error(), "drop user") {
|
||||
_ = postgresqlRepo.Update(db.ID, map[string]interface{}{"is_delete": true})
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -336,101 +337,40 @@ func (u *PostgresqlService) Delete(ctx context.Context, req dto.PostgresqlDBDele
|
||||
global.LOG.Infof("delete database %s-%s backups successful", req.Database, db.Name)
|
||||
}
|
||||
|
||||
_ = postgresqlRepo.Delete(ctx, repo.WithByID(db.ID))
|
||||
return nil
|
||||
return postgresqlRepo.Delete(ctx, repo.WithByID(db.ID))
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) ChangePrivileges(req dto.PostgresqlPrivileges) error {
|
||||
if cmd.CheckIllegal(req.Database, req.Username) {
|
||||
return buserr.New("ErrCmdIllegal")
|
||||
}
|
||||
dbItem, err := postgresqlRepo.Get(postgresqlRepo.WithByPostgresqlName(req.Database), repo.WithByName(req.Name))
|
||||
user, err := u.loadPostgresqlUser(req.Database, req.Username)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
|
||||
if err := cli.ChangePrivileges(client.Privileges{Username: req.Username, SuperUser: req.SuperUser, Timeout: 300}); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := postgresqlRepo.Update(dbItem.ID, map[string]interface{}{
|
||||
"super_user": req.SuperUser,
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
return u.UpdateUser(dto.PostgresqlUserUpdate{Database: req.Database, Username: req.Username, SuperUser: req.SuperUser, Description: user.Description})
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) ChangePassword(req dto.ChangeDBInfo) error {
|
||||
if cmd.CheckIllegal(req.Value) || strings.Contains(req.Value, " ") {
|
||||
return buserr.New("ErrCmdIllegal")
|
||||
}
|
||||
if req.ID != 0 {
|
||||
db, err := postgresqlRepo.Get(repo.WithByID(req.ID), postgresqlRepo.WithByPostgresqlName(req.Database))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return u.ChangeUserPassword(dto.PostgresqlUserPassword{Database: req.Database, Username: db.Username, Password: req.Value})
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
var (
|
||||
postgresqlData model.DatabasePostgresql
|
||||
passwordInfo client.PasswordChangeInfo
|
||||
)
|
||||
passwordInfo.Password = req.Value
|
||||
passwordInfo.Timeout = 300
|
||||
|
||||
if req.ID != 0 {
|
||||
postgresqlData, err = postgresqlRepo.Get(repo.WithByID(req.ID))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
passwordInfo.Username = postgresqlData.Username
|
||||
} else {
|
||||
dbItem, err := databaseRepo.Get(repo.WithByType(req.Type), repo.WithByFrom(req.From))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
passwordInfo.Username = dbItem.Username
|
||||
}
|
||||
if err := cli.ChangePassword(passwordInfo); err != nil {
|
||||
dbItem, err := databaseRepo.Get(repo.WithByName(req.Database))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if req.ID != 0 {
|
||||
var appRess []model.AppInstallResource
|
||||
if req.From == "local" {
|
||||
app, err := appInstallRepo.LoadBaseInfo(req.Type, req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
appRess, _ = appInstallResourceRepo.GetBy(appInstallResourceRepo.WithLinkId(app.ID), appInstallResourceRepo.WithResourceId(postgresqlData.ID))
|
||||
} else {
|
||||
appRess, _ = appInstallResourceRepo.GetBy(appInstallResourceRepo.WithResourceId(postgresqlData.ID))
|
||||
}
|
||||
for _, appRes := range appRess {
|
||||
appInstall, err := appInstallRepo.GetFirst(repo.WithByID(appRes.AppInstallId))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
appModel, err := appRepo.GetFirst(repo.WithByID(appInstall.AppId))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
global.LOG.Infof("start to update postgresql password used by app %s-%s", appModel.Key, appInstall.Name)
|
||||
if err := updateInstallInfoInDB(appModel.Key, appInstall.Name, "user-password", req.Value); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
global.LOG.Info("execute password change sql successful")
|
||||
pass, err := encrypt.StringEncrypt(req.Value)
|
||||
if err != nil {
|
||||
return fmt.Errorf("decrypt database db password failed, err: %v", err)
|
||||
}
|
||||
_ = postgresqlRepo.Update(postgresqlData.ID, map[string]interface{}{"password": pass})
|
||||
return nil
|
||||
passwordInfo := client.PasswordChangeInfo{Username: dbItem.Username, Password: req.Value, Timeout: 300}
|
||||
if err := cli.ChangePassword(passwordInfo); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := updateInstallInfoInDB(req.Type, req.Database, "password", req.Value); err != nil {
|
||||
@@ -449,3 +389,44 @@ func (u *PostgresqlService) ChangePassword(req dto.ChangeDBInfo) error {
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func LoadPostgresqlClientByFrom(database string) (postgresql.PostgresqlClient, error) {
|
||||
var (
|
||||
dbInfo client.DBInfo
|
||||
err error
|
||||
)
|
||||
|
||||
dbInfo.Timeout = 300
|
||||
databaseItem, err := databaseRepo.Get(repo.WithByName(database))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if databaseItem.Type != constant.AppPostgresql && databaseItem.Type != constant.AppPostgresqlCluster && databaseItem.Type != constant.AppPostgres {
|
||||
return nil, buserr.New("ErrInvalidParams")
|
||||
}
|
||||
dbInfo.From = databaseItem.From
|
||||
dbInfo.Database = database
|
||||
if dbInfo.From != "local" {
|
||||
dbInfo.Address = databaseItem.Address
|
||||
dbInfo.Port = databaseItem.Port
|
||||
dbInfo.Username = databaseItem.Username
|
||||
dbInfo.Password = databaseItem.Password
|
||||
dbInfo.InitialDB = databaseItem.InitialDB
|
||||
} else {
|
||||
app, err := appInstallRepo.LoadBaseInfo(databaseItem.Type, database)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
dbInfo.From = "local"
|
||||
dbInfo.Address = app.ContainerName
|
||||
dbInfo.Username = app.UserName
|
||||
dbInfo.Password = app.Password
|
||||
dbInfo.Port = uint(app.Port)
|
||||
}
|
||||
|
||||
cli, err := postgresql.NewPostgresqlClient(dbInfo)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return cli, nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,382 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/1Panel-dev/1Panel/agent/app/dto"
|
||||
"github.com/1Panel-dev/1Panel/agent/app/model"
|
||||
"github.com/1Panel-dev/1Panel/agent/app/repo"
|
||||
"github.com/1Panel-dev/1Panel/agent/buserr"
|
||||
"github.com/1Panel-dev/1Panel/agent/constant"
|
||||
"github.com/1Panel-dev/1Panel/agent/utils/encrypt"
|
||||
"github.com/1Panel-dev/1Panel/agent/utils/postgresql/client"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
func (u *PostgresqlService) ListUsers(req dto.PostgresqlUserSearch) ([]dto.PostgresqlUser, error) {
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer cli.Close()
|
||||
users, err := client.ListUsers(cli)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
metadata, err := databaseUserRepo.List(repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
legacy, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(req.Database))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
result := make([]dto.PostgresqlUser, 0, len(users))
|
||||
for _, user := range users {
|
||||
item := dto.PostgresqlUser{Username: user.Username, SuperUser: user.SuperUser, Protected: user.Protected, Databases: user.Databases}
|
||||
passwords := make(map[string]struct{})
|
||||
for _, db := range legacy {
|
||||
if db.Username == user.Username && db.Password != "" {
|
||||
passwords[db.Password] = struct{}{}
|
||||
}
|
||||
}
|
||||
if len(passwords) == 1 {
|
||||
for password := range passwords {
|
||||
item.Password = password
|
||||
}
|
||||
}
|
||||
for _, meta := range metadata {
|
||||
if meta.Username == user.Username {
|
||||
item.Password, item.Description = meta.Password, meta.Description
|
||||
break
|
||||
}
|
||||
}
|
||||
result = append(result, item)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) CreateUser(req dto.PostgresqlUserCreate) error {
|
||||
if strings.HasPrefix(req.Username, "pg_") || req.Username == "postgres" {
|
||||
return buserr.New("ErrPgUserProtected")
|
||||
}
|
||||
if req.Username == "" || len(req.Username) > 63 || req.Password == "" || strings.ContainsAny(req.Username+req.Password, "\x00") {
|
||||
return buserr.New("ErrInvalidParams")
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
if err := cli.CreateUser(client.CreateInfo{Username: req.Username, Password: req.Password, SuperUser: req.SuperUser, Timeout: 300}, false); err != nil {
|
||||
return err
|
||||
}
|
||||
return saveDatabaseUserCredential("postgresql", req.Database, req.Username, "", req.Password, req.Description)
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) UpdateUser(req dto.PostgresqlUserUpdate) error {
|
||||
user, err := u.loadPostgresqlUser(req.Database, req.Username)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if user.Protected {
|
||||
return buserr.New("ErrPgUserProtected")
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
if err := cli.ChangePrivileges(client.Privileges{Username: req.Username, SuperUser: req.SuperUser, Timeout: 300}); err != nil {
|
||||
return err
|
||||
}
|
||||
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(req.Database))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, db := range dbs {
|
||||
if db.Username == req.Username {
|
||||
if err := postgresqlRepo.Update(db.ID, map[string]interface{}{"super_user": req.SuperUser}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return saveDatabaseUserCredential("postgresql", req.Database, req.Username, "", user.Password, req.Description)
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) ChangeUserPassword(req dto.PostgresqlUserPassword) error {
|
||||
user, err := u.loadPostgresqlUser(req.Database, req.Username)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if user.Protected {
|
||||
return buserr.New("ErrPgUserProtected")
|
||||
}
|
||||
if req.Password == "" || strings.ContainsRune(req.Password, 0) {
|
||||
return buserr.New("ErrInvalidParams")
|
||||
}
|
||||
targets, err := loadPostgresqlUserApps(req.Database, req.Username, "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(req.Database))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
password, err := encrypt.StringEncrypt(req.Password)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
if err := cli.ChangePassword(client.PasswordChangeInfo{Username: req.Username, Password: req.Password, Timeout: 300}); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := saveDatabaseUserCredential("postgresql", req.Database, req.Username, "", req.Password, user.Description); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, db := range dbs {
|
||||
if db.Username == req.Username {
|
||||
if err := postgresqlRepo.Update(db.ID, map[string]interface{}{"password": password}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
var failures []string
|
||||
for _, app := range targets {
|
||||
if err := updateInstallInfoInDB(app.App.Key, app.Name, "user-password", req.Password); err != nil {
|
||||
failures = append(failures, fmt.Sprintf("%s: %v", app.Name, err))
|
||||
}
|
||||
}
|
||||
if len(failures) != 0 {
|
||||
return buserr.WithDetail("ErrPgUserPasswordSync", strings.Join(failures, "; "), nil)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) SaveUserPassword(req dto.PostgresqlUserPassword) error {
|
||||
if req.Password == "" || strings.ContainsRune(req.Password, 0) {
|
||||
return buserr.New("ErrInvalidParams")
|
||||
}
|
||||
user, err := u.loadPostgresqlUser(req.Database, req.Username)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if user.Protected {
|
||||
return buserr.New("ErrPgUserProtected")
|
||||
}
|
||||
metadata, err := databaseUserRepo.Get(repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database), databaseUserRepo.WithByUser(req.Username, ""))
|
||||
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return err
|
||||
}
|
||||
metadata.Type, metadata.Database, metadata.Username, metadata.Host = "postgresql", req.Database, req.Username, ""
|
||||
metadata.Password, metadata.Description, metadata.IsDelete = req.Password, user.Description, false
|
||||
return postgresqlRepo.SaveUserPassword(&metadata)
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) DeleteUser(req dto.PostgresqlUserDelete) error {
|
||||
user, err := u.loadPostgresqlUser(req.Database, req.Username)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if user.Protected {
|
||||
return buserr.New("ErrPgUserProtected")
|
||||
}
|
||||
if err := checkPostgresqlUserUsage(req.Database, req.Username, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(user.Databases) != 0 {
|
||||
return buserr.New("ErrPgUserBound")
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
if err := cli.Delete(client.DeleteInfo{Username: req.Username, Timeout: 300}); err != nil {
|
||||
return err
|
||||
}
|
||||
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(req.Database))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, db := range dbs {
|
||||
if db.Username == req.Username {
|
||||
if err := postgresqlRepo.Update(db.ID, map[string]interface{}{"username": "", "password": "", "super_user": false}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return databaseUserRepo.Delete(repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database), databaseUserRepo.WithByUser(req.Username, ""))
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) GrantUser(req dto.PostgresqlUserGrant) error {
|
||||
user, err := u.loadPostgresqlUser(req.Database, req.Username)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if user.Protected {
|
||||
return buserr.New("ErrPgUserProtected")
|
||||
}
|
||||
if user.SuperUser {
|
||||
return buserr.New("ErrPgSuperUserGrant")
|
||||
}
|
||||
db, err := postgresqlRepo.Get(postgresqlRepo.WithByPostgresqlName(req.Database), repo.WithByName(req.Name))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
if err := client.GrantUser(cli, req.Name, req.Username, false); err != nil {
|
||||
return err
|
||||
}
|
||||
if db.Username == "" {
|
||||
password, err := encrypt.StringEncrypt(user.Password)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return postgresqlRepo.Update(db.ID, map[string]interface{}{"username": req.Username, "password": password, "super_user": false})
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) RevokeUser(req dto.PostgresqlUserGrant) error {
|
||||
user, err := u.loadPostgresqlUser(req.Database, req.Username)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if user.Protected {
|
||||
return buserr.New("ErrPgUserProtected")
|
||||
}
|
||||
if user.SuperUser {
|
||||
return buserr.New("ErrPgSuperUserGrant")
|
||||
}
|
||||
db, err := postgresqlRepo.Get(postgresqlRepo.WithByPostgresqlName(req.Database), repo.WithByName(req.Name))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := checkPostgresqlUserUsage(req.Database, req.Username, req.Name); err != nil {
|
||||
return err
|
||||
}
|
||||
cli, err := LoadPostgresqlClientByFrom(req.Database)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cli.Close()
|
||||
if err := saveDatabaseUserCredential("postgresql", req.Database, req.Username, "", user.Password, user.Description); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := client.GrantUser(cli, req.Name, req.Username, true); err != nil {
|
||||
return err
|
||||
}
|
||||
if db.Username == req.Username {
|
||||
return postgresqlRepo.Update(db.ID, map[string]interface{}{"username": "", "password": "", "super_user": false})
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (u *PostgresqlService) loadPostgresqlUser(database, username string) (dto.PostgresqlUser, error) {
|
||||
users, err := u.ListUsers(dto.PostgresqlUserSearch{Database: database})
|
||||
if err != nil {
|
||||
return dto.PostgresqlUser{}, err
|
||||
}
|
||||
for _, user := range users {
|
||||
if user.Username == username {
|
||||
return user, nil
|
||||
}
|
||||
}
|
||||
return dto.PostgresqlUser{}, buserr.New("ErrRecordNotFound")
|
||||
}
|
||||
|
||||
func loadPostgresqlUserApps(database, username, dbName string) ([]model.AppInstall, error) {
|
||||
instance, err := databaseRepo.Get(repo.WithByName(database))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(database))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ids := make([]uint, 0, len(dbs))
|
||||
for _, db := range dbs {
|
||||
if dbName == "" || db.Name == dbName {
|
||||
ids = append(ids, db.ID)
|
||||
}
|
||||
}
|
||||
if len(ids) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
opts := []repo.DBOption{appInstallResourceRepo.WithResourceIds(ids), appRepo.WithKey(instance.Type)}
|
||||
if instance.From == "local" {
|
||||
app, err := appInstallRepo.LoadBaseInfo(instance.Type, database)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
opts = append(opts, appInstallResourceRepo.WithLinkId(app.ID))
|
||||
}
|
||||
resources, err := appInstallResourceRepo.GetBy(opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
appIDs := make([]uint, 0, len(resources))
|
||||
for _, resource := range resources {
|
||||
appIDs = append(appIDs, resource.AppInstallId)
|
||||
}
|
||||
if len(appIDs) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
apps, err := appInstallRepo.ListBy(context.Background(), repo.WithByIDs(appIDs))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
result := make([]model.AppInstall, 0, len(apps))
|
||||
for _, app := range apps {
|
||||
var env map[string]interface{}
|
||||
if err := json.Unmarshal([]byte(app.Env), &env); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if env["PANEL_DB_USER"] == username {
|
||||
result = append(result, app)
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func checkPostgresqlUserUsage(database, username, dbName string) error {
|
||||
apps, err := loadPostgresqlUserApps(database, username, dbName)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(apps) != 0 {
|
||||
return buserr.New("ErrPgUserUsed")
|
||||
}
|
||||
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(database))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
websites, err := websiteRepo.List(websiteRepo.WithDBTypes([]string{constant.AppPostgresql, constant.AppPostgresqlCluster}))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, db := range dbs {
|
||||
if db.Username != username || (dbName != "" && db.Name != dbName) {
|
||||
continue
|
||||
}
|
||||
for _, website := range websites {
|
||||
if website.DbID == db.ID {
|
||||
return buserr.New("ErrPgUserUsed")
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -2790,6 +2790,78 @@
|
||||
"formatZH": "创建 postgresql 数据库 [name]",
|
||||
"formatEN": "create postgresql database [name]"
|
||||
},
|
||||
"/databases/pg/users": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "创建 PostgreSQL 实例 [database] 用户 [username]",
|
||||
"formatEN": "create PostgreSQL instance [database] user [username]"
|
||||
},
|
||||
"/databases/pg/users/update": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "修改 PostgreSQL 实例 [database] 用户 [username]",
|
||||
"formatEN": "update PostgreSQL instance [database] user [username]"
|
||||
},
|
||||
"/databases/pg/users/password/save": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "补充 PostgreSQL 实例 [database] 用户 [username] 密码",
|
||||
"formatEN": "save PostgreSQL instance [database] user [username] password locally"
|
||||
},
|
||||
"/databases/pg/users/password": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "修改 PostgreSQL 实例 [database] 用户 [username] 密码",
|
||||
"formatEN": "change PostgreSQL instance [database] user [username] password"
|
||||
},
|
||||
"/databases/pg/users/del": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "删除 PostgreSQL 实例 [database] 用户 [username]",
|
||||
"formatEN": "delete PostgreSQL instance [database] user [username]"
|
||||
},
|
||||
"/databases/pg/grants": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username",
|
||||
"name"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "绑定 PostgreSQL 实例 [database] 数据库 [name] 用户 [username]",
|
||||
"formatEN": "bind PostgreSQL instance [database] database [name] user [username]"
|
||||
},
|
||||
"/databases/pg/grants/del": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username",
|
||||
"name"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "撤销 PostgreSQL 实例 [database] 数据库 [name] 用户 [username] 绑定",
|
||||
"formatEN": "revoke PostgreSQL instance [database] database [name] user [username] binding"
|
||||
},
|
||||
"/databases/pg/bind": {
|
||||
"bodyKeys": [
|
||||
"name",
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# base errors
|
||||
ErrInvalidParams: 'Bad request: {{ .detail }}'
|
||||
ErrInvalidParams: 'Bad request{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'Invalid MCP custom argument format'
|
||||
ErrMcpGatewayArgsConflict: 'Argument {{ .name }} is managed by 1Panel and cannot be set in custom arguments'
|
||||
ErrTokenParse: 'Token error: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: 'Start local DB container with image {{ .name }} before backing up
|
||||
RemoteRecover: 'Start local DB container with image {{ .name }} before restoring remote DB'
|
||||
Arg: "Argument"
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "System users and the current connection user are protected from this operation"
|
||||
ErrPgSuperUserGrant: "Superusers can access all databases and do not require individual grants or revocations"
|
||||
ErrPgUserUsed: "This user is used by linked applications or websites; update their connection accounts first"
|
||||
ErrPgUserBound: "Revoke this user's database authorizations first"
|
||||
ErrPgUserPasswordSync: "The user password was changed, but password synchronization failed for these applications: {{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: 'Backup file type does not match current persistence mode'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# errores básicos
|
||||
ErrInvalidParams: 'Solicitud inválida: {{ .detail }}'
|
||||
ErrInvalidParams: 'Solicitud inválida{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'Formato de argumentos personalizados de MCP no válido'
|
||||
ErrMcpGatewayArgsConflict: 'El argumento {{ .name }} está gestionado por 1Panel y no puede definirse en los argumentos personalizados'
|
||||
ErrTokenParse: 'Token inválido: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: 'Para hacer una copia de seguridad de la base de datos remota, pri
|
||||
RemoteRecover: 'Para restaurar la base de datos remota, primero debe iniciarse el servicio de base de datos del contenedor local utilizando la imagen {{ .name }}, espere...'
|
||||
Arg: 'Argumento'
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "Los usuarios del sistema y el usuario de conexión actual están protegidos frente a esta operación"
|
||||
ErrPgSuperUserGrant: "Los superusuarios acceden a todas las bases de datos y no requieren autorizaciones ni revocaciones individuales"
|
||||
ErrPgUserUsed: "Las aplicaciones o sitios web vinculados usan este usuario; cambie primero sus cuentas de conexión"
|
||||
ErrPgUserBound: "Primero revoque las autorizaciones de base de datos de este usuario"
|
||||
ErrPgUserPasswordSync: "La contraseña del usuario se cambió, pero no se pudo sincronizar en estas aplicaciones: {{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: 'El tipo de archivo de recuperación no coincide con el método de persistencia actual, modifíquelo e intente'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# خطاهای پایه
|
||||
ErrInvalidParams: 'درخواست نامعتبر: {{ .detail }}'
|
||||
ErrInvalidParams: 'درخواست نامعتبر{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'قالب آرگومانهای سفارشی MCP نامعتبر است'
|
||||
ErrMcpGatewayArgsConflict: 'آرگومان {{ .name }} توسط 1Panel مدیریت میشود و نمیتوان آن را در آرگومانهای سفارشی تنظیم کرد'
|
||||
ErrTokenParse: 'خطا در توکن: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: 'قبل از پشتیبانگیری از پایگاه داده
|
||||
RemoteRecover: 'قبل از بازیابی پایگاه داده از راه دور، کانتینر پایگاه داده محلی را با تصویر {{ .name }} راهاندازی کنید'
|
||||
Arg: "آرگومان"
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "کاربران سیستم و کاربر اتصال فعلی در برابر این عملیات محافظت میشوند"
|
||||
ErrPgSuperUserGrant: "ابرکاربران به همه پایگاههای داده دسترسی دارند و نیازی به اعطا یا لغو مجوز جداگانه ندارند"
|
||||
ErrPgUserUsed: "برنامهها یا وبسایتهای پیوندشده از این کاربر استفاده میکنند؛ ابتدا حساب اتصال را تغییر دهید"
|
||||
ErrPgUserBound: "ابتدا مجوزهای پایگاه داده این کاربر را لغو کنید"
|
||||
ErrPgUserPasswordSync: "گذرواژه کاربر تغییر کرد، اما همگامسازی گذرواژه برای این برنامهها ناموفق بود: {{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: 'نوع فایل پشتیبان با حالت ماندگاری فعلی مطابقت ندارد'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# 基本エラー
|
||||
ErrInvalidParams: '不正なリクエスト: {{ .detail }}'
|
||||
ErrInvalidParams: '不正なリクエスト{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'MCP カスタム引数の形式が正しくありません'
|
||||
ErrMcpGatewayArgsConflict: '引数 {{ .name }} は 1Panel によって管理されているため、カスタム引数には設定できません'
|
||||
ErrTokenParse: 'トークンエラー: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: 'リモートデータベースをバックアップするには
|
||||
RemoteRecover: 'リモートデータベースを復元するには、まずイメージ {{ .name }} を使用してローカルコンテナデータベースサービスを起動する必要があります。しばらくお待ちください...'
|
||||
Arg: '引数'
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "システムユーザーと現在の接続ユーザーは保護されているため、この操作は実行できません"
|
||||
ErrPgSuperUserGrant: "スーパーユーザーは全データベースにアクセスでき、個別の権限付与や取り消しは不要です"
|
||||
ErrPgUserUsed: "関連アプリまたはウェブサイトがこのユーザーを使用しています。先に接続アカウントを変更してください"
|
||||
ErrPgUserBound: "先にこのユーザーのデータベース権限を取り消してください"
|
||||
ErrPgUserPasswordSync: "ユーザーのパスワードは変更されましたが、次のアプリへのパスワード同期に失敗しました:{{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: 'リカバリ ファイルの種類が現在の永続化方法と一致しません。変更して再試行してください'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# 기본 오류
|
||||
ErrInvalidParams: '잘못된 요청: {{ .detail }}'
|
||||
ErrInvalidParams: '잘못된 요청{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'MCP 사용자 지정 인수 형식이 잘못되었습니다'
|
||||
ErrMcpGatewayArgsConflict: '{{ .name }} 인수는 1Panel에서 관리하므로 사용자 지정 인수에 설정할 수 없습니다'
|
||||
ErrTokenParse: '토큰 오류: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: '원격 데이터베이스를 백업하려면 먼저 이미지 {{
|
||||
RemoteRecover: '원격 데이터베이스를 복원하려면 먼저 이미지 {{ .name }}을(를) 사용하여 로컬 컨테이너 데이터베이스 서비스를 시작해야 합니다. 잠시만 기다려 주세요...'
|
||||
Arg: '인수'
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "시스템 사용자와 현재 연결 사용자는 보호되어 이 작업을 수행할 수 없습니다"
|
||||
ErrPgSuperUserGrant: "슈퍼유저는 모든 데이터베이스에 접근할 수 있어 개별 권한 부여나 철회가 필요하지 않습니다"
|
||||
ErrPgUserUsed: "연결된 앱 또는 웹사이트가 이 사용자를 사용 중입니다. 먼저 연결 계정을 변경하세요"
|
||||
ErrPgUserBound: "먼저 이 사용자의 데이터베이스 권한을 철회하세요"
|
||||
ErrPgUserPasswordSync: "사용자 비밀번호는 변경되었지만 다음 앱의 비밀번호 동기화에 실패했습니다: {{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: '복구 파일 유형이 현재 지속성 방법과 일치하지 않습니다. 수정하고 다시 시도하세요'
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
ErrInvalidParams: 'ຄຳຮ້ອງຂໍບໍ່ຖືກຕ້ອງ: {{ .detail }}'
|
||||
ErrInvalidParams: 'ຄຳຮ້ອງຂໍບໍ່ຖືກຕ້ອງ{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'ຮູບແບບອາກິວເມັນ MCP ກຳນົດເອງບໍ່ຖືກຕ້ອງ'
|
||||
ErrMcpGatewayArgsConflict: 'ອາກິວເມັນ {{ .name }} ຖືກຈັດການໂດຍ 1Panel ແລະ ບໍ່ສາມາດຕັ້ງຄ່າໃນອາກິວເມັນກຳນົດເອງໄດ້'
|
||||
ErrTokenParse: 'ໂທເຄັນຜິດພາດ: {{ .detail }}'
|
||||
@@ -282,6 +282,13 @@ RemoteBackup: 'ກະລຸນາເລີ່ມຄອນເທນເນີຖ
|
||||
RemoteRecover: 'ກະລຸນາເລີ່ມຄອນເທນເນີຖານຂໍ້ມູນພາຍໃນເຄື່ອງດ້ວຍຮູບພາບ {{ .name }} ກ່ອນທີ່ຈະກູ້ຄືນຖານຂໍ້ມູນທາງໄກ'
|
||||
Arg: "ອາກິວເມນ"
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "ຜູ້ໃຊ້ລະບົບແລະຜູ້ໃຊ້ເຊື່ອມຕໍ່ປັດຈຸບັນຖືກປົກປ້ອງຈາກການດຳເນີນການນີ້"
|
||||
ErrPgSuperUserGrant: "ຜູ້ໃຊ້ຂັ້ນສູງເຂົ້າເຖິງທຸກຖານຂໍ້ມູນໄດ້ ໂດຍບໍ່ຕ້ອງໃຫ້ສິດຫຼືຍົກເລີກສິດແຍກຕ່າງຫາກ"
|
||||
ErrPgUserUsed: "ແອັບຫຼືເວັບໄຊທີ່ຜູກຢູ່ກຳລັງໃຊ້ຜູ້ໃຊ້ນີ້; ກະລຸນາປ່ຽນບັນຊີເຊື່ອມຕໍ່ກ່ອນ"
|
||||
ErrPgUserBound: "ກະລຸນາຍົກເລີກສິດຖານຂໍ້ມູນຂອງຜູ້ໃຊ້ນີ້ກ່ອນ"
|
||||
ErrPgUserPasswordSync: "ລະຫັດຜ່ານຜູ້ໃຊ້ຖືກປ່ຽນແລ້ວ ແຕ່ການຊິງລະຫັດຜ່ານໃຫ້ແອັບຕໍ່ໄປນີ້ລົ້ມເຫຼວ: {{ .detail }}"
|
||||
|
||||
#redis
|
||||
ErrTypeOfRedis: 'ປະເພດໄຟລ໌ສຳຮອງຂໍ້ມູນບໍ່ກົງກັບໂໝດ persistence ປັດຈຸບັນ'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# ralat asas
|
||||
ErrInvalidParams: 'Permintaan tidak sah: {{ .detail }}'
|
||||
ErrInvalidParams: 'Permintaan tidak sah{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'Format argumen tersuai MCP tidak sah'
|
||||
ErrMcpGatewayArgsConflict: 'Argumen {{ .name }} diurus oleh 1Panel dan tidak boleh ditetapkan dalam argumen tersuai'
|
||||
ErrTokenParse: 'Token tidak sah: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: 'Untuk menyandarkan pangkalan data jauh, perkhidmatan pangkalan da
|
||||
RemoteRecover: 'Untuk memulihkan pangkalan data jauh, perkhidmatan pangkalan data bekas tempatan perlu dimulakan terlebih dahulu menggunakan imej {{ .name }}, sila tunggu...'
|
||||
Arg: 'Hujah'
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "Pengguna sistem dan pengguna sambungan semasa dilindungi daripada operasi ini"
|
||||
ErrPgSuperUserGrant: "Pengguna super boleh mengakses semua pangkalan data dan tidak memerlukan pemberian atau pembatalan kebenaran individu"
|
||||
ErrPgUserUsed: "Aplikasi atau laman web terpaut menggunakan pengguna ini; tukar akaun sambungan dahulu"
|
||||
ErrPgUserBound: "Batalkan kebenaran pangkalan data pengguna ini dahulu"
|
||||
ErrPgUserPasswordSync: "Kata laluan pengguna telah diubah, tetapi penyegerakan kata laluan gagal untuk aplikasi berikut: {{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: 'Jenis fail pemulihan tidak sepadan dengan kaedah kegigihan semasa, sila ubah suai dan cuba lagi'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# erros básicos
|
||||
ErrInvalidParams: 'Requisição inválida: {{ .detail }}'
|
||||
ErrInvalidParams: 'Requisição inválida{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'Formato inválido dos argumentos personalizados do MCP'
|
||||
ErrMcpGatewayArgsConflict: 'O argumento {{ .name }} é gerenciado pelo 1Panel e não pode ser definido nos argumentos personalizados'
|
||||
ErrTokenParse: 'Erro de token: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: 'Para fazer backup do banco de dados remoto, o serviço de banco d
|
||||
RemoteRecover: 'Para restaurar o banco de dados remoto, o serviço de banco de dados do contêiner local precisa ser iniciado primeiro usando a imagem {{ .name }} aguarde...'
|
||||
Arg: 'Argumento'
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "Usuários do sistema e o usuário da conexão atual estão protegidos contra esta operação"
|
||||
ErrPgSuperUserGrant: "Superusuários acessam todos os bancos de dados e não precisam de concessões ou revogações individuais"
|
||||
ErrPgUserUsed: "Aplicativos ou sites vinculados usam este usuário; altere primeiro suas contas de conexão"
|
||||
ErrPgUserBound: "Primeiro revogue as autorizações de banco de dados deste usuário"
|
||||
ErrPgUserPasswordSync: "A senha do usuário foi alterada, mas a sincronização falhou nestes aplicativos: {{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: 'O tipo de arquivo de recuperação não corresponde ao método de persistência atual, modifique-o e'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# базовые ошибки
|
||||
ErrInvalidParams: 'Неверный запрос: {{ .detail }}'
|
||||
ErrInvalidParams: 'Неверный запрос{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'Неверный формат пользовательских аргументов MCP'
|
||||
ErrMcpGatewayArgsConflict: 'Аргумент {{ .name }} управляется 1Panel и не может быть задан в пользовательских аргументах'
|
||||
ErrTokenParse: 'Ошибка токена: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: 'Для резервного копирования удаленн
|
||||
RemoteRecover: 'Для восстановления удаленной базы данных необходимо сначала запустить службу базы данных локального контейнера с помощью образа {{ .name }}, пожалуйста, подождите...'
|
||||
Arg: 'Аргумент'
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "Системные пользователи и пользователь текущего подключения защищены от этой операции"
|
||||
ErrPgSuperUserGrant: "Суперпользователи имеют доступ ко всем базам данных и не требуют отдельной выдачи или отзыва прав"
|
||||
ErrPgUserUsed: "Пользователь используется связанными приложениями или сайтами; сначала измените их учётные записи подключения"
|
||||
ErrPgUserBound: "Сначала отзовите права этого пользователя на базы данных"
|
||||
ErrPgUserPasswordSync: "Пароль пользователя изменён, но синхронизация пароля со следующими приложениями не удалась: {{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: 'Тип файла восстановления не соответствует текущему методу сохранения. Измените его и повторите попытку'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# temel hatalar
|
||||
ErrInvalidParams: 'İstek geçersiz: {{ .detail }}'
|
||||
ErrInvalidParams: 'İstek geçersiz{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'MCP özel bağımsız değişken biçimi geçersiz'
|
||||
ErrMcpGatewayArgsConflict: '{{ .name }} bağımsız değişkeni 1Panel tarafından yönetilir ve özel bağımsız değişkenlerde ayarlanamaz'
|
||||
ErrTokenParse: 'Token hatası: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: 'Uzak veritabanını yedeklemek için önce {{ .name }} görüntü
|
||||
RemoteRecover: 'Uzak veritabanını geri yüklemek için önce {{ .name }} görüntüsü kullanılarak yerel konteyner veritabanı hizmetinin başlatılması gerekiyor, lütfen bekleyin...'
|
||||
Arg: 'Argüman'
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "Sistem kullanıcıları ve mevcut bağlantı kullanıcısı bu işleme karşı korunur"
|
||||
ErrPgSuperUserGrant: "Süper kullanıcılar tüm veritabanlarına erişebilir; ayrı yetki verme veya iptal işlemi gerektirmez"
|
||||
ErrPgUserUsed: "Bağlı uygulamalar veya web siteleri bu kullanıcıyı kullanıyor; önce bağlantı hesaplarını değiştirin"
|
||||
ErrPgUserBound: "Önce bu kullanıcının veritabanı yetkilerini iptal edin"
|
||||
ErrPgUserPasswordSync: "Kullanıcı parolası değiştirildi ancak şu uygulamalarda parola eşitlemesi başarısız oldu: {{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: 'Kurtarma dosyası türü mevcut kalıcılık yöntemiyle eşleşmiyor, lütfen değiştirin ve tekrar deneyin'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# 基礎錯誤
|
||||
ErrInvalidParams: '請求參數錯誤: {{ .detail }}'
|
||||
ErrInvalidParams: '請求參數錯誤{{ if .detail }}: {{ .detail }}{{ end }}'
|
||||
ErrMcpGatewayArgsParse: 'MCP 自訂參數格式錯誤'
|
||||
ErrMcpGatewayArgsConflict: '參數 {{ .name }} 由 1Panel 管理,不能在自訂參數中設定'
|
||||
ErrTokenParse: 'Token 產生錯誤: {{ .detail }}'
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: '備份遠端資料庫需要先使用映像 {{ .name }} 啟動本
|
||||
RemoteRecover: '復原遠端資料庫需要先使用映像 {{ .name }} 啟動本機容器資料庫服務,請稍候...'
|
||||
Arg: '參數'
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "系統使用者或目前連線使用者受到保護,無法執行此操作"
|
||||
ErrPgSuperUserGrant: "超級使用者可存取所有資料庫,無需單獨授權或撤銷授權"
|
||||
ErrPgUserUsed: "關聯應用程式或網站正在使用此使用者,請先調整連線帳號"
|
||||
ErrPgUserBound: "請先撤銷此使用者的資料庫授權"
|
||||
ErrPgUserPasswordSync: "使用者密碼已修改,但以下應用程式的密碼同步失敗:{{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: '復原檔案類型與目前持久化方式不符,請修改後重試'
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# 基础错误
|
||||
ErrInvalidParams: "参数错误: {{ .detail }}"
|
||||
ErrInvalidParams: "参数错误{{ if .detail }}: {{ .detail }}{{ end }}"
|
||||
ErrMcpGatewayArgsParse: "MCP 自定义参数格式错误"
|
||||
ErrMcpGatewayArgsConflict: "参数 {{ .name }} 由 1Panel 管理,不能在自定义参数中设置"
|
||||
ErrTokenParse: "Token 错误: {{ .detail }}"
|
||||
@@ -292,6 +292,13 @@ RemoteBackup: "备份远程数据库前需先用镜像 {{ .name }} 启动本地
|
||||
RemoteRecover: "恢复远程数据库前需先用镜像 {{ .name }} 启动本地容器数据库服务,请稍候"
|
||||
Arg: "参数"
|
||||
|
||||
#PostgreSQL
|
||||
ErrPgUserProtected: "系统用户或当前连接用户受保护,无法执行此操作"
|
||||
ErrPgSuperUserGrant: "超级用户可访问所有数据库,无需单独授权或撤销授权"
|
||||
ErrPgUserUsed: "该用户正在被关联应用或网站使用,请先调整连接账号"
|
||||
ErrPgUserBound: "请先撤销该用户的数据库授权"
|
||||
ErrPgUserPasswordSync: "用户密码已修改,但以下应用的密码同步失败:{{ .detail }}"
|
||||
|
||||
# Redis
|
||||
ErrTypeOfRedis: "恢复文件类型与当前持久化方式不符,请修改后重试"
|
||||
|
||||
|
||||
@@ -58,6 +58,14 @@ func (s *DatabaseRouter) InitRouter(Router *gin.RouterGroup) {
|
||||
cmdRouter.POST("/db/del/check", baseApi.DeleteCheckDatabase)
|
||||
cmdRouter.POST("/db/del", baseApi.DeleteDatabase)
|
||||
|
||||
cmdRouter.POST("/pg/users/search", baseApi.ListPostgresqlUsers)
|
||||
cmdRouter.POST("/pg/users", baseApi.CreatePostgresqlUser)
|
||||
cmdRouter.POST("/pg/users/update", baseApi.UpdatePostgresqlUser)
|
||||
cmdRouter.POST("/pg/users/password", baseApi.ChangePostgresqlUserPassword)
|
||||
cmdRouter.POST("/pg/users/password/save", baseApi.SavePostgresqlUserPassword)
|
||||
cmdRouter.POST("/pg/users/del", baseApi.DeletePostgresqlUser)
|
||||
cmdRouter.POST("/pg/grants", baseApi.GrantPostgresqlUser)
|
||||
cmdRouter.POST("/pg/grants/del", baseApi.RevokePostgresqlUser)
|
||||
cmdRouter.POST("/pg", baseApi.CreatePostgresql)
|
||||
cmdRouter.POST("/pg/search", baseApi.SearchPostgresql)
|
||||
cmdRouter.POST("/pg/:database/load", baseApi.LoadPostgresqlDBFromRemote)
|
||||
|
||||
@@ -14,6 +14,8 @@ import (
|
||||
)
|
||||
|
||||
type PostgresqlClient interface {
|
||||
ExecSQL(command string, timeout uint) error
|
||||
ExecSQLForRows(command string, timeout uint) ([]string, error)
|
||||
Create(info client.CreateInfo) error
|
||||
CreateUser(info client.CreateInfo, withDeleteDB bool) error
|
||||
Delete(info client.DeleteInfo) error
|
||||
@@ -28,7 +30,7 @@ type PostgresqlClient interface {
|
||||
|
||||
func NewPostgresqlClient(conn client.DBInfo) (PostgresqlClient, error) {
|
||||
if conn.From == "local" {
|
||||
connArgs := []string{"exec", "-e", fmt.Sprintf("PGPASSWORD=%s", conn.Password), conn.Address, "psql", "-t", "-U", conn.Username, "-c"}
|
||||
connArgs := []string{"exec", "-e", fmt.Sprintf("PGPASSWORD=%s", conn.Password), conn.Address, "psql", "-A", "-t", "-U", conn.Username, "-c"}
|
||||
return client.NewLocal(connArgs, conn.Address, conn.Username, conn.Password, conn.Database), nil
|
||||
}
|
||||
escapedUsername := url.QueryEscape(conn.Username)
|
||||
@@ -45,6 +47,7 @@ func NewPostgresqlClient(conn client.DBInfo) (PostgresqlClient, error) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(conn.Timeout)*time.Second)
|
||||
defer cancel()
|
||||
if err := db.PingContext(ctx); err != nil {
|
||||
_ = db.Close()
|
||||
return nil, err
|
||||
}
|
||||
if errors.Is(ctx.Err(), context.DeadlineExceeded) {
|
||||
|
||||
@@ -19,10 +19,11 @@ type DBInfo struct {
|
||||
}
|
||||
|
||||
type CreateInfo struct {
|
||||
Name string `json:"name"`
|
||||
Username string `json:"userName"`
|
||||
Password string `json:"password"`
|
||||
SuperUser bool `json:"superUser"`
|
||||
ExistingUser bool `json:"existingUser"`
|
||||
Name string `json:"name"`
|
||||
Username string `json:"userName"`
|
||||
Password string `json:"password"`
|
||||
SuperUser bool `json:"superUser"`
|
||||
|
||||
Timeout uint `json:"timeout"` // second
|
||||
}
|
||||
|
||||
@@ -31,19 +31,26 @@ func NewLocal(command []string, containerName, username, password, database stri
|
||||
}
|
||||
|
||||
func (r *Local) Create(info CreateInfo) error {
|
||||
createSql := fmt.Sprintf("CREATE DATABASE \"%s\"", info.Name)
|
||||
if err := r.ExecSQL(createSql, info.Timeout); err != nil {
|
||||
if err := r.ExecSQL("CREATE DATABASE "+QuoteIdentifier(info.Name), info.Timeout); err != nil {
|
||||
if strings.Contains(strings.ToLower(err.Error()), "already exists") {
|
||||
return buserr.New("ErrDatabaseIsExist")
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
if err := r.CreateUser(info, true); err != nil {
|
||||
_ = r.ExecSQL(fmt.Sprintf("DROP DATABASE \"%s\"", info.Name), info.Timeout)
|
||||
var err error
|
||||
if info.ExistingUser {
|
||||
if !info.SuperUser {
|
||||
err = GrantUser(r, info.Name, info.Username, false)
|
||||
}
|
||||
} else {
|
||||
err = r.CreateUser(info, false)
|
||||
}
|
||||
if err != nil {
|
||||
if cleanupErr := r.ExecSQL("DROP DATABASE "+QuoteIdentifier(info.Name), info.Timeout); cleanupErr != nil {
|
||||
return fmt.Errorf("%w; cleanup database: %v", err, cleanupErr)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -52,48 +59,30 @@ func (r *Local) ChangePrivileges(info Privileges) error {
|
||||
if !info.SuperUser {
|
||||
super = "NOSUPERUSER"
|
||||
}
|
||||
changeSql := fmt.Sprintf("ALTER USER \"%s\" WITH %s", info.Username, super)
|
||||
changeSql := "ALTER USER " + QuoteIdentifier(info.Username) + " WITH " + super
|
||||
return r.ExecSQL(changeSql, info.Timeout)
|
||||
}
|
||||
|
||||
func (r *Local) CreateUser(info CreateInfo, withDeleteDB bool) error {
|
||||
createSql := fmt.Sprintf("CREATE USER \"%s\" WITH PASSWORD '%s'", info.Username, info.Password)
|
||||
if err := r.ExecSQL(createSql, info.Timeout); err != nil {
|
||||
privileges := "NOSUPERUSER"
|
||||
if info.SuperUser {
|
||||
privileges = "SUPERUSER"
|
||||
}
|
||||
statement := "CREATE USER " + QuoteIdentifier(info.Username) + " WITH " + privileges + " PASSWORD " + QuoteLiteral(info.Password)
|
||||
if err := r.ExecSQL(statement, info.Timeout); err != nil {
|
||||
if strings.Contains(strings.ToLower(err.Error()), "already exists") {
|
||||
return buserr.New("ErrUserIsExist")
|
||||
}
|
||||
if withDeleteDB {
|
||||
_ = r.Delete(DeleteInfo{
|
||||
Name: info.Name,
|
||||
Username: info.Username,
|
||||
ForceDelete: true,
|
||||
Timeout: 300})
|
||||
}
|
||||
return err
|
||||
}
|
||||
if info.SuperUser {
|
||||
if err := r.ChangePrivileges(Privileges{SuperUser: true, Username: info.Username, Timeout: info.Timeout}); err != nil {
|
||||
if withDeleteDB {
|
||||
_ = r.Delete(DeleteInfo{
|
||||
Name: info.Name,
|
||||
Username: info.Username,
|
||||
ForceDelete: true,
|
||||
Timeout: 300})
|
||||
if info.Name != "" && !info.SuperUser {
|
||||
if err := GrantUser(r, info.Name, info.Username, false); err != nil {
|
||||
if cleanupErr := r.ExecSQL("DROP USER "+QuoteIdentifier(info.Username), info.Timeout); cleanupErr != nil {
|
||||
return fmt.Errorf("%w; cleanup user: %v", err, cleanupErr)
|
||||
}
|
||||
return err
|
||||
}
|
||||
}
|
||||
grantStr := fmt.Sprintf("GRANT ALL PRIVILEGES ON DATABASE \"%s\" TO \"%s\"", info.Name, info.Username)
|
||||
if err := r.ExecSQL(grantStr, info.Timeout); err != nil {
|
||||
if withDeleteDB {
|
||||
_ = r.Delete(DeleteInfo{
|
||||
Name: info.Name,
|
||||
Username: info.Username,
|
||||
ForceDelete: true,
|
||||
Timeout: 300})
|
||||
}
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -106,12 +95,15 @@ func (r *Local) Delete(info DeleteInfo) error {
|
||||
if inUse && !info.ForceDelete {
|
||||
return buserr.WithDetail("ErrInUsed", info.Name, nil)
|
||||
}
|
||||
dropSql := fmt.Sprintf("DROP DATABASE \"%s\"", info.Name)
|
||||
dropSql := "DROP DATABASE " + QuoteIdentifier(info.Name)
|
||||
if err := r.ExecSQL(dropSql, info.Timeout); err != nil && !info.ForceDelete {
|
||||
return fmt.Errorf("drop database failed, err: %v", err)
|
||||
}
|
||||
}
|
||||
dropSql := fmt.Sprintf("DROP USER \"%s\"", info.Username)
|
||||
if info.Username == "" {
|
||||
return nil
|
||||
}
|
||||
dropSql := "DROP USER " + QuoteIdentifier(info.Username)
|
||||
if err := r.ExecSQL(dropSql, info.Timeout); err != nil && !info.ForceDelete {
|
||||
return fmt.Errorf("drop user failed, err: %v", err)
|
||||
}
|
||||
@@ -119,7 +111,7 @@ func (r *Local) Delete(info DeleteInfo) error {
|
||||
}
|
||||
|
||||
func (r *Local) ChangePassword(info PasswordChangeInfo) error {
|
||||
changeSql := fmt.Sprintf("ALTER USER \"%s\" WITH PASSWORD '%s'", info.Username, info.Password)
|
||||
changeSql := "ALTER USER " + QuoteIdentifier(info.Username) + " WITH PASSWORD " + QuoteLiteral(info.Password)
|
||||
if err := r.ExecSQL(changeSql, info.Timeout); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -70,58 +70,49 @@ func NewRemote(db Remote) *Remote {
|
||||
return &db
|
||||
}
|
||||
func (r *Remote) Create(info CreateInfo) error {
|
||||
createSql := fmt.Sprintf("CREATE DATABASE \"%s\"", info.Name)
|
||||
if err := r.ExecSQL(createSql, info.Timeout); err != nil {
|
||||
if err := r.ExecSQL("CREATE DATABASE "+QuoteIdentifier(info.Name), info.Timeout); err != nil {
|
||||
if strings.Contains(strings.ToLower(err.Error()), "already exists") {
|
||||
return buserr.New("ErrDatabaseIsExist")
|
||||
}
|
||||
return err
|
||||
}
|
||||
if err := r.CreateUser(info, true); err != nil {
|
||||
var err error
|
||||
if info.ExistingUser {
|
||||
if !info.SuperUser {
|
||||
err = GrantUser(r, info.Name, info.Username, false)
|
||||
}
|
||||
} else {
|
||||
err = r.CreateUser(info, false)
|
||||
}
|
||||
if err != nil {
|
||||
if cleanupErr := r.ExecSQL("DROP DATABASE "+QuoteIdentifier(info.Name), info.Timeout); cleanupErr != nil {
|
||||
return fmt.Errorf("%w; cleanup database: %v", err, cleanupErr)
|
||||
}
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Remote) CreateUser(info CreateInfo, withDeleteDB bool) error {
|
||||
createSql := fmt.Sprintf("CREATE USER \"%s\" WITH PASSWORD '%s'", info.Username, info.Password)
|
||||
if err := r.ExecSQL(createSql, info.Timeout); err != nil {
|
||||
privileges := "NOSUPERUSER"
|
||||
if info.SuperUser {
|
||||
privileges = "SUPERUSER"
|
||||
}
|
||||
statement := "CREATE USER " + QuoteIdentifier(info.Username) + " WITH " + privileges + " PASSWORD " + QuoteLiteral(info.Password)
|
||||
if err := r.ExecSQL(statement, info.Timeout); err != nil {
|
||||
if strings.Contains(strings.ToLower(err.Error()), "already exists") {
|
||||
return buserr.New("ErrUserIsExist")
|
||||
}
|
||||
if withDeleteDB {
|
||||
_ = r.Delete(DeleteInfo{
|
||||
Name: info.Name,
|
||||
Username: info.Username,
|
||||
ForceDelete: true,
|
||||
Timeout: 300})
|
||||
}
|
||||
return err
|
||||
}
|
||||
if info.SuperUser {
|
||||
if err := r.ChangePrivileges(Privileges{SuperUser: true, Username: info.Username, Timeout: info.Timeout}); err != nil {
|
||||
if withDeleteDB {
|
||||
_ = r.Delete(DeleteInfo{
|
||||
Name: info.Name,
|
||||
Username: info.Username,
|
||||
ForceDelete: true,
|
||||
Timeout: 300})
|
||||
if info.Name != "" && !info.SuperUser {
|
||||
if err := GrantUser(r, info.Name, info.Username, false); err != nil {
|
||||
if cleanupErr := r.ExecSQL("DROP USER "+QuoteIdentifier(info.Username), info.Timeout); cleanupErr != nil {
|
||||
return fmt.Errorf("%w; cleanup user: %v", err, cleanupErr)
|
||||
}
|
||||
return err
|
||||
}
|
||||
}
|
||||
grantSql := fmt.Sprintf("GRANT ALL PRIVILEGES ON DATABASE \"%s\" TO \"%s\"", info.Name, info.Username)
|
||||
if err := r.ExecSQL(grantSql, info.Timeout); err != nil {
|
||||
if withDeleteDB {
|
||||
_ = r.Delete(DeleteInfo{
|
||||
Name: info.Name,
|
||||
Username: info.Username,
|
||||
ForceDelete: true,
|
||||
Timeout: 300})
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -134,12 +125,15 @@ func (r *Remote) Delete(info DeleteInfo) error {
|
||||
if inUse && !info.ForceDelete {
|
||||
return buserr.WithDetail("ErrInUsed", info.Name, nil)
|
||||
}
|
||||
dropSql := fmt.Sprintf("DROP DATABASE \"%s\"", info.Name)
|
||||
dropSql := "DROP DATABASE " + QuoteIdentifier(info.Name)
|
||||
if err := r.ExecSQL(dropSql, info.Timeout); err != nil && !info.ForceDelete {
|
||||
return fmt.Errorf("drop database failed, err: %v", err)
|
||||
}
|
||||
}
|
||||
dropSql := fmt.Sprintf("DROP USER \"%s\"", info.Username)
|
||||
if info.Username == "" {
|
||||
return nil
|
||||
}
|
||||
dropSql := "DROP USER " + QuoteIdentifier(info.Username)
|
||||
if err := r.ExecSQL(dropSql, info.Timeout); err != nil && !info.ForceDelete {
|
||||
return fmt.Errorf("drop user failed, err: %v", err)
|
||||
}
|
||||
@@ -169,11 +163,11 @@ func (r *Remote) ChangePrivileges(info Privileges) error {
|
||||
if !info.SuperUser {
|
||||
super = "NOSUPERUSER"
|
||||
}
|
||||
return r.ExecSQL(fmt.Sprintf("ALTER USER \"%s\" WITH %s", info.Username, super), info.Timeout)
|
||||
return r.ExecSQL("ALTER USER "+QuoteIdentifier(info.Username)+" WITH "+super, info.Timeout)
|
||||
}
|
||||
|
||||
func (r *Remote) ChangePassword(info PasswordChangeInfo) error {
|
||||
return r.ExecSQL(fmt.Sprintf("ALTER USER \"%s\" WITH ENCRYPTED PASSWORD '%s'", info.Username, info.Password), info.Timeout)
|
||||
return r.ExecSQL("ALTER USER "+QuoteIdentifier(info.Username)+" WITH PASSWORD "+QuoteLiteral(info.Password), info.Timeout)
|
||||
}
|
||||
|
||||
func (r *Remote) Backup(info BackupInfo) error {
|
||||
|
||||
@@ -0,0 +1,73 @@
|
||||
package client
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type UserInfo struct {
|
||||
Username string `json:"username"`
|
||||
SuperUser bool `json:"superUser"`
|
||||
Protected bool `json:"protected"`
|
||||
Databases []string `json:"databases"`
|
||||
}
|
||||
|
||||
type UserClient interface {
|
||||
ExecSQL(command string, timeout uint) error
|
||||
ExecSQLForRows(command string, timeout uint) ([]string, error)
|
||||
}
|
||||
|
||||
func ListUsers(cli UserClient) ([]UserInfo, error) {
|
||||
rows, err := cli.ExecSQLForRows(`SELECT COALESCE(json_agg(u ORDER BY u.username), '[]'::json)::text FROM (
|
||||
SELECT r.rolname AS username, r.rolsuper AS "superUser",
|
||||
(r.rolname = current_user OR r.rolname = 'postgres' OR r.rolname LIKE 'pg\_%') AS protected,
|
||||
COALESCE((SELECT json_agg(d.datname ORDER BY d.datname) FROM pg_database d
|
||||
WHERE NOT d.datistemplate AND EXISTS (
|
||||
SELECT 1 FROM aclexplode(d.datacl) a WHERE a.grantee = r.oid
|
||||
)), '[]'::json) AS databases
|
||||
FROM pg_roles r WHERE r.rolcanlogin
|
||||
) u`, 300)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var users []UserInfo
|
||||
err = json.Unmarshal([]byte(strings.TrimSpace(strings.Join(rows, "\n"))), &users)
|
||||
return users, err
|
||||
}
|
||||
|
||||
func GrantUser(cli UserClient, database, username string, revoke bool) error {
|
||||
statement := "GRANT ALL PRIVILEGES ON DATABASE " + QuoteIdentifier(database) + " TO " + QuoteIdentifier(username)
|
||||
if revoke {
|
||||
statement = "REVOKE ALL PRIVILEGES ON DATABASE " + QuoteIdentifier(database) + " FROM " + QuoteIdentifier(username)
|
||||
}
|
||||
return cli.ExecSQL(statement, 300)
|
||||
}
|
||||
|
||||
func QuoteIdentifier(value string) string {
|
||||
return `"` + strings.ReplaceAll(value, `"`, `""`) + `"`
|
||||
}
|
||||
|
||||
func QuoteLiteral(value string) string {
|
||||
return `E'` + strings.ReplaceAll(strings.ReplaceAll(value, `\`, `\\`), `'`, `''`) + `'`
|
||||
}
|
||||
|
||||
func (r *Remote) ExecSQLForRows(command string, timeout uint) ([]string, error) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
|
||||
defer cancel()
|
||||
rows, err := r.Client.QueryContext(ctx, command)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var result []string
|
||||
for rows.Next() {
|
||||
var value string
|
||||
if err := rows.Scan(&value); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
result = append(result, value)
|
||||
}
|
||||
return result, rows.Err()
|
||||
}
|
||||
@@ -2790,6 +2790,78 @@
|
||||
"formatZH": "创建 postgresql 数据库 [name]",
|
||||
"formatEN": "create postgresql database [name]"
|
||||
},
|
||||
"/databases/pg/users": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "创建 PostgreSQL 实例 [database] 用户 [username]",
|
||||
"formatEN": "create PostgreSQL instance [database] user [username]"
|
||||
},
|
||||
"/databases/pg/users/update": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "修改 PostgreSQL 实例 [database] 用户 [username]",
|
||||
"formatEN": "update PostgreSQL instance [database] user [username]"
|
||||
},
|
||||
"/databases/pg/users/password/save": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "补充 PostgreSQL 实例 [database] 用户 [username] 密码",
|
||||
"formatEN": "save PostgreSQL instance [database] user [username] password locally"
|
||||
},
|
||||
"/databases/pg/users/password": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "修改 PostgreSQL 实例 [database] 用户 [username] 密码",
|
||||
"formatEN": "change PostgreSQL instance [database] user [username] password"
|
||||
},
|
||||
"/databases/pg/users/del": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "删除 PostgreSQL 实例 [database] 用户 [username]",
|
||||
"formatEN": "delete PostgreSQL instance [database] user [username]"
|
||||
},
|
||||
"/databases/pg/grants": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username",
|
||||
"name"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "绑定 PostgreSQL 实例 [database] 数据库 [name] 用户 [username]",
|
||||
"formatEN": "bind PostgreSQL instance [database] database [name] user [username]"
|
||||
},
|
||||
"/databases/pg/grants/del": {
|
||||
"bodyKeys": [
|
||||
"database",
|
||||
"username",
|
||||
"name"
|
||||
],
|
||||
"paramKeys": [],
|
||||
"beforeFunctions": [],
|
||||
"formatZH": "撤销 PostgreSQL 实例 [database] 数据库 [name] 用户 [username] 绑定",
|
||||
"formatEN": "revoke PostgreSQL instance [database] database [name] user [username] binding"
|
||||
},
|
||||
"/databases/pg/bind": {
|
||||
"bodyKeys": [
|
||||
"name",
|
||||
|
||||
@@ -297,6 +297,26 @@ export namespace Database {
|
||||
type: string;
|
||||
database: string;
|
||||
}
|
||||
export interface PostgresqlUser {
|
||||
username: string;
|
||||
password: string;
|
||||
description: string;
|
||||
superUser: boolean;
|
||||
protected: boolean;
|
||||
databases: string[];
|
||||
}
|
||||
export interface PostgresqlUserCreate {
|
||||
database: string;
|
||||
username: string;
|
||||
password: string;
|
||||
superUser: boolean;
|
||||
description: string;
|
||||
}
|
||||
export interface PostgresqlUserGrant {
|
||||
database: string;
|
||||
name: string;
|
||||
username: string;
|
||||
}
|
||||
export interface PostgresqlDBInfo {
|
||||
id: number;
|
||||
createdAt: Date;
|
||||
@@ -316,6 +336,7 @@ export namespace Database {
|
||||
file: string;
|
||||
}
|
||||
export interface PostgresqlDBCreate {
|
||||
existingUser?: boolean;
|
||||
name: string;
|
||||
from: string;
|
||||
database: string;
|
||||
|
||||
@@ -258,3 +258,34 @@ export const deleteCheckDatabase = (id: number) => {
|
||||
export const deleteDatabase = (params: Database.DatabaseDelete) => {
|
||||
return http.post(`/databases/db/del`, params);
|
||||
};
|
||||
|
||||
export const searchPostgresqlUsers = (database: string) => {
|
||||
return http.post<Database.PostgresqlUser[]>('/databases/pg/users/search', { database });
|
||||
};
|
||||
export const createPostgresqlUser = (params: Database.PostgresqlUserCreate) => {
|
||||
const request = { ...params };
|
||||
encodeBase64Fields(request, ['password']);
|
||||
return http.post('/databases/pg/users', request);
|
||||
};
|
||||
export const updatePostgresqlUser = (params: Omit<Database.PostgresqlUserCreate, 'password'>) => {
|
||||
return http.post('/databases/pg/users/update', params);
|
||||
};
|
||||
export const changePostgresqlUserPassword = (params: { database: string; username: string; password: string }) => {
|
||||
const request = { ...params };
|
||||
encodeBase64Fields(request, ['password']);
|
||||
return http.post('/databases/pg/users/password', request);
|
||||
};
|
||||
export const savePostgresqlUserPassword = (params: { database: string; username: string; password: string }) => {
|
||||
const request = { ...params };
|
||||
encodeBase64Fields(request, ['password']);
|
||||
return http.post('/databases/pg/users/password/save', request);
|
||||
};
|
||||
export const deletePostgresqlUser = (params: { database: string; username: string }) => {
|
||||
return http.post('/databases/pg/users/del', params);
|
||||
};
|
||||
export const grantPostgresqlUser = (params: Database.PostgresqlUserGrant) => {
|
||||
return http.post('/databases/pg/grants', params);
|
||||
};
|
||||
export const revokePostgresqlUser = (params: Database.PostgresqlUserGrant) => {
|
||||
return http.post('/databases/pg/grants/del', params);
|
||||
};
|
||||
|
||||
@@ -621,6 +621,7 @@ const message = {
|
||||
'This port is the exposed port of the container. You need to save the modification separately and restart the container!',
|
||||
loadFromRemote: 'Sync from server',
|
||||
userBind: 'Bind user',
|
||||
connectionUser: 'Connection user',
|
||||
userAuthorization: 'User authorization',
|
||||
noUserAuthorization: 'Do not authorize',
|
||||
authorizedDatabaseCount: '{0} authorized database(s)',
|
||||
@@ -631,10 +632,13 @@ const message = {
|
||||
revokeAuthorization: 'Revoke authorization',
|
||||
revokeAuthorizationHelper: "Revoke user {0}'s access to database {1}?",
|
||||
supplementPassword: 'Add password',
|
||||
supplementPasswordHelper: 'This only saves the existing password to 1Panel and does not change it in MySQL.',
|
||||
supplementPasswordHelper:
|
||||
'This only saves the existing password to 1Panel and does not change the database user password.',
|
||||
noUserBind: 'No binding',
|
||||
pgBindHelper:
|
||||
'This operation is used to create a new user and bind it to the target database. Currently, selecting users already existing in the database is not supported.',
|
||||
pgAuthorizationHelper:
|
||||
'Superusers can access all databases in this instance without binding. Ordinary users receive database-level grants only, without table permissions.',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'Revoking authorization does not delete the user. Access through PUBLIC or other roles may remain.',
|
||||
pgSuperUser: 'Superuser',
|
||||
loadFromRemoteHelper: 'Sync databases, users, and authorizations from the server to 1Panel. Continue?',
|
||||
passwordHelper: 'Not available, click to update',
|
||||
|
||||
@@ -623,6 +623,7 @@ const message = {
|
||||
loadFromRemote: 'Sincronizar desde el servidor',
|
||||
userBind: 'Vincular usuario',
|
||||
noUserBind: 'Sin vinculación',
|
||||
connectionUser: 'Usuario de conexión',
|
||||
userAuthorization: 'Autorización de usuario',
|
||||
noUserAuthorization: 'No autorizar',
|
||||
authorizedDatabaseCount: '{0} base(s) de datos autorizada(s)',
|
||||
@@ -633,9 +634,12 @@ const message = {
|
||||
revokeAuthorization: 'Revocar autorización',
|
||||
revokeAuthorizationHelper: '¿Revocar el acceso del usuario {0} a la base de datos {1}?',
|
||||
supplementPassword: 'Añadir contraseña',
|
||||
supplementPasswordHelper: 'Solo guarda la contraseña existente en 1Panel; no cambia la contraseña en MySQL.',
|
||||
pgBindHelper:
|
||||
'Esta operación se utiliza para crear un nuevo usuario y vincularlo a la base de datos destino. Actualmente no se admite seleccionar usuarios ya existentes en la base de datos.',
|
||||
supplementPasswordHelper:
|
||||
'Solo guarda la contraseña existente en 1Panel, sin cambiar la contraseña del usuario de la base de datos.',
|
||||
pgAuthorizationHelper:
|
||||
'Los superusuarios acceden a todas las bases de datos de esta instancia sin vinculación. Para usuarios normales solo se gestionan permisos de base de datos, no de tablas.',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'Revocar la autorización no elimina al usuario. Puede conservar el acceso mediante PUBLIC u otros roles.',
|
||||
pgSuperUser: 'Superusuario',
|
||||
loadFromRemoteHelper:
|
||||
'Esto sincronizará las bases de datos, los usuarios y las autorizaciones del servidor con 1Panel. ¿Desea continuar?',
|
||||
|
||||
@@ -617,6 +617,7 @@ const message = {
|
||||
loadFromRemote: 'همگامسازی از سرور',
|
||||
userBind: 'اتصال کاربر',
|
||||
noUserBind: 'بدون اتصال',
|
||||
connectionUser: 'کاربر اتصال',
|
||||
userAuthorization: 'مجوز کاربر',
|
||||
noUserAuthorization: 'بدون اعطای مجوز',
|
||||
authorizedDatabaseCount: '{0} پایگاه داده مجاز',
|
||||
@@ -627,9 +628,12 @@ const message = {
|
||||
revokeAuthorization: 'لغو مجوز',
|
||||
revokeAuthorizationHelper: 'دسترسی کاربر {0} به پایگاه داده {1} لغو شود؟',
|
||||
supplementPassword: 'افزودن گذرواژه',
|
||||
supplementPasswordHelper: 'فقط گذرواژه فعلی را در 1Panel ذخیره میکند و گذرواژه MySQL را تغییر نمیدهد.',
|
||||
pgBindHelper:
|
||||
'این عملیات برای ایجاد کاربر جدید و اتصال آن به پایگاه داده هدف استفاده میشود. در حال حاضر انتخاب کاربرانی که از قبل در پایگاه داده وجود دارند پشتیبانی نمیشود.',
|
||||
supplementPasswordHelper:
|
||||
'فقط گذرواژه موجود را در 1Panel ذخیره میکند و گذرواژه کاربر پایگاه داده را تغییر نمیدهد.',
|
||||
pgAuthorizationHelper:
|
||||
'ابرکاربران بدون پیوند به همه پایگاههای داده این نمونه دسترسی دارند. برای کاربران عادی فقط مجوزهای سطح پایگاه داده مدیریت میشود، نه مجوز جدولها.',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'لغو مجوز کاربر را حذف نمیکند. دسترسی از طریق PUBLIC یا نقشهای دیگر ممکن است باقی بماند.',
|
||||
pgSuperUser: 'کاربر فوقالعاده',
|
||||
loadFromRemoteHelper: 'پایگاههای داده، کاربران و مجوزها از سرور با 1Panel همگام شوند؟',
|
||||
passwordHelper: 'در دسترس نیست، برای بهروزرسانی کلیک کنید',
|
||||
|
||||
@@ -622,6 +622,7 @@ const message = {
|
||||
loadFromRemote: '同期',
|
||||
userBind: 'バインドユーザー',
|
||||
noUserBind: '未バインド',
|
||||
connectionUser: '接続ユーザー',
|
||||
userAuthorization: 'ユーザー権限',
|
||||
noUserAuthorization: '権限を付与しない',
|
||||
authorizedDatabaseCount: '{0} データベースに権限付与済み',
|
||||
@@ -632,9 +633,12 @@ const message = {
|
||||
revokeAuthorization: '権限を取り消す',
|
||||
revokeAuthorizationHelper: 'ユーザー {0} のデータベース {1} へのアクセス権を取り消しますか?',
|
||||
supplementPassword: 'パスワードを登録',
|
||||
supplementPasswordHelper: '既存のパスワードを 1Panel に保存するだけで、MySQL のパスワードは変更しません。',
|
||||
pgBindHelper:
|
||||
'この操作は、新しいユーザーを作成し、ターゲットデータベースにバインドするために使用されます。現在、データベースに既存のユーザーを選択することはサポートされていません。',
|
||||
supplementPasswordHelper:
|
||||
'既存のパスワードを 1Panel に保存するだけで、データベースユーザーのパスワードは変更しません。',
|
||||
pgAuthorizationHelper:
|
||||
'スーパーユーザーは紐付けなしでこのインスタンスの全データベースにアクセスできます。一般ユーザーはデータベース単位の権限のみ管理し、テーブル権限は含みません。',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'権限を取り消してもユーザーは削除されません。PUBLIC や他のロール経由のアクセスが残る場合があります。',
|
||||
pgSuperUser: 'スーパーユーザー',
|
||||
loadFromRemoteHelper: 'サーバー上のデータベース、ユーザー、権限情報を 1Panel に同期します。続行しますか?',
|
||||
passwordHelper: '取得できません、クリックして修正',
|
||||
|
||||
@@ -615,6 +615,7 @@ const message = {
|
||||
loadFromRemote: '동기화',
|
||||
userBind: '사용자 바인딩',
|
||||
noUserBind: '바인딩 없음',
|
||||
connectionUser: '연결 사용자',
|
||||
userAuthorization: '사용자 권한',
|
||||
noUserAuthorization: '권한 부여 안 함',
|
||||
authorizedDatabaseCount: '데이터베이스 {0}개 권한 보유',
|
||||
@@ -625,9 +626,12 @@ const message = {
|
||||
revokeAuthorization: '권한 취소',
|
||||
revokeAuthorizationHelper: '사용자 {0}의 데이터베이스 {1} 접근 권한을 취소하시겠습니까?',
|
||||
supplementPassword: '비밀번호 추가',
|
||||
supplementPasswordHelper: '기존 비밀번호를 1Panel에만 저장하며 MySQL 비밀번호는 변경하지 않습니다.',
|
||||
pgBindHelper:
|
||||
'이 작업은 새 사용자를 생성하여 대상 데이터베이스에 바인딩하는 데 사용됩니다. 현재 데이터베이스에 이미 존재하는 사용자 선택은 지원되지 않습니다.',
|
||||
supplementPasswordHelper:
|
||||
'기존 비밀번호를 1Panel에 저장하기만 하며 데이터베이스 사용자 비밀번호는 변경하지 않습니다.',
|
||||
pgAuthorizationHelper:
|
||||
'슈퍼유저는 연결 설정 없이 이 인스턴스의 모든 데이터베이스에 접근합니다. 일반 사용자는 데이터베이스 권한만 관리하며 테이블 권한은 포함하지 않습니다.',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'권한을 철회해도 사용자는 삭제되지 않습니다. PUBLIC 또는 다른 역할을 통한 접근 권한은 남을 수 있습니다.',
|
||||
pgSuperUser: '슈퍼 사용자',
|
||||
loadFromRemoteHelper: '서버의 데이터베이스, 사용자 및 권한 정보를 1Panel로 동기화합니다. 계속하시겠습니까?',
|
||||
passwordHelper: '확인 불가, 수정하려면 클릭',
|
||||
|
||||
@@ -613,6 +613,7 @@ const message = {
|
||||
portHelper: 'ພອດນີ້ແມ່ນພອດທີ່ເປີດອອກຂອງຄອນເທນເນີ. ທ່ານຕ້ອງບັນທຶກການແກ້ໄຂແຍກຕ່າງຫາກ ແລະ ຣີສະຕາດຄອນເທນເນີ!',
|
||||
loadFromRemote: 'ຊິ້ງຄ໌ຈາກເຊີເວີ',
|
||||
userBind: 'ຜູກມັດຜູ້ໃຊ້',
|
||||
connectionUser: 'ຜູ້ໃຊ້ເຊື່ອມຕໍ່',
|
||||
userAuthorization: 'ການໃຫ້ສິດຜູ້ໃຊ້',
|
||||
noUserAuthorization: 'ບໍ່ໃຫ້ສິດ',
|
||||
authorizedDatabaseCount: 'ໄດ້ຮັບສິດ {0} ຖານຂໍ້ມູນ',
|
||||
@@ -623,10 +624,11 @@ const message = {
|
||||
revokeAuthorization: 'ຖອນສິດ',
|
||||
revokeAuthorizationHelper: 'ຖອນສິດຜູ້ໃຊ້ {0} ໃນຖານຂໍ້ມູນ {1} ຫຼືບໍ່?',
|
||||
supplementPassword: 'ເພີ່ມລະຫັດຜ່ານ',
|
||||
supplementPasswordHelper: 'ບັນທຶກລະຫັດຜ່ານປັດຈຸບັນໄວ້ໃນ 1Panel ເທົ່ານັ້ນ ແລະບໍ່ປ່ຽນລະຫັດ MySQL.',
|
||||
supplementPasswordHelper: 'ບັນທຶກລະຫັດຜ່ານທີ່ມີຢູ່ໃນ 1Panel ເທົ່ານັ້ນ ໂດຍບໍ່ປ່ຽນລະຫັດຜ່ານຜູ້ໃຊ້ຖານຂໍ້ມູນ.',
|
||||
noUserBind: 'ບໍ່ມີການຜູກມັດ',
|
||||
pgBindHelper:
|
||||
'ການດຳເນີນການນີ້ໃຊ້ເພື່ອສ້າງຜູ້ໃຊ້ໃໝ່ ແລະ ຜູກມັດກັບຖານຂໍ້ມູນເປົ້າໝາຍ. ໃນປັດຈຸບັນ, ຍັງບໍ່ຮອງຮັບການເລືອກຜູ້ໃຊ້ທີ່ມີຢູ່ແລ້ວໃນຖານຂໍ້ມູນ.',
|
||||
pgAuthorizationHelper:
|
||||
'ຜູ້ໃຊ້ຂັ້ນສູງເຂົ້າເຖິງທຸກຖານຂໍ້ມູນໃນອິນສະແຕນນີ້ໄດ້ໂດຍບໍ່ຕ້ອງຜູກ. ຜູ້ໃຊ້ທົ່ວໄປຈັດການສະເພາະສິດລະດັບຖານຂໍ້ມູນ ບໍ່ລວມສິດຕາຕະລາງ.',
|
||||
pgRevokeAuthorizationHelper: 'ການຍົກເລີກສິດບໍ່ລຶບຜູ້ໃຊ້. ການເຂົ້າເຖິງຜ່ານ PUBLIC ຫຼືບົດບາດອື່ນອາດຍັງຄົງຢູ່.',
|
||||
pgSuperUser: 'ຊຸບເປີຢູເຊີ',
|
||||
loadFromRemoteHelper: 'ຊິ້ງຄ໌ຖານຂໍ້ມູນ, ຜູ້ໃຊ້ ແລະສິດຈາກເຊີເວີມາຍັງ 1Panel ຫຼືບໍ່?',
|
||||
passwordHelper: 'ບໍ່ສາມາດໃຊ້ໄດ້, ຄລິກເພື່ອອັບເດດ',
|
||||
|
||||
@@ -628,6 +628,7 @@ const message = {
|
||||
'Port ini adalah port yang didedahkan oleh kontena. Anda perlu menyimpan pengubahsuaian secara berasingan dan memulakan semula kontena!',
|
||||
loadFromRemote: 'Selaras',
|
||||
userBind: 'Kaitkan pengguna',
|
||||
connectionUser: 'Pengguna sambungan',
|
||||
userAuthorization: 'Kebenaran pengguna',
|
||||
noUserAuthorization: 'Jangan beri kebenaran',
|
||||
authorizedDatabaseCount: '{0} pangkalan data dibenarkan',
|
||||
@@ -638,10 +639,13 @@ const message = {
|
||||
revokeAuthorization: 'Tarik balik kebenaran',
|
||||
revokeAuthorizationHelper: 'Tarik balik akses pengguna {0} kepada pangkalan data {1}?',
|
||||
supplementPassword: 'Tambah kata laluan',
|
||||
supplementPasswordHelper: 'Hanya menyimpan kata laluan sedia ada ke 1Panel dan tidak mengubahnya dalam MySQL.',
|
||||
supplementPasswordHelper:
|
||||
'Hanya menyimpan kata laluan sedia ada dalam 1Panel tanpa menukar kata laluan pengguna pangkalan data.',
|
||||
noUserBind: 'Tiada kaitan',
|
||||
pgBindHelper:
|
||||
'Operasi ini digunakan untuk mencipta pengguna baharu dan mengaitkannya dengan pangkalan data sasaran. Pada masa ini, memilih pengguna yang sudah wujud dalam pangkalan data tidak disokong.',
|
||||
pgAuthorizationHelper:
|
||||
'Pengguna super boleh mengakses semua pangkalan data dalam tika ini tanpa pautan. Pengguna biasa hanya mengurus kebenaran pangkalan data, bukan kebenaran jadual.',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'Pembatalan kebenaran tidak memadamkan pengguna. Akses melalui PUBLIC atau peranan lain mungkin kekal.',
|
||||
pgSuperUser: 'Pengguna Super',
|
||||
loadFromRemoteHelper:
|
||||
'Ini akan menyelaraskan pangkalan data, pengguna dan kebenaran dari pelayan ke 1Panel. Teruskan?',
|
||||
|
||||
@@ -621,6 +621,7 @@ const message = {
|
||||
'Esta porta é a porta exposta do container. Você precisa salvar a modificação separadamente e reiniciar o container!',
|
||||
loadFromRemote: 'Sincronizar',
|
||||
userBind: 'Vincular usuário',
|
||||
connectionUser: 'Usuário de conexão',
|
||||
userAuthorization: 'Autorização de usuário',
|
||||
noUserAuthorization: 'Não autorizar',
|
||||
authorizedDatabaseCount: '{0} banco(s) de dados autorizado(s)',
|
||||
@@ -631,10 +632,13 @@ const message = {
|
||||
revokeAuthorization: 'Revogar autorização',
|
||||
revokeAuthorizationHelper: 'Revogar o acesso do usuário {0} ao banco de dados {1}?',
|
||||
supplementPassword: 'Adicionar senha',
|
||||
supplementPasswordHelper: 'Apenas salva a senha existente no 1Panel; não altera a senha no MySQL.',
|
||||
supplementPasswordHelper:
|
||||
'Salva apenas a senha existente no 1Panel, sem alterar a senha do usuário do banco de dados.',
|
||||
noUserBind: 'Sem vínculo',
|
||||
pgBindHelper:
|
||||
'Esta operação cria um novo usuário e o vincula ao banco de dados alvo. A seleção de usuários já existentes no banco de dados não é suportada.',
|
||||
pgAuthorizationHelper:
|
||||
'Superusuários acessam todos os bancos desta instância sem vínculo. Para usuários comuns, são gerenciadas apenas permissões de banco, sem permissões de tabelas.',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'Revogar a autorização não exclui o usuário. O acesso por PUBLIC ou outros papéis pode permanecer.',
|
||||
pgSuperUser: 'Superusuário',
|
||||
loadFromRemoteHelper:
|
||||
'Isso sincronizará bancos de dados, usuários e autorizações do servidor com o 1Panel. Deseja continuar?',
|
||||
|
||||
@@ -615,6 +615,7 @@ const message = {
|
||||
'Этот порт является открытым портом контейнера. Вам нужно сохранить изменение отдельно и перезапустить контейнер!',
|
||||
loadFromRemote: 'Синхронизировать',
|
||||
userBind: 'Привязать пользователя',
|
||||
connectionUser: 'Пользователь подключения',
|
||||
userAuthorization: 'Доступ пользователя',
|
||||
noUserAuthorization: 'Не предоставлять доступ',
|
||||
authorizedDatabaseCount: 'Доступных баз данных: {0}',
|
||||
@@ -625,10 +626,13 @@ const message = {
|
||||
revokeAuthorization: 'Отозвать доступ',
|
||||
revokeAuthorizationHelper: 'Отозвать у пользователя {0} доступ к базе данных {1}?',
|
||||
supplementPassword: 'Добавить пароль',
|
||||
supplementPasswordHelper: 'Сохраняет текущий пароль только в 1Panel и не изменяет пароль в MySQL.',
|
||||
supplementPasswordHelper:
|
||||
'Сохраняет существующий пароль только в 1Panel, не изменяя пароль пользователя базы данных.',
|
||||
noUserBind: 'Нет привязки',
|
||||
pgBindHelper:
|
||||
'Эта операция используется для создания нового пользователя и привязки его к целевой базе данных. В настоящее время выбор уже существующих пользователей в базе данных не поддерживается.',
|
||||
pgAuthorizationHelper:
|
||||
'Суперпользователи имеют доступ ко всем базам экземпляра без привязки. Для обычных пользователей управляются только права уровня базы данных, без прав на таблицы.',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'Отзыв прав не удаляет пользователя. Доступ через PUBLIC или другие роли может сохраниться.',
|
||||
pgSuperUser: 'Суперпользователь',
|
||||
loadFromRemoteHelper: 'Синхронизировать базы данных, пользователей и права доступа с сервера в 1Panel?',
|
||||
passwordHelper: 'Не удается получить, нажмите для изменения',
|
||||
|
||||
@@ -622,6 +622,7 @@ const message = {
|
||||
'Bu port konteynerin açığa çıkan portudur. Değişikliği ayrı olarak kaydetmeniz ve konteyneri yeniden başlatmanız gerekir!',
|
||||
loadFromRemote: 'Sunucudan senkronize et',
|
||||
userBind: 'Kullanıcı bağla',
|
||||
connectionUser: 'Bağlantı kullanıcısı',
|
||||
userAuthorization: 'Kullanıcı yetkilendirmesi',
|
||||
noUserAuthorization: 'Yetki verme',
|
||||
authorizedDatabaseCount: '{0} veritabanı yetkisi',
|
||||
@@ -632,10 +633,13 @@ const message = {
|
||||
revokeAuthorization: 'Yetkiyi kaldır',
|
||||
revokeAuthorizationHelper: '{0} kullanıcısının {1} veritabanına erişimi kaldırılsın mı?',
|
||||
supplementPassword: 'Parola ekle',
|
||||
supplementPasswordHelper: 'Yalnızca mevcut parolayı 1Panel içine kaydeder; MySQL parolasını değiştirmez.',
|
||||
supplementPasswordHelper:
|
||||
'Yalnızca mevcut parolayı 1Panel içine kaydeder; veritabanı kullanıcısının parolasını değiştirmez.',
|
||||
noUserBind: 'Bağlantı yok',
|
||||
pgBindHelper:
|
||||
'Bu işlem yeni bir kullanıcı oluşturmak ve hedef veritabanına bağlamak için kullanılır. Şu anda veritabanında mevcut olan kullanıcıları seçmek desteklenmiyor.',
|
||||
pgAuthorizationHelper:
|
||||
'Süper kullanıcılar bu örnekteki tüm veritabanlarına bağlama gerekmeden erişir. Normal kullanıcılar için yalnızca veritabanı izinleri yönetilir, tablo izinleri dahil değildir.',
|
||||
pgRevokeAuthorizationHelper:
|
||||
'Yetkinin iptal edilmesi kullanıcıyı silmez. PUBLIC veya diğer roller üzerinden erişim devam edebilir.',
|
||||
pgSuperUser: 'Süper Kullanıcı',
|
||||
loadFromRemoteHelper:
|
||||
'Sunucudaki veritabanlarını, kullanıcıları ve yetkilendirmeleri 1Panel ile eşitler. Devam edilsin mi?',
|
||||
|
||||
@@ -596,6 +596,7 @@ const message = {
|
||||
confNotFound: '未能找到該應用設定檔,請在應用商店升級該應用至最新版本後重試',
|
||||
loadFromRemote: '從伺服器同步',
|
||||
userBind: '綁定使用者',
|
||||
connectionUser: '連線使用者',
|
||||
userAuthorization: '使用者授權',
|
||||
noUserAuthorization: '不授權',
|
||||
authorizedDatabaseCount: '已授權 {0} 個資料庫',
|
||||
@@ -606,9 +607,11 @@ const message = {
|
||||
revokeAuthorization: '撤銷授權',
|
||||
revokeAuthorizationHelper: '確定撤銷使用者 {0} 對資料庫 {1} 的存取授權嗎?',
|
||||
supplementPassword: '補充密碼',
|
||||
supplementPasswordHelper: '僅將現有密碼儲存到 1Panel,不會修改 MySQL 使用者密碼。',
|
||||
supplementPasswordHelper: '僅將現有密碼儲存至 1Panel,不會修改資料庫使用者密碼。',
|
||||
noUserBind: '未綁定',
|
||||
pgBindHelper: '此操作用於建立新使用者並將其綁定到目標資料庫,暫不支援選擇已存在於資料庫中的使用者。',
|
||||
pgAuthorizationHelper:
|
||||
'超級使用者可存取此執行個體的所有資料庫,無需單獨授權。一般使用者僅管理資料庫層級授權,不包含資料表權限。',
|
||||
pgRevokeAuthorizationHelper: '撤銷授權不會刪除使用者,使用者仍可能透過公共權限或其他角色存取此資料庫。',
|
||||
pgSuperUser: '超級使用者',
|
||||
loadFromRemoteHelper: '此操作將同步伺服器上的資料庫、使用者及授權資訊到 1Panel,是否繼續?',
|
||||
passwordHelper: '無法取得,可點選修改',
|
||||
|
||||
@@ -603,6 +603,7 @@ const message = {
|
||||
|
||||
loadFromRemote: '从服务器同步',
|
||||
userBind: '绑定用户',
|
||||
connectionUser: '连接用户',
|
||||
userAuthorization: '用户授权',
|
||||
noUserAuthorization: '不授权',
|
||||
authorizedDatabaseCount: '已授权 {0} 个数据库',
|
||||
@@ -613,9 +614,11 @@ const message = {
|
||||
revokeAuthorization: '撤销授权',
|
||||
revokeAuthorizationHelper: '确定撤销用户 {0} 对数据库 {1} 的访问授权吗?',
|
||||
supplementPassword: '补充密码',
|
||||
supplementPasswordHelper: '仅将现有密码保存到 1Panel,不会修改 MySQL 用户密码。',
|
||||
supplementPasswordHelper: '仅将现有密码保存到 1Panel,不会修改数据库用户密码。',
|
||||
noUserBind: '不绑定',
|
||||
pgBindHelper: '该操作用于创建新用户并将其绑定到目标数据库,暂不支持选择已存在于数据库中的用户。',
|
||||
pgAuthorizationHelper:
|
||||
'超级用户可访问此实例的所有数据库,无需单独授权。普通用户仅管理数据库级授权,不包含表级权限。',
|
||||
pgRevokeAuthorizationHelper: '撤销授权不会删除用户,用户仍可能通过公共权限或其他角色访问该数据库。',
|
||||
pgSuperUser: '超级用户',
|
||||
loadFromRemoteHelper: '此操作将同步服务器上的数据库、用户及授权信息到 1Panel,是否继续?',
|
||||
passwordHelper: '无法获取,可点击修改',
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
size="small"
|
||||
>
|
||||
<el-form v-loading="loading" ref="changeFormRef" :model="form" :rules="rules" label-position="top">
|
||||
<el-alert type="warning" :title="$t('database.pgBindHelper')" :closable="false" />
|
||||
<el-alert type="warning" :title="$t('database.pgAuthorizationHelper')" :closable="false" />
|
||||
<el-form-item class="mt-5" :label="$t('database.userBind')" prop="username">
|
||||
<el-input v-model="form.username" />
|
||||
</el-form-item>
|
||||
|
||||
@@ -1,14 +1,74 @@
|
||||
<template>
|
||||
<DrawerPro v-model="createVisible" :header="$t('commons.button.create')" @close="handleClose" size="small">
|
||||
<DrawerPro v-model="createVisible" :header="$t('commons.button.create')" @close="handleClose" size="normal">
|
||||
<div v-loading="loading">
|
||||
<el-form ref="formRef" label-position="top" :model="form" :rules="rules">
|
||||
<el-form-item :label="$t('commons.table.name')" prop="name">
|
||||
<el-input clearable v-model.trim="form.name" @input="form.username = form.name"></el-input>
|
||||
<el-input
|
||||
clearable
|
||||
v-model.trim="form.name"
|
||||
@input="!form.existingUser && (form.username = form.name)"
|
||||
></el-input>
|
||||
</el-form-item>
|
||||
<el-form-item :label="$t('database.userAuthorization')">
|
||||
<el-radio-group v-model="form.existingUser" @change="changeUserMode">
|
||||
<el-radio-button :value="true" :disabled="!users.length">
|
||||
{{ $t('commons.button.select') }}
|
||||
</el-radio-button>
|
||||
<el-radio-button :value="false">{{ $t('commons.button.create') }}</el-radio-button>
|
||||
</el-radio-group>
|
||||
</el-form-item>
|
||||
<el-form-item :label="$t('commons.login.username')" prop="username">
|
||||
<el-input clearable v-model.trim="form.username" />
|
||||
<el-select
|
||||
v-if="form.existingUser"
|
||||
v-model="form.username"
|
||||
filterable
|
||||
:fit-input-width="true"
|
||||
popper-class="postgresql-create-user-select-popper"
|
||||
>
|
||||
<el-option
|
||||
v-for="user in users"
|
||||
:key="user.username"
|
||||
:value="user.username"
|
||||
:label="user.username"
|
||||
class="user-select-option"
|
||||
>
|
||||
<div class="user-option-row">
|
||||
<div class="user-option">
|
||||
<div class="user-option-title">
|
||||
<el-tooltip :content="user.username" v-bind="TABLE_TOOLTIP_OPTIONS">
|
||||
<span class="user-name-text">{{ user.username }}</span>
|
||||
</el-tooltip>
|
||||
<el-tag v-if="user.superUser" class="superuser-tag" type="warning" size="small">
|
||||
{{ $t('database.pgSuperUser') }}
|
||||
</el-tag>
|
||||
</div>
|
||||
<span v-if="user.description" class="user-option-description">
|
||||
{{ user.description }}
|
||||
</span>
|
||||
</div>
|
||||
<el-tag v-if="user.superUser" size="small">{{ $t('commons.table.all') }}</el-tag>
|
||||
<el-popover
|
||||
v-else
|
||||
:disabled="!user.databases.length"
|
||||
placement="right"
|
||||
trigger="hover"
|
||||
:width="220"
|
||||
>
|
||||
<template #reference>
|
||||
<el-button class="user-bound-button" size="small" @click.stop>
|
||||
{{ $t('database.authorizedDatabaseCount', [user.databases.length]) }}
|
||||
</el-button>
|
||||
</template>
|
||||
<div class="user-bound-list">
|
||||
<el-tag v-for="db in user.databases" :key="db" size="small">{{ db }}</el-tag>
|
||||
</div>
|
||||
</el-popover>
|
||||
</div>
|
||||
</el-option>
|
||||
</el-select>
|
||||
<el-input v-else clearable v-model.trim="form.username" />
|
||||
</el-form-item>
|
||||
<el-form-item :label="$t('commons.login.password')" prop="password">
|
||||
<el-form-item v-if="!form.existingUser" :label="$t('commons.login.password')" prop="password">
|
||||
<el-input type="password" clearable show-password v-model.trim="form.password">
|
||||
<template #append>
|
||||
<el-button @click="random">{{ $t('commons.button.random') }}</el-button>
|
||||
@@ -16,8 +76,9 @@
|
||||
</el-input>
|
||||
<span class="input-help">{{ $t('commons.rule.illegalChar') }}</span>
|
||||
</el-form-item>
|
||||
<el-form-item :label="$t('database.permission')" prop="superUser">
|
||||
<el-form-item v-if="!form.existingUser" :label="$t('database.permission')" prop="superUser">
|
||||
<el-checkbox v-model="form.superUser">{{ $t('database.pgSuperUser') }}</el-checkbox>
|
||||
<span class="input-help">{{ $t('database.pgAuthorizationHelper') }}</span>
|
||||
</el-form-item>
|
||||
|
||||
<el-form-item :label="$t('commons.table.type')" prop="database">
|
||||
@@ -43,13 +104,16 @@
|
||||
</template>
|
||||
|
||||
<script lang="ts" setup>
|
||||
import { reactive, ref } from 'vue';
|
||||
import { computed, reactive, ref } from 'vue';
|
||||
import { TABLE_TOOLTIP_OPTIONS } from '@/components/table/shared';
|
||||
import { Rules } from '@/global/form-rules';
|
||||
import i18n from '@/lang';
|
||||
import { ElForm } from 'element-plus';
|
||||
import { addPostgresqlDB } from '@/api/modules/database';
|
||||
import { addPostgresqlDB, searchPostgresqlUsers } from '@/api/modules/database';
|
||||
import { MsgSuccess } from '@/utils/message';
|
||||
import { getRandomStr } from '@/utils/id';
|
||||
import { Database } from '@/api/interface/database';
|
||||
const users = ref<Database.PostgresqlUser[]>([]);
|
||||
const loading = ref();
|
||||
const createVisible = ref(false);
|
||||
const form = reactive({
|
||||
@@ -60,14 +124,15 @@ const form = reactive({
|
||||
format: '',
|
||||
username: '',
|
||||
password: '',
|
||||
superUser: true,
|
||||
superUser: false,
|
||||
existingUser: false,
|
||||
description: '',
|
||||
});
|
||||
const rules = reactive({
|
||||
const rules = computed(() => ({
|
||||
name: [Rules.requiredInput, Rules.dbName],
|
||||
username: [Rules.requiredInput, Rules.name],
|
||||
username: form.existingUser ? [Rules.requiredSelect] : [Rules.requiredInput, Rules.name],
|
||||
password: [Rules.requiredInput, Rules.databasePassword],
|
||||
});
|
||||
}));
|
||||
|
||||
type FormInstance = InstanceType<typeof ElForm>;
|
||||
const formRef = ref<FormInstance>();
|
||||
@@ -77,17 +142,32 @@ interface DialogProps {
|
||||
type: string;
|
||||
database: string;
|
||||
}
|
||||
const acceptParams = (params: DialogProps): void => {
|
||||
const acceptParams = async (params: DialogProps): Promise<void> => {
|
||||
form.name = '';
|
||||
form.from = params.from;
|
||||
form.type = params.type;
|
||||
form.database = params.database;
|
||||
form.format = 'UTF8';
|
||||
form.username = '';
|
||||
form.superUser = true;
|
||||
form.superUser = false;
|
||||
form.existingUser = false;
|
||||
users.value = [];
|
||||
form.description = '';
|
||||
random();
|
||||
createVisible.value = true;
|
||||
loading.value = true;
|
||||
try {
|
||||
users.value = (await searchPostgresqlUsers(params.database)).data || [];
|
||||
} catch {
|
||||
return;
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
};
|
||||
const changeUserMode = () => {
|
||||
form.username = form.existingUser ? users.value[0]?.username || '' : form.name;
|
||||
form.password = form.existingUser ? '' : getRandomStr(16);
|
||||
formRef.value?.clearValidate();
|
||||
};
|
||||
const handleClose = () => {
|
||||
createVisible.value = false;
|
||||
@@ -121,3 +201,70 @@ defineExpose({
|
||||
acceptParams,
|
||||
});
|
||||
</script>
|
||||
|
||||
<style lang="scss" scoped>
|
||||
:deep(.user-select-option) {
|
||||
height: auto;
|
||||
min-height: 48px;
|
||||
}
|
||||
.user-option-row {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 8px;
|
||||
width: 100%;
|
||||
}
|
||||
.user-option {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
justify-content: center;
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
min-height: 40px;
|
||||
padding: 4px 0;
|
||||
line-height: 18px;
|
||||
}
|
||||
.user-option-title {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
min-width: 0;
|
||||
}
|
||||
.user-name-text {
|
||||
min-width: 0;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.user-option-description {
|
||||
margin-top: 3px;
|
||||
color: var(--el-text-color-secondary);
|
||||
font-size: 12px;
|
||||
line-height: 16px;
|
||||
white-space: normal;
|
||||
word-break: break-word;
|
||||
}
|
||||
.user-bound-button {
|
||||
flex-shrink: 0;
|
||||
}
|
||||
.superuser-tag {
|
||||
flex-shrink: 0;
|
||||
}
|
||||
</style>
|
||||
|
||||
<style lang="scss">
|
||||
.postgresql-create-user-select-popper {
|
||||
min-width: 360px;
|
||||
|
||||
.user-select-option {
|
||||
height: auto;
|
||||
min-height: 48px;
|
||||
padding-top: 4px;
|
||||
padding-bottom: 4px;
|
||||
}
|
||||
}
|
||||
.user-bound-list {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 6px;
|
||||
}
|
||||
</style>
|
||||
|
||||
@@ -34,6 +34,15 @@
|
||||
<el-button v-if="currentDB" @click="onChangeConn" type="primary" plain>
|
||||
{{ $t('database.databaseConnInfo') }}
|
||||
</el-button>
|
||||
<el-button
|
||||
v-if="currentDB && (currentDB.from !== 'local' || postgresqlStatus === 'Running')"
|
||||
v-permission
|
||||
type="primary"
|
||||
plain
|
||||
@click="usersRef.acceptParams({ database: currentDBName })"
|
||||
>
|
||||
{{ $t('commons.table.user') }}
|
||||
</el-button>
|
||||
<el-button
|
||||
v-if="currentDB && (currentDB.from !== 'local' || postgresqlStatus === 'Running')"
|
||||
v-permission
|
||||
@@ -114,7 +123,7 @@
|
||||
</div>
|
||||
</template>
|
||||
</el-table-column>
|
||||
<el-table-column :label="$t('commons.login.username')" prop="username">
|
||||
<el-table-column :label="$t('database.connectionUser')" prop="username">
|
||||
<template #default="{ row }">
|
||||
<div class="flex items-center" v-if="row.username">
|
||||
<span>
|
||||
@@ -227,8 +236,7 @@
|
||||
</template>
|
||||
</DialogPro>
|
||||
|
||||
<PrivilegesDialog ref="privilegesRef" @search="search" />
|
||||
<BindDialog ref="bindRef" @search="search" />
|
||||
<UserDialog ref="usersRef" @search="search" />
|
||||
<PasswordDialog ref="passwordRef" @search="search" />
|
||||
<RootPasswordDialog ref="connRef" />
|
||||
<UploadDialog ref="uploadRef" />
|
||||
@@ -245,12 +253,11 @@
|
||||
<script lang="ts" setup>
|
||||
import { TABLE_TOOLTIP_OPTIONS } from '@/components/table/shared';
|
||||
import { useSearchState } from '@/utils/search-reset';
|
||||
import BindDialog from '@/views/database/postgresql/bind/index.vue';
|
||||
import UserDialog from '@/views/database/postgresql/user/index.vue';
|
||||
import OperateDialog from '@/views/database/postgresql/create/index.vue';
|
||||
import DeleteDialog from '@/views/database/postgresql/delete/index.vue';
|
||||
import PasswordDialog from '@/views/database/postgresql/password/index.vue';
|
||||
import TerminalDialog from '@/components/terminal/database.vue';
|
||||
import PrivilegesDialog from '@/views/database/postgresql/privileges/index.vue';
|
||||
import RootPasswordDialog from '@/views/database/postgresql/conn/index.vue';
|
||||
import AppResources from '@/views/database/postgresql/check/index.vue';
|
||||
import AppStatus from '@/components/app-status/index.vue';
|
||||
@@ -292,8 +299,7 @@ const currentDBName = ref();
|
||||
|
||||
const checkRef = ref();
|
||||
const deleteRef = ref();
|
||||
const bindRef = ref();
|
||||
const privilegesRef = ref();
|
||||
const usersRef = ref();
|
||||
const dialogTerminalRef = ref();
|
||||
|
||||
const dashboardName = ref();
|
||||
@@ -408,7 +414,7 @@ const onBind = async (row: Database.PostgresqlDBInfo) => {
|
||||
name: row.name,
|
||||
database: currentDBName.value,
|
||||
};
|
||||
bindRef.value.acceptParams(param);
|
||||
usersRef.value.acceptParams(param);
|
||||
};
|
||||
|
||||
const loadDB = async () => {
|
||||
@@ -551,20 +557,10 @@ const buttons = [
|
||||
},
|
||||
},
|
||||
{
|
||||
label: i18n.global.t('database.permission'),
|
||||
label: i18n.global.t('database.authorizationManagement'),
|
||||
permission: true,
|
||||
disabled: (row: Database.PostgresqlDBInfo) => {
|
||||
return !row.username || row.isDelete;
|
||||
},
|
||||
click: (row: Database.PostgresqlDBInfo) => {
|
||||
let param = {
|
||||
database: currentDBName.value,
|
||||
name: row.name,
|
||||
username: row.username,
|
||||
superUser: row.superUser,
|
||||
};
|
||||
privilegesRef.value.acceptParams(param);
|
||||
},
|
||||
disabled: (row: Database.PostgresqlDBInfo) => row.isDelete,
|
||||
click: (row: Database.PostgresqlDBInfo) => onBind(row),
|
||||
},
|
||||
{
|
||||
label: i18n.global.t('database.backupList'),
|
||||
|
||||
@@ -0,0 +1,567 @@
|
||||
<template>
|
||||
<DrawerPro
|
||||
v-model="visible"
|
||||
:header="name ? $t('database.authorizationManagement') : $t('commons.table.user')"
|
||||
:resource="name || database"
|
||||
size="60%"
|
||||
>
|
||||
<div v-loading="loading">
|
||||
<el-alert
|
||||
:title="$t('database.pgAuthorizationHelper')"
|
||||
type="info"
|
||||
:closable="false"
|
||||
class="authorization-hint"
|
||||
/>
|
||||
<div class="drawer-toolbar">
|
||||
<el-button v-if="!name" v-permission type="primary" @click="openEdit()">
|
||||
{{ $t('commons.button.create') }}
|
||||
</el-button>
|
||||
<el-button v-else v-permission type="primary" @click="openAddAuthorization">
|
||||
{{ $t('database.addUserAuthorization') }}
|
||||
</el-button>
|
||||
</div>
|
||||
<ComplexTable :data="displayed" :heightDiff="260">
|
||||
<el-table-column :label="$t('commons.table.user')" prop="username" min-width="180">
|
||||
<template #default="{ row }">
|
||||
<div class="user-name-row">
|
||||
<el-tooltip :content="row.username" v-bind="TABLE_TOOLTIP_OPTIONS">
|
||||
<span class="user-name-text">{{ row.username }}</span>
|
||||
</el-tooltip>
|
||||
<el-tag v-if="row.superUser" class="superuser-tag" type="warning" size="small">
|
||||
{{ $t('database.pgSuperUser') }}
|
||||
</el-tag>
|
||||
</div>
|
||||
</template>
|
||||
</el-table-column>
|
||||
<el-table-column :label="$t('commons.login.password')" prop="password" min-width="120">
|
||||
<template #default="{ row }">
|
||||
<div v-if="row.password" class="password-cell">
|
||||
<span v-if="!row.showPassword" class="password-text">**********</span>
|
||||
<Tooltip v-else class="password-text" :islink="false" :text="row.password" />
|
||||
<el-button
|
||||
link
|
||||
:icon="row.showPassword ? 'Hide' : 'View'"
|
||||
class="password-action"
|
||||
@click="row.showPassword = !row.showPassword"
|
||||
/>
|
||||
<CopyButton class="password-copy" :content="row.password" />
|
||||
</div>
|
||||
<div v-else-if="!row.protected" class="password-cell">
|
||||
<el-button v-permission link type="primary" @click="openSupplementPassword(row)">
|
||||
{{ $t('database.supplementPassword') }}
|
||||
</el-button>
|
||||
</div>
|
||||
<span v-else>-</span>
|
||||
</template>
|
||||
</el-table-column>
|
||||
<el-table-column :label="$t('menu.database')" min-width="160">
|
||||
<template #default="{ row }">
|
||||
<el-tag v-if="row.superUser" size="small">{{ $t('commons.table.all') }}</el-tag>
|
||||
<span v-else-if="!row.databases.length">-</span>
|
||||
<div v-else class="bind-db-list">
|
||||
<el-tooltip
|
||||
v-for="db in row.databases.slice(0, 1)"
|
||||
:key="db"
|
||||
:content="db"
|
||||
v-bind="TABLE_TOOLTIP_OPTIONS"
|
||||
>
|
||||
<el-tag size="small">{{ db }}</el-tag>
|
||||
</el-tooltip>
|
||||
<el-popover v-if="row.databases.length > 1" placement="right" trigger="click" :width="260">
|
||||
<template #reference>
|
||||
<el-tag class="cursor-pointer" type="info" size="small">
|
||||
+{{ row.databases.length - 1 }}
|
||||
</el-tag>
|
||||
</template>
|
||||
<div class="bind-db-popover">
|
||||
<el-tooltip
|
||||
v-for="db in row.databases"
|
||||
:key="db"
|
||||
:content="db"
|
||||
v-bind="TABLE_TOOLTIP_OPTIONS"
|
||||
>
|
||||
<el-tag size="small">{{ db }}</el-tag>
|
||||
</el-tooltip>
|
||||
</div>
|
||||
</el-popover>
|
||||
</div>
|
||||
</template>
|
||||
</el-table-column>
|
||||
<el-table-column
|
||||
:label="$t('commons.table.description')"
|
||||
prop="description"
|
||||
show-overflow-tooltip
|
||||
min-width="120"
|
||||
/>
|
||||
<fu-table-operations
|
||||
:width="120"
|
||||
:buttons="userButtons"
|
||||
:label="$t('commons.table.operate')"
|
||||
fixed="right"
|
||||
fix
|
||||
/>
|
||||
</ComplexTable>
|
||||
</div>
|
||||
</DrawerPro>
|
||||
<DialogPro v-model="editing" :title="dialogTitle" size="small">
|
||||
<el-form ref="formRef" v-loading="saving" :model="form" :rules="rules" label-position="top">
|
||||
<el-form-item v-if="name && (mode === 'select' || mode === 'create')" :label="$t('commons.table.type')">
|
||||
<el-radio-group v-model="mode" @change="changeAuthorizationMode">
|
||||
<el-radio-button value="select">{{ $t('commons.button.select') }}</el-radio-button>
|
||||
<el-radio-button value="create">{{ $t('commons.button.create') }}</el-radio-button>
|
||||
</el-radio-group>
|
||||
</el-form-item>
|
||||
<el-form-item v-if="mode === 'select'" :label="$t('commons.login.username')" prop="username">
|
||||
<el-select
|
||||
v-model="form.username"
|
||||
filterable
|
||||
:fit-input-width="true"
|
||||
popper-class="postgresql-bind-user-select-popper"
|
||||
>
|
||||
<el-option
|
||||
v-for="user in available"
|
||||
:key="user.username"
|
||||
:value="user.username"
|
||||
:label="user.username"
|
||||
class="user-select-option"
|
||||
>
|
||||
<div class="user-option-row">
|
||||
<div class="user-option">
|
||||
<el-tooltip :content="user.username" v-bind="TABLE_TOOLTIP_OPTIONS">
|
||||
<span class="user-option-title">{{ user.username }}</span>
|
||||
</el-tooltip>
|
||||
<span v-if="user.description" class="user-option-description">
|
||||
{{ user.description }}
|
||||
</span>
|
||||
</div>
|
||||
<el-popover
|
||||
:disabled="!user.databases.length"
|
||||
placement="right"
|
||||
trigger="hover"
|
||||
:width="220"
|
||||
>
|
||||
<template #reference>
|
||||
<el-button class="user-bound-button" size="small" @click.stop>
|
||||
{{ $t('database.authorizedDatabaseCount', [user.databases.length]) }}
|
||||
</el-button>
|
||||
</template>
|
||||
<div class="user-bound-list">
|
||||
<el-tag v-for="db in user.databases" :key="db" size="small">{{ db }}</el-tag>
|
||||
</div>
|
||||
</el-popover>
|
||||
</div>
|
||||
</el-option>
|
||||
</el-select>
|
||||
</el-form-item>
|
||||
<template v-else>
|
||||
<el-form-item :label="$t('commons.login.username')" prop="username">
|
||||
<el-input v-model.trim="form.username" :disabled="mode !== 'create'" />
|
||||
</el-form-item>
|
||||
<el-form-item v-if="mode !== 'supplement'" :label="$t('database.permission')">
|
||||
<el-checkbox v-model="form.superUser">{{ $t('database.pgSuperUser') }}</el-checkbox>
|
||||
<span class="input-help">{{ $t('database.pgAuthorizationHelper') }}</span>
|
||||
</el-form-item>
|
||||
<el-form-item :label="$t('commons.login.password')" prop="password" :required="mode !== 'edit'">
|
||||
<el-input v-model.trim="form.password" type="password" clearable show-password />
|
||||
<span class="input-help">{{ $t('commons.rule.illegalChar') }}</span>
|
||||
<span v-if="mode === 'edit'" class="input-help">{{ $t('setting.passwordEmptyTip') }}</span>
|
||||
<span v-if="mode === 'supplement'" class="input-help">
|
||||
{{ $t('database.supplementPasswordHelper') }}
|
||||
</span>
|
||||
</el-form-item>
|
||||
</template>
|
||||
<template v-if="mode === 'create' || mode === 'edit'">
|
||||
<el-form-item :label="$t('commons.table.description')" prop="description">
|
||||
<el-input v-model="form.description" type="textarea" clearable />
|
||||
</el-form-item>
|
||||
</template>
|
||||
</el-form>
|
||||
<template #footer>
|
||||
<el-button :disabled="saving" @click="editing = false">{{ $t('commons.button.cancel') }}</el-button>
|
||||
<el-button type="primary" :disabled="saving" @click="save">{{ $t('commons.button.confirm') }}</el-button>
|
||||
</template>
|
||||
</DialogPro>
|
||||
|
||||
<DialogPro
|
||||
v-model="deleteDialogVisible"
|
||||
:title="$t('commons.button.delete') + ' - ' + deleteUser.username"
|
||||
size="small"
|
||||
>
|
||||
<div v-loading="deleting">
|
||||
<div class="delete-user-title">{{ deleteUser.username }} {{ $t('database.userBoundDatabases') }}</div>
|
||||
<div class="delete-user-section">
|
||||
<el-tag v-if="deleteUser.superUser" size="small">{{ $t('commons.table.all') }}</el-tag>
|
||||
<div v-else-if="deleteUser.databases.length === 0" class="delete-user-empty">-</div>
|
||||
<div v-else class="bind-db-list delete-user-dbs">
|
||||
<el-tag v-for="item in deleteUser.databases" :key="item" size="small">
|
||||
{{ item }}
|
||||
</el-tag>
|
||||
</div>
|
||||
</div>
|
||||
<div class="delete-user-section">
|
||||
<div>
|
||||
<span style="font-size: 12px">{{ $t('database.delete') }}</span>
|
||||
<span style="font-size: 12px; color: red; font-weight: 500">
|
||||
{{ deleteUser.username }}
|
||||
</span>
|
||||
<span style="font-size: 12px">{{ $t('database.deleteUserHelper') }}</span>
|
||||
</div>
|
||||
<el-input v-model="deleteConfirmInput" :placeholder="deleteUser.username" />
|
||||
</div>
|
||||
</div>
|
||||
<template #footer>
|
||||
<el-button @click="deleteDialogVisible = false" :disabled="deleting">
|
||||
{{ $t('commons.button.cancel') }}
|
||||
</el-button>
|
||||
<el-button
|
||||
type="primary"
|
||||
@click="remove()"
|
||||
:disabled="deleteConfirmInput !== deleteUser.username || deleting"
|
||||
>
|
||||
{{ $t('commons.button.confirm') }}
|
||||
</el-button>
|
||||
</template>
|
||||
</DialogPro>
|
||||
</template>
|
||||
<script setup lang="ts">
|
||||
import { computed, reactive, ref } from 'vue';
|
||||
import Tooltip from '@/components/tooltip/index.vue';
|
||||
import { TABLE_TOOLTIP_OPTIONS } from '@/components/table/shared';
|
||||
import { ElMessageBox, type FormInstance } from 'element-plus';
|
||||
import { Database } from '@/api/interface/database';
|
||||
import {
|
||||
searchPostgresqlUsers,
|
||||
createPostgresqlUser,
|
||||
updatePostgresqlUser,
|
||||
changePostgresqlUserPassword,
|
||||
savePostgresqlUserPassword,
|
||||
deletePostgresqlUser,
|
||||
grantPostgresqlUser,
|
||||
revokePostgresqlUser,
|
||||
} from '@/api/modules/database';
|
||||
import { Rules } from '@/global/form-rules';
|
||||
import { MsgSuccess } from '@/utils/message';
|
||||
import i18n from '@/lang';
|
||||
|
||||
const visible = ref(false);
|
||||
const loading = ref(false);
|
||||
const saving = ref(false);
|
||||
const database = ref('');
|
||||
const name = ref('');
|
||||
const users = ref<Array<Database.PostgresqlUser & { showPassword?: boolean }>>([]);
|
||||
const displayed = computed(() =>
|
||||
users.value.filter((user) => !name.value || user.superUser || user.databases.includes(name.value)),
|
||||
);
|
||||
const available = computed(() =>
|
||||
users.value.filter((user) => !user.superUser && !user.protected && !user.databases.includes(name.value)),
|
||||
);
|
||||
const editing = ref(false);
|
||||
const mode = ref<'create' | 'edit' | 'select' | 'supplement'>('create');
|
||||
const dialogTitle = computed(() => {
|
||||
if (name.value && (mode.value === 'create' || mode.value === 'select')) {
|
||||
return i18n.global.t('database.addUserAuthorization');
|
||||
}
|
||||
if (mode.value === 'supplement') return i18n.global.t('database.supplementPassword');
|
||||
return i18n.global.t(mode.value === 'create' ? 'commons.table.user' : 'commons.button.edit');
|
||||
});
|
||||
const deleteDialogVisible = ref(false);
|
||||
const deleting = ref(false);
|
||||
const deleteConfirmInput = ref('');
|
||||
const deleteUser = reactive({ username: '', databases: [] as string[], superUser: false });
|
||||
const formRef = ref<FormInstance>();
|
||||
const form = reactive({ username: '', password: '', superUser: false, description: '' });
|
||||
const rules = computed(() => ({
|
||||
username:
|
||||
mode.value === 'create'
|
||||
? [Rules.requiredInput, Rules.name]
|
||||
: mode.value === 'select'
|
||||
? [Rules.requiredSelect]
|
||||
: [Rules.requiredInput],
|
||||
password: mode.value === 'edit' ? [Rules.databasePassword] : [Rules.requiredInput, Rules.databasePassword],
|
||||
}));
|
||||
const emit = defineEmits<{ (e: 'search'): void }>();
|
||||
|
||||
const load = async () => {
|
||||
loading.value = true;
|
||||
try {
|
||||
const res = await searchPostgresqlUsers(database.value);
|
||||
users.value = res.data || [];
|
||||
} catch {
|
||||
return;
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
};
|
||||
const acceptParams = async (params: { database: string; name?: string }) => {
|
||||
database.value = params.database;
|
||||
name.value = params.name || '';
|
||||
users.value = [];
|
||||
visible.value = true;
|
||||
await load();
|
||||
};
|
||||
const openEdit = (user?: Database.PostgresqlUser) => {
|
||||
mode.value = user ? 'edit' : 'create';
|
||||
Object.assign(form, {
|
||||
username: user?.username || '',
|
||||
password: '',
|
||||
superUser: user?.superUser || false,
|
||||
description: user?.description || '',
|
||||
});
|
||||
editing.value = true;
|
||||
formRef.value?.clearValidate();
|
||||
};
|
||||
const openAddAuthorization = () => {
|
||||
openEdit();
|
||||
mode.value = 'select';
|
||||
};
|
||||
const changeAuthorizationMode = () => {
|
||||
Object.assign(form, { username: '', password: '', superUser: false, description: '' });
|
||||
formRef.value?.clearValidate();
|
||||
};
|
||||
const openDeleteUserDialog = (user: Database.PostgresqlUser) => {
|
||||
Object.assign(deleteUser, { username: user.username, databases: user.databases, superUser: user.superUser });
|
||||
deleteConfirmInput.value = '';
|
||||
deleteDialogVisible.value = true;
|
||||
};
|
||||
const openSupplementPassword = (user: Database.PostgresqlUser) => {
|
||||
openEdit(user);
|
||||
mode.value = 'supplement';
|
||||
};
|
||||
const save = async () => {
|
||||
if (!(await formRef.value?.validate().catch(() => false))) return;
|
||||
saving.value = true;
|
||||
try {
|
||||
const params = { database: database.value, ...form };
|
||||
if (mode.value === 'create') {
|
||||
await createPostgresqlUser(params);
|
||||
mode.value = name.value && !form.superUser ? 'select' : 'edit';
|
||||
form.password = '';
|
||||
if (name.value && !form.superUser) {
|
||||
await grantPostgresqlUser({ database: database.value, name: name.value, username: form.username });
|
||||
}
|
||||
} else if (mode.value === 'supplement') {
|
||||
await savePostgresqlUserPassword({
|
||||
database: database.value,
|
||||
username: form.username,
|
||||
password: form.password,
|
||||
});
|
||||
} else if (mode.value === 'select') {
|
||||
await grantPostgresqlUser({ database: database.value, name: name.value, username: form.username });
|
||||
} else {
|
||||
await updatePostgresqlUser({
|
||||
database: database.value,
|
||||
username: form.username,
|
||||
superUser: form.superUser,
|
||||
description: form.description,
|
||||
});
|
||||
if (form.password) {
|
||||
await changePostgresqlUserPassword({
|
||||
database: database.value,
|
||||
username: form.username,
|
||||
password: form.password,
|
||||
});
|
||||
}
|
||||
}
|
||||
editing.value = false;
|
||||
MsgSuccess(i18n.global.t('commons.msg.operationSuccess'));
|
||||
emit('search');
|
||||
} catch {
|
||||
return;
|
||||
} finally {
|
||||
saving.value = false;
|
||||
await load();
|
||||
}
|
||||
};
|
||||
const revoke = async (user: Database.PostgresqlUser) => {
|
||||
const confirmed = await ElMessageBox.confirm(
|
||||
`${i18n.global.t('database.revokeAuthorizationHelper', [user.username, name.value])} ${i18n.global.t('database.pgRevokeAuthorizationHelper')}`,
|
||||
i18n.global.t('commons.msg.infoTitle'),
|
||||
{
|
||||
type: 'warning',
|
||||
confirmButtonText: i18n.global.t('commons.button.confirm'),
|
||||
cancelButtonText: i18n.global.t('commons.button.cancel'),
|
||||
},
|
||||
).catch(() => false);
|
||||
if (!confirmed) return;
|
||||
loading.value = true;
|
||||
try {
|
||||
await revokePostgresqlUser({ database: database.value, name: name.value, username: user.username });
|
||||
MsgSuccess(i18n.global.t('commons.msg.operationSuccess'));
|
||||
emit('search');
|
||||
} catch {
|
||||
return;
|
||||
} finally {
|
||||
await load();
|
||||
}
|
||||
};
|
||||
const remove = async () => {
|
||||
if (deleteConfirmInput.value !== deleteUser.username) return;
|
||||
deleting.value = true;
|
||||
try {
|
||||
await deletePostgresqlUser({ database: database.value, username: deleteUser.username });
|
||||
MsgSuccess(i18n.global.t('commons.msg.deleteSuccess'));
|
||||
deleteDialogVisible.value = false;
|
||||
emit('search');
|
||||
} catch {
|
||||
return;
|
||||
} finally {
|
||||
deleting.value = false;
|
||||
await load();
|
||||
}
|
||||
};
|
||||
const userButtons = [
|
||||
{
|
||||
label: i18n.global.t('commons.button.edit'),
|
||||
permission: true,
|
||||
show: (row: Database.PostgresqlUser) => !row.protected,
|
||||
click: (row: Database.PostgresqlUser) => openEdit(row),
|
||||
},
|
||||
{
|
||||
label: i18n.global.t('database.revokeAuthorization'),
|
||||
permission: true,
|
||||
show: (row: Database.PostgresqlUser) => !!name.value && !row.superUser && !row.protected,
|
||||
click: (row: Database.PostgresqlUser) => revoke(row),
|
||||
},
|
||||
{
|
||||
label: i18n.global.t('commons.button.delete'),
|
||||
permission: true,
|
||||
show: (row: Database.PostgresqlUser) => !name.value && !row.protected,
|
||||
click: (row: Database.PostgresqlUser) => openDeleteUserDialog(row),
|
||||
},
|
||||
];
|
||||
defineExpose({ acceptParams });
|
||||
</script>
|
||||
|
||||
<style lang="scss" scoped>
|
||||
.authorization-hint {
|
||||
margin-bottom: 16px;
|
||||
}
|
||||
.user-name-row {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
min-width: 0;
|
||||
}
|
||||
.user-name-text {
|
||||
min-width: 0;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.superuser-tag {
|
||||
flex-shrink: 0;
|
||||
}
|
||||
.drawer-toolbar {
|
||||
display: flex;
|
||||
gap: 8px;
|
||||
margin-bottom: 12px;
|
||||
}
|
||||
.password-cell {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 4px;
|
||||
max-width: 100%;
|
||||
}
|
||||
.password-text {
|
||||
overflow: hidden;
|
||||
max-width: 96px;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.password-action {
|
||||
min-height: 20px;
|
||||
padding: 0;
|
||||
}
|
||||
.password-copy {
|
||||
margin-left: -2px;
|
||||
}
|
||||
.bind-db-list {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 6px;
|
||||
}
|
||||
.bind-db-popover {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(2, minmax(0, 1fr));
|
||||
gap: 8px;
|
||||
|
||||
:deep(.el-tag) {
|
||||
width: 100%;
|
||||
justify-content: flex-start;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
}
|
||||
.delete-user-title {
|
||||
overflow-wrap: anywhere;
|
||||
margin-bottom: 12px;
|
||||
font-size: 14px;
|
||||
font-weight: 500;
|
||||
line-height: 20px;
|
||||
}
|
||||
.delete-user-section {
|
||||
margin-top: 12px;
|
||||
}
|
||||
.delete-user-empty {
|
||||
margin-top: 6px;
|
||||
}
|
||||
.delete-user-dbs {
|
||||
margin-top: 6px;
|
||||
}
|
||||
|
||||
:deep(.user-select-option) {
|
||||
height: auto;
|
||||
min-height: 48px;
|
||||
}
|
||||
.user-option-row {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 8px;
|
||||
width: 100%;
|
||||
}
|
||||
.user-option {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
justify-content: center;
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
min-height: 40px;
|
||||
padding: 4px 0;
|
||||
line-height: 18px;
|
||||
}
|
||||
.user-option-title {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.user-option-description {
|
||||
margin-top: 3px;
|
||||
color: var(--el-text-color-secondary);
|
||||
font-size: 12px;
|
||||
line-height: 16px;
|
||||
white-space: normal;
|
||||
word-break: break-word;
|
||||
}
|
||||
.user-bound-button {
|
||||
flex-shrink: 0;
|
||||
}
|
||||
</style>
|
||||
|
||||
<style lang="scss">
|
||||
.postgresql-bind-user-select-popper {
|
||||
min-width: 360px;
|
||||
|
||||
.user-select-option {
|
||||
height: auto;
|
||||
min-height: 48px;
|
||||
padding-top: 4px;
|
||||
padding-bottom: 4px;
|
||||
}
|
||||
}
|
||||
.user-bound-list {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 6px;
|
||||
}
|
||||
</style>
|
||||
Reference in New Issue
Block a user