Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

Fix user detail show not work (#19719)

Wang Qi81c2b80ce200
diff --git a/internal/admin/handler.go b/internal/admin/handler.go
index 3393c779e9..e0aaccdaea 100644
--- a/internal/admin/handler.go
+++ b/internal/admin/handler.go
@@ -287,7 +287,7 @@ func (h *Handler) GetUser(c *gin.Context) {
return
}
- userDetails, err := h.service.GetUserDetails(username)
+ userDetails, err := h.service.GetUserDetails(c.Request.Context(), username)
if err != nil {
if errors.Is(err, common.ErrUserNotFound) {
common.ErrorWithCode(c, common.CodeNotFound, "User not found")
@@ -297,7 +297,7 @@ func (h *Handler) GetUser(c *gin.Context) {
return
}
- common.SuccessWithData(c, userDetails, "")
+ common.SuccessWithData(c, []map[string]interface{}{userDetails}, "")
}
// DeleteUser handle delete user
diff --git a/internal/admin/handler_ee.go b/internal/admin/handler_ee.go
index d96a2be36f..163738ab40 100644
--- a/internal/admin/handler_ee.go
+++ b/internal/admin/handler_ee.go
@@ -1092,6 +1092,10 @@ func (h *Handler) ListUserDatasets(c *gin.Context) {
datasets, err := h.service.ListUserDatasets(ctx, username)
if err != nil {
+ if errors.Is(err, common.ErrUserNotFound) {
+ common.ErrorWithCode(c, common.CodeNotFound, "User not found")
+ return
+ }
common.ErrorWithCode(c, common.CodeServerError, err.Error())
return
}
@@ -1109,6 +1113,10 @@ func (h *Handler) ListUserAgents(c *gin.Context) {
agents, err := h.service.ListUserAgents(ctx, username)
if err != nil {
+ if errors.Is(err, common.ErrUserNotFound) {
+ common.ErrorWithCode(c, common.CodeNotFound, "User not found")
+ return
+ }
common.ErrorWithCode(c, common.CodeServerError, err.Error())
return
}
diff --git a/internal/admin/service.go b/internal/admin/service.go
index b00d771ae5..c30ea1ce17 100644
--- a/internal/admin/service.go
+++ b/internal/admin/service.go
@@ -40,6 +40,7 @@ import (
"time"
"go.uber.org/zap"
+ "gorm.io/gorm"
)
// Service admin service layer
@@ -475,22 +476,27 @@ func (s *Service) getInitTenantLLM(ctx context.Context, userID string) ([]*entit
}
// GetUserDetails get user details
-func (s *Service) GetUserDetails(username string) (map[string]interface{}, error) {
- // Query user by email/username
- var user entity.User
- err := dao.DB.Where("email = ?", username).First(&user).Error
+func (s *Service) GetUserDetails(ctx context.Context, username string) (map[string]interface{}, error) {
+ user, err := s.userDAO.GetByEmail(ctx, dao.DB, username)
if err != nil {
- return nil, common.ErrUserNotFound
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.ErrUserNotFound
+ }
+ return nil, fmt.Errorf("failed to get user: %w", err)
}
return map[string]interface{}{
- "id": user.ID,
- "email": user.Email,
- "nickname": user.Nickname,
- "is_active": user.IsActive,
- "is_superuser": user.IsSuperuser,
- "create_time": user.CreateTime,
- "update_time": user.UpdateTime,
+ "avatar": user.Avatar,
+ "email": user.Email,
+ "language": user.Language,
+ "last_login_time": user.LastLoginTime,
+ "is_active": user.IsActive,
+ "is_anonymous": user.IsAnonymous,
+ "login_channel": user.LoginChannel,
+ "status": user.Status,
+ "is_superuser": user.IsSuperuser,
+ "create_date": user.CreateDate,
+ "update_date": user.UpdateDate,
}, nil
}
@@ -873,18 +879,6 @@ func (s *Service) RevokeAdmin(ctx context.Context, username string) error {
return nil
}
-// GetUserDatasets get user datasets
-func (s *Service) GetUserDatasets(username string) ([]map[string]interface{}, error) {
- // TODO: Implement get user datasets
- return []map[string]interface{}{}, nil
-}
-
-// GetUserAgents get user agents
-func (s *Service) GetUserAgents(username string) ([]map[string]interface{}, error) {
- // TODO: Implement get user agents
- return []map[string]interface{}{}, nil
-}
-
// API Key methods
// ListUserAPITokens get user API keys
diff --git a/internal/admin/service_ee.go b/internal/admin/service_ee.go
index 1a00c8a15d..b127d1ed5f 100644
--- a/internal/admin/service_ee.go
+++ b/internal/admin/service_ee.go
@@ -21,9 +21,13 @@ import (
"errors"
"fmt"
"mime/multipart"
+ "strings"
+
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
+
+ "gorm.io/gorm"
)
func UpdateServer(serverName string, status *common.BaseMessage) (common.ErrorCode, string) {
@@ -570,43 +574,79 @@ func (s *Service) ShowUserPermission(ctx context.Context, email string) (map[str
// ListUserDatasets show user datasets for enterprise edition
func (s *Service) ListUserDatasets(ctx context.Context, email string) ([]map[string]interface{}, error) {
- // Query user by email
- var user entity.User
- err := dao.DB.Where("email = ?", email).First(&user).Error
+ user, err := s.userDAO.GetByEmail(ctx, dao.DB, email)
if err != nil {
- return nil, common.ErrUserNotFound
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.ErrUserNotFound
+ }
+ return nil, fmt.Errorf("failed to get user: %w", err)
}
- result := []map[string]interface{}{
- {
- "command": "list_user_datasets",
- "email": user.Email,
- "nickname": user.Nickname,
- "error": "'list user datasets' is not supported",
- },
+ tenantIDs, err := s.userTenantDAO.GetTenantIDsByUserID(ctx, dao.DB, user.ID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get user tenants: %w", err)
}
+ datasets, err := s.kbDAO.GetAllByTenantIDs(ctx, dao.DB, tenantIDs, user.ID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get user datasets: %w", err)
+ }
+
+ result := make([]map[string]interface{}, 0, len(datasets))
+ for _, dataset := range datasets {
+ status := ""
+ if dataset.Status != nil {
+ status = *dataset.Status
+ }
+ result = append(result, map[string]interface{}{
+ "name": dataset.Name,
+ "avatar": dataset.Avatar,
+ "language": dataset.Language,
+ "permission": dataset.Permission,
+ "doc_num": dataset.DocNum,
+ "token_num": dataset.TokenNum,
+ "chunk_num": dataset.ChunkNum,
+ "status": status,
+ "create_date": dataset.CreateDate,
+ "update_date": dataset.UpdateDate,
+ })
+ }
return result, nil
}
// ListUserAgents show user agents for enterprise edition
func (s *Service) ListUserAgents(ctx context.Context, email string) ([]map[string]interface{}, error) {
- // Query user by email
- var user entity.User
- err := dao.DB.Where("email = ?", email).First(&user).Error
+ user, err := s.userDAO.GetByEmail(ctx, dao.DB, email)
if err != nil {
- return nil, common.ErrUserNotFound
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.ErrUserNotFound
+ }
+ return nil, fmt.Errorf("failed to get user: %w", err)
}
- result := []map[string]interface{}{
- {
- "command": "list_user_agents",
- "email": user.Email,
- "nickname": user.Nickname,
- "error": "'list user agents' is not supported",
- },
+ tenantIDs, err := s.userTenantDAO.GetTenantIDsByUserID(ctx, dao.DB, user.ID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get user tenants: %w", err)
+ }
+
+ agents, err := s.canvasDAO.GetAllCanvasesByTenantIDs(ctx, dao.DB, tenantIDs, user.ID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get user agents: %w", err)
}
+ result := make([]map[string]interface{}, 0, len(agents))
+ for _, agent := range agents {
+ title := ""
+ if agent.Title != nil {
+ title = *agent.Title
+ }
+ result = append(result, map[string]interface{}{
+ "title": title,
+ "permission": agent.Permission,
+ "canvas_category": strings.SplitN(agent.CanvasCategory, "_", 2)[0],
+ "avatar": agent.Avatar,
+ })
+ }
return result, nil
}
diff --git a/internal/admin/user_detail_test.go b/internal/admin/user_detail_test.go
new file mode 100644
index 0000000000..d27fa19cfa
--- /dev/null
+++ b/internal/admin/user_detail_test.go
@@ -0,0 +1,210 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package admin
+
+import (
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "ragflow/internal/common"
+ "ragflow/internal/entity"
+ "ragflow/internal/ingestion/testutil"
+
+ "github.com/gin-gonic/gin"
+)
+
+type adminTestResponse struct {
+ Code int `json:"code"`
+ Data json.RawMessage `json:"data"`
+}
+
+func setupAdminUserDetailTest(t *testing.T) *Handler {
+ t.Helper()
+ db := testutil.SetupTestDB(t,
+ &entity.User{},
+ &entity.UserTenant{},
+ &entity.Knowledgebase{},
+ &entity.UserCanvas{},
+ )
+ t.Cleanup(testutil.ReplaceDBForTest(t, db))
+
+ now := time.Date(2026, time.September, 16, 12, 0, 0, 0, time.UTC)
+ isSuperuser := false
+ statusValid := string(entity.StatusValid)
+ language := "English"
+ loginChannel := "password"
+ user := entity.User{
+ ID: "user-1",
+ Nickname: "User One",
+ Email: "[email protected]",
+ Language: &language,
+ IsAuthenticated: "1",
+ IsActive: "1",
+ IsAnonymous: "0",
+ LoginChannel: &loginChannel,
+ Status: &statusValid,
+ IsSuperuser: &isSuperuser,
+ BaseModel: entity.BaseModel{CreateDate: &now, UpdateDate: &now},
+ }
+ if err := db.Create(&user).Error; err != nil {
+ t.Fatalf("create user: %v", err)
+ }
+
+ membership := entity.UserTenant{
+ ID: "membership-1",
+ UserID: user.ID,
+ TenantID: "tenant-2",
+ Role: "normal",
+ InvitedBy: "tenant-2",
+ Status: &statusValid,
+ }
+ if err := db.Create(&membership).Error; err != nil {
+ t.Fatalf("create membership: %v", err)
+ }
+
+ datasets := []entity.Knowledgebase{
+ {ID: "dataset-own", TenantID: user.ID, Name: "Own dataset", EmbdID: "embedding", Permission: "me", CreatedBy: user.ID, Status: &statusValid},
+ {ID: "dataset-team", TenantID: "tenant-2", Name: "Team dataset", EmbdID: "embedding", Permission: "team", CreatedBy: "tenant-2", Status: &statusValid},
+ {ID: "dataset-private", TenantID: "tenant-2", Name: "Private dataset", EmbdID: "embedding", Permission: "me", CreatedBy: "tenant-2", Status: &statusValid},
+ {ID: "dataset-invalid", TenantID: user.ID, Name: "Invalid dataset", EmbdID: "embedding", Permission: "me", CreatedBy: user.ID, Status: testutil.StrPtr(string(entity.StatusInvalid))},
+ }
+ if err := db.Create(&datasets).Error; err != nil {
+ t.Fatalf("create datasets: %v", err)
+ }
+
+ agents := []entity.UserCanvas{
+ {ID: "agent-own", UserID: user.ID, Title: testutil.StrPtr("Own agent"), Permission: "me", CanvasCategory: "agent_canvas"},
+ {ID: "agent-team", UserID: "tenant-2", Title: testutil.StrPtr("Team agent"), Permission: "team", CanvasCategory: "agent_canvas"},
+ {ID: "agent-private", UserID: "tenant-2", Title: testutil.StrPtr("Private agent"), Permission: "me", CanvasCategory: "agent_canvas"},
+ }
+ if err := db.Create(&agents).Error; err != nil {
+ t.Fatalf("create agents: %v", err)
+ }
+
+ return NewHandler(NewService())
+}
+
+func callAdminUserHandler(t *testing.T, handler func(*gin.Context)) adminTestResponse {
+ t.Helper()
+ recorder := httptest.NewRecorder()
+ ctx, _ := gin.CreateTestContext(recorder)
+ ctx.Params = gin.Params{{Key: "username", Value: "[email protected]"}}
+ ctx.Request = httptest.NewRequest(http.MethodGet, "/", nil)
+ handler(ctx)
+
+ var response adminTestResponse
+ if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+ t.Fatalf("decode response: %v", err)
+ }
+ if response.Code != int(common.CodeSuccess) {
+ t.Fatalf("response code = %d, want %d; body = %s", response.Code, common.CodeSuccess, recorder.Body.String())
+ }
+ return response
+}
+
+func TestGetUserReturnsPythonCompatibleDetailList(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ handler := setupAdminUserDetailTest(t)
+ response := callAdminUserHandler(t, handler.GetUser)
+
+ var details []struct {
+ Email string `json:"email"`
+ IsActive string `json:"is_active"`
+ CreateDate string `json:"create_date"`
+ IsAnonymous string `json:"is_anonymous"`
+ }
+ if err := json.Unmarshal(response.Data, &details); err != nil {
+ t.Fatalf("decode user details: %v", err)
+ }
+ if len(details) != 1 {
+ t.Fatalf("user details length = %d, want 1", len(details))
+ }
+ if details[0].Email != "[email protected]" || details[0].IsActive != "1" || details[0].CreateDate == "" || details[0].IsAnonymous != "0" {
+ t.Fatalf("unexpected user details: %+v", details[0])
+ }
+}
+
+func TestListUserDatasetsReturnsAccessibleDatasets(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ handler := setupAdminUserDetailTest(t)
+ response := callAdminUserHandler(t, handler.ListUserDatasets)
+
+ var datasets []struct {
+ Name string `json:"name"`
+ Permission string `json:"permission"`
+ Status string `json:"status"`
+ }
+ if err := json.Unmarshal(response.Data, &datasets); err != nil {
+ t.Fatalf("decode datasets: %v", err)
+ }
+ if len(datasets) != 2 {
+ t.Fatalf("datasets length = %d, want 2: %+v", len(datasets), datasets)
+ }
+ datasetsByName := make(map[string]struct {
+ Permission string
+ Status string
+ }, len(datasets))
+ for _, dataset := range datasets {
+ datasetsByName[dataset.Name] = struct {
+ Permission string
+ Status string
+ }{Permission: dataset.Permission, Status: dataset.Status}
+ }
+ if dataset := datasetsByName["Own dataset"]; dataset.Permission != "me" || dataset.Status != "1" {
+ t.Fatalf("unexpected own dataset: %+v", dataset)
+ }
+ if dataset := datasetsByName["Team dataset"]; dataset.Permission != "team" || dataset.Status != "1" {
+ t.Fatalf("unexpected team dataset: %+v", dataset)
+ }
+}
+
+func TestListUserAgentsReturnsAccessibleAgents(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ handler := setupAdminUserDetailTest(t)
+ response := callAdminUserHandler(t, handler.ListUserAgents)
+
+ var agents []struct {
+ Title string `json:"title"`
+ Permission string `json:"permission"`
+ CanvasCategory string `json:"canvas_category"`
+ }
+ if err := json.Unmarshal(response.Data, &agents); err != nil {
+ t.Fatalf("decode agents: %v", err)
+ }
+ if len(agents) != 2 {
+ t.Fatalf("agents length = %d, want 2: %+v", len(agents), agents)
+ }
+ agentsByTitle := make(map[string]struct {
+ Permission string
+ CanvasCategory string
+ }, len(agents))
+ for _, agent := range agents {
+ agentsByTitle[agent.Title] = struct {
+ Permission string
+ CanvasCategory string
+ }{Permission: agent.Permission, CanvasCategory: agent.CanvasCategory}
+ }
+ if agent := agentsByTitle["Own agent"]; agent.Permission != "me" || agent.CanvasCategory != "agent" {
+ t.Fatalf("unexpected own agent: %+v", agent)
+ }
+ if agent := agentsByTitle["Team agent"]; agent.Permission != "team" || agent.CanvasCategory != "agent" {
+ t.Fatalf("unexpected team agent: %+v", agent)
+ }
+}
diff --git a/internal/dao/kb.go b/internal/dao/kb.go
index 14961d9fce..92e4d4b804 100644
--- a/internal/dao/kb.go
+++ b/internal/dao/kb.go
@@ -300,8 +300,8 @@ func (dao *KnowledgebaseDAO) GetAllByTenantIDs(ctx context.Context, db *gorm.DB,
var kbs []*entity.Knowledgebase
err := db.WithContext(ctx).Where(
- "(tenant_id IN ? AND permission = ?) OR tenant_id = ?",
- tenantIDs, string(entity.TenantPermissionTeam), userID,
+ "((tenant_id IN ? AND permission = ?) OR tenant_id = ?) AND status = ?",
+ tenantIDs, string(entity.TenantPermissionTeam), userID, string(entity.StatusValid),
).Order("create_time ASC").Find(&kbs).Error
return kbs, err