Feature (System Settings): Implemented system settings management functionality (#13556)

### What problem does this PR solve?

Feature (System Settings): Implemented system settings management
functionality

- Added a new SystemSettings model, including creation and update time
fields.

- Implemented SystemSettingsDAO, providing CRUD operations and
transaction support.

- Implemented management interfaces for variables, configurations, and
environment variables in the admin service.

### Type of change

- [x] New Feature (non-breaking change which adds functionality)

Co-authored-by: Yingfeng <yingfeng.zhang@gmail.com>
This commit is contained in:
chanx
2026-03-12 19:06:20 +08:00
committed by GitHub
parent 7c79602c77
commit 1df804a14a
4 changed files with 410 additions and 39 deletions

View File

@ -767,28 +767,46 @@ func (h *Handler) RestartService(c *gin.Context) {
}
// GetVariables handle get variables
// Python logic: if request body is empty, list all variables; otherwise get single variable by var_name from body
func (h *Handler) GetVariables(c *gin.Context) {
varName := c.Query("var_name")
if varName != "" {
// Get single variable
variable, err := h.service.GetVariable(varName)
// Check if request has body content
if c.Request.ContentLength == 0 || c.Request.ContentLength == -1 {
// List all variables
variables, err := h.service.GetAllVariables()
if err != nil {
errorResponse(c, err.Error(), 400)
errorResponse(c, err.Error(), 500)
return
}
success(c, variable, "")
success(c, variables, "")
return
}
// List all variables
variables, err := h.service.GetAllVariables()
// Get single variable by var_name from request body
var req struct {
VarName string `json:"var_name"`
}
if err := c.ShouldBindJSON(&req); err != nil {
errorResponse(c, "Invalid request body", 400)
return
}
if req.VarName == "" {
errorResponse(c, "Var name is required", 400)
return
}
variable, err := h.service.GetVariable(req.VarName)
if err != nil {
// Check if it's an AdminException
if adminErr, ok := err.(*AdminException); ok {
errorResponse(c, adminErr.Message, 400)
return
}
errorResponse(c, err.Error(), 500)
return
}
success(c, variables, "")
success(c, variable, "")
}
// SetVariableHTTPRequest set variable request
@ -798,15 +816,31 @@ type SetVariableHTTPRequest struct {
}
// SetVariable handle set variable
// Python logic: update or create a system setting with the given name and value
func (h *Handler) SetVariable(c *gin.Context) {
var req SetVariableHTTPRequest
if err := c.ShouldBindJSON(&req); err != nil {
errorResponse(c, "Var name and value are required", 400)
errorResponse(c, "Var name is required", 400)
return
}
if req.VarName == "" {
errorResponse(c, "Var name is required", 400)
return
}
if req.VarValue == "" {
errorResponse(c, "Var value is required", 400)
return
}
if err := h.service.SetVariable(req.VarName, req.VarValue); err != nil {
errorResponse(c, err.Error(), 400)
// Check if it's an AdminException
if adminErr, ok := err.(*AdminException); ok {
errorResponse(c, adminErr.Message, 400)
return
}
errorResponse(c, err.Error(), 500)
return
}
@ -814,10 +848,16 @@ func (h *Handler) SetVariable(c *gin.Context) {
}
// GetConfigs handle get configs
// Python logic: return all service configurations
func (h *Handler) GetConfigs(c *gin.Context) {
configs, err := h.service.GetAllConfigs()
if err != nil {
errorResponse(c, err.Error(), 400)
// Check if it's an AdminException
if adminErr, ok := err.(*AdminException); ok {
errorResponse(c, adminErr.Message, 400)
return
}
errorResponse(c, err.Error(), 500)
return
}
@ -825,10 +865,16 @@ func (h *Handler) GetConfigs(c *gin.Context) {
}
// GetEnvironments handle get environments
// Python logic: return important environment variables
func (h *Handler) GetEnvironments(c *gin.Context) {
environments, err := h.service.GetAllEnvironments()
if err != nil {
errorResponse(c, err.Error(), 400)
// Check if it's an AdminException
if adminErr, ok := err.(*AdminException); ok {
errorResponse(c, adminErr.Message, 400)
return
}
errorResponse(c, err.Error(), 500)
return
}

View File

@ -46,15 +46,17 @@ var (
// Service admin service layer
type Service struct {
userDAO *dao.UserDAO
licenseDAO *dao.LicenseDAO
userDAO *dao.UserDAO
licenseDAO *dao.LicenseDAO
systemSettingsDAO *dao.SystemSettingsDAO
}
// NewService create admin service
func NewService() *Service {
return &Service{
userDAO: dao.NewUserDAO(),
licenseDAO: dao.NewLicenseDAO(),
userDAO: dao.NewUserDAO(),
licenseDAO: dao.NewLicenseDAO(),
systemSettingsDAO: dao.NewSystemSettingsDAO(),
}
}
@ -888,43 +890,172 @@ func (s *Service) RestartService(serviceID string) (map[string]interface{}, erro
// Variable/Settings methods
// GetVariable get variable
func (s *Service) GetVariable(varName string) (map[string]interface{}, error) {
// TODO: Implement with settings manager
return map[string]interface{}{
"var_name": varName,
"var_value": "",
}, nil
// AdminException admin exception error
type AdminException struct {
Message string
Code int
}
// Error implement error interface
func (e *AdminException) Error() string {
return e.Message
}
// NewAdminException create admin exception
func NewAdminException(message string) *AdminException {
return &AdminException{
Message: message,
Code: 400,
}
}
// GetVariable get variable by name
// Returns the system setting with the given name
// Returns AdminException if the setting is not found
func (s *Service) GetVariable(varName string) ([]map[string]interface{}, error) {
settings, err := s.systemSettingsDAO.GetByName(varName)
if err != nil {
return nil, err
}
if len(settings) == 0 {
return nil, NewAdminException("Can't get setting: " + varName)
}
result := make([]map[string]interface{}, 0, len(settings))
for _, setting := range settings {
result = append(result, map[string]interface{}{
"name": setting.Name,
"source": setting.Source,
"data_type": setting.DataType,
"value": setting.Value,
})
}
return result, nil
}
// GetAllVariables get all variables
// Returns all system settings from database
func (s *Service) GetAllVariables() ([]map[string]interface{}, error) {
// TODO: Implement with settings manager
return []map[string]interface{}{}, nil
settings, err := s.systemSettingsDAO.GetAll()
if err != nil {
return nil, err
}
result := make([]map[string]interface{}, 0, len(settings))
for _, setting := range settings {
result = append(result, map[string]interface{}{
"name": setting.Name,
"source": setting.Source,
"data_type": setting.DataType,
"value": setting.Value,
})
}
return result, nil
}
// SetVariable set variable
// Creates or updates a system setting
// If the setting exists, updates it; otherwise creates a new one
func (s *Service) SetVariable(varName, varValue string) error {
// TODO: Implement with settings manager
_ = varName
_ = varValue
return nil
settings, err := s.systemSettingsDAO.GetByName(varName)
if err != nil {
return err
}
if len(settings) == 1 {
setting := &settings[0]
setting.Value = varValue
return s.systemSettingsDAO.UpdateByName(varName, setting)
} else if len(settings) > 1 {
return NewAdminException("Can't update more than 1 setting: " + varName)
}
// Create new setting if it doesn't exist
// Determine data_type based on name and value
dataType := "string"
if len(varName) >= 7 && varName[:7] == "sandbox" {
dataType = "json"
} else if len(varName) >= 9 && varName[len(varName)-9:] == ".enabled" {
dataType = "boolean"
}
newSetting := &model.SystemSettings{
Name: varName,
Value: varValue,
Source: "admin",
DataType: dataType,
}
return s.systemSettingsDAO.Create(newSetting)
}
// Config methods
// GetAllConfigs get all configs
// Returns all service configurations from the config file
func (s *Service) GetAllConfigs() ([]map[string]interface{}, error) {
// TODO: Implement with config manager
return []map[string]interface{}{}, nil
result := server.GetAllConfigs()
return result, nil
}
// Environment methods
// GetAllEnvironments get all environments
// Returns important environment variables
func (s *Service) GetAllEnvironments() ([]map[string]interface{}, error) {
// TODO: Implement with environment manager
return []map[string]interface{}{}, nil
result := make([]map[string]interface{}, 0)
// DOC_ENGINE
docEngine := os.Getenv("DOC_ENGINE")
if docEngine == "" {
docEngine = "elasticsearch"
}
result = append(result, map[string]interface{}{
"env": "DOC_ENGINE",
"value": docEngine,
})
// DEFAULT_SUPERUSER_EMAIL
defaultSuperuserEmail := os.Getenv("DEFAULT_SUPERUSER_EMAIL")
if defaultSuperuserEmail == "" {
defaultSuperuserEmail = "admin@ragflow.io"
}
result = append(result, map[string]interface{}{
"env": "DEFAULT_SUPERUSER_EMAIL",
"value": defaultSuperuserEmail,
})
// DB_TYPE
dbType := os.Getenv("DB_TYPE")
if dbType == "" {
dbType = "mysql"
}
result = append(result, map[string]interface{}{
"env": "DB_TYPE",
"value": dbType,
})
// DEVICE
device := os.Getenv("DEVICE")
if device == "" {
device = "cpu"
}
result = append(result, map[string]interface{}{
"env": "DEVICE",
"value": device,
})
// STORAGE_IMPL
storageImpl := os.Getenv("STORAGE_IMPL")
if storageImpl == "" {
storageImpl = "MINIO"
}
result = append(result, map[string]interface{}{
"env": "STORAGE_IMPL",
"value": storageImpl,
})
return result, nil
}
// Version methods