Skip to content

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

feat(permission): enforce tenant and resource access (#21377)

buua436e4ab718ca62a
diff --git a/internal/admin/service.go b/internal/admin/service.go
index 98eae5e44c..15c136fbc8 100644
--- a/internal/admin/service.go
+++ b/internal/admin/service.go
@@ -265,13 +265,6 @@ func (s *Service) CreateUser(ctx context.Context, username, password, role strin
tenant := &entity.Tenant{
ID: userID,
Name: &tenantName,
- LLMID: chatModel,
- EmbdID: embeddingModel,
- ASRID: asrModel,
- Img2TxtID: vlmModel,
- RerankID: rerankModel,
- TTSID: ttsModel,
- OCRID: ocrModel,
ParserIDs: parserIDs,
Credit: 512,
Status: &tenantStatus,
@@ -294,6 +287,13 @@ func (s *Service) CreateUser(ctx context.Context, username, password, role strin
Role: "owner",
InvitedBy: userID,
Status: &userTenantStatus,
+ LLMID: chatModel,
+ EmbdID: embeddingModel,
+ ASRID: asrModel,
+ Img2TxtID: vlmModel,
+ RerankID: rerankModel,
+ TTSID: ttsModel,
+ OCRID: ocrModel,
}
if err = tx.Create(userTenant).Error; err != nil {
rollbackTx()
diff --git a/internal/admin/user_delete_test.go b/internal/admin/user_delete_test.go
index f8b8b6db28..3f5fb3f41f 100644
--- a/internal/admin/user_delete_test.go
+++ b/internal/admin/user_delete_test.go
@@ -147,8 +147,8 @@ func TestDeleteUserRemovesOwnedDataAndJoinedDocuments(t *testing.T) {
}
insert("INSERT INTO user (id, email, nickname, is_active, is_authenticated, is_anonymous) VALUES (?, ?, ?, ?, ?, ?)", "user-1", "[email protected]", "User", "0", "1", "0")
insert("INSERT INTO user (id, email, nickname, is_active, is_authenticated, is_anonymous) VALUES (?, ?, ?, ?, ?, ?)", "user-2", "[email protected]", "Other", "1", "1", "0")
- insert("INSERT INTO tenant (id, llm_id, embd_id, asr_id, img2txt_id, rerank_id, parser_ids) VALUES (?, ?, ?, ?, ?, ?, ?)", "user-1", "llm", "embd", "asr", "img", "rerank", "general")
- insert("INSERT INTO user_tenant (id, user_id, tenant_id, role, invited_by) VALUES (?, ?, ?, ?, ?)", "owner", "user-1", "user-1", "owner", "user-1")
+ insert("INSERT INTO tenant (id, parser_ids) VALUES (?, ?)", "user-1", "general")
+ insert("INSERT INTO user_tenant (id, user_id, tenant_id, role, invited_by, llm_id, embd_id, asr_id, img2txt_id, rerank_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", "owner", "user-1", "user-1", "owner", "user-1", "llm", "embd", "asr", "img", "rerank")
insert("INSERT INTO user_tenant (id, user_id, tenant_id, role, invited_by) VALUES (?, ?, ?, ?, ?)", "joined", "user-1", "team", "normal", "user-2")
insert("INSERT INTO knowledgebase (id, tenant_id, name, embd_id, permission, created_by, parser_id, doc_num, token_num, chunk_num) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", "own-kb", "user-1", "Own", "embd", "me", "user-1", "general", 1, 2, 3)
insert("INSERT INTO knowledgebase (id, tenant_id, name, embd_id, permission, created_by, parser_id, doc_num, token_num, chunk_num) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", "team-kb", "team", "Team", "embd", "team", "user-2", "general", 2, 5, 7)
diff --git a/internal/agentic_rag/decision_config.go b/internal/agentic_rag/decision_config.go
index 4831d990de..cc126c2e4a 100644
--- a/internal/agentic_rag/decision_config.go
+++ b/internal/agentic_rag/decision_config.go
@@ -33,7 +33,7 @@ import (
// The judge used to be a process-wide singleton built from the environment.
// It is now resolved per run from what the operator configured in the UI:
//
-// chat.decision_id -> tenant.decision_id -> the env-configured backend
+// chat.decision_id -> user_tenant.decision_id -> the env-configured backend
//
// The env backend stays as the last step so an existing deployment keeps its
// behaviour until it configures a model in the UI, and so a run that carries no
@@ -144,9 +144,9 @@ func decisionModelIDFor(ctx context.Context, scope decisionScope) string {
}
}
if scope.tenantID != "" {
- var tenant entity.Tenant
- if err := dao.DB.Where("id = ?", scope.tenantID).First(&tenant).Error; err == nil {
- if id := resolvedDecisionID(tenant.TenantDecisionID, tenant.DecisionID); id != "" {
+ membership, err := dao.NewUserTenantDAO().GetOwnerByTenantID(ctx, dao.DB, scope.tenantID)
+ if err == nil && membership != nil {
+ if id := resolvedDecisionID(membership.TenantDecisionID, membership.DecisionID); id != "" {
return id
}
}
diff --git a/internal/agentic_rag/decision_config_test.go b/internal/agentic_rag/decision_config_test.go
index 88fe4ed26b..d8cfb51a65 100644
--- a/internal/agentic_rag/decision_config_test.go
+++ b/internal/agentic_rag/decision_config_test.go
@@ -112,6 +112,7 @@ func setupDecisionConfigDB(t *testing.T) {
}
if err := db.AutoMigrate(
&entity.Tenant{},
+ &entity.UserTenant{},
&entity.Chat{},
&entity.TenantModelProvider{},
&entity.TenantModelInstance{},
@@ -124,6 +125,17 @@ func setupDecisionConfigDB(t *testing.T) {
t.Cleanup(func() { dao.DB = orig })
}
+func seedTenantDecisionDefault(t *testing.T, db *gorm.DB, tenantID string, decisionID string, tenantDecisionID *string) {
+ t.Helper()
+ status := entity.TenantMembershipStatusJoined
+ if err := db.Create(&entity.UserTenant{
+ ID: "owner-" + tenantID, UserID: tenantID, TenantID: tenantID, Role: "owner", Status: &status,
+ DecisionID: &decisionID, TenantDecisionID: tenantDecisionID,
+ }).Error; err != nil {
+ t.Fatalf("seed owner model settings: %v", err)
+ }
+}
+
func seedDecisionModel(t *testing.T, db *gorm.DB, tenantID, modelName string, modelType int) (providerID, instanceID, modelID string) {
t.Helper()
tag := strings.ReplaceAll(t.Name(), "/", "-")
@@ -148,9 +160,7 @@ func TestResolveDecisionBackendUsesTenantDefault(t *testing.T) {
setupDecisionConfigDB(t)
db := dao.DB
_, _, modelID := seedDecisionModel(t, db, "tenant-1", "decision-model-preview", int(entity.ModelTypeDecision))
- if err := db.Create(&entity.Tenant{ID: "tenant-1", DecisionID: &modelID}).Error; err != nil {
- t.Fatalf("seed tenant: %v", err)
- }
+ seedTenantDecisionDefault(t, db, "tenant-1", modelID, nil)
if err := db.Create(&entity.Chat{ID: "chat-1", TenantID: "tenant-1", LLMSetting: entity.JSONMap{}, PromptConfig: entity.JSONMap{}, KBIDs: entity.JSONSlice{}}).Error; err != nil {
t.Fatalf("seed chat: %v", err)
}
@@ -176,9 +186,7 @@ func TestResolveDecisionBackendPrefersChatOverride(t *testing.T) {
db := dao.DB
_, _, tenantModel := seedDecisionModel(t, db, "tenant-1", "tenant-model", int(entity.ModelTypeDecision))
_, _, chatModel := seedDecisionModel(t, db, "tenant-1", "chat-model", int(entity.ModelTypeDecision))
- if err := db.Create(&entity.Tenant{ID: "tenant-1", DecisionID: &tenantModel}).Error; err != nil {
- t.Fatalf("seed tenant: %v", err)
- }
+ seedTenantDecisionDefault(t, db, "tenant-1", tenantModel, nil)
if err := db.Create(&entity.Chat{ID: "chat-1", TenantID: "tenant-1", LLMSetting: entity.JSONMap{}, PromptConfig: entity.JSONMap{}, KBIDs: entity.JSONSlice{}, DecisionID: &chatModel}).Error; err != nil {
t.Fatalf("seed chat: %v", err)
}
@@ -195,9 +203,7 @@ func TestResolveDecisionBackendRejectsWrongModelType(t *testing.T) {
setupDecisionConfigDB(t)
db := dao.DB
_, _, modelID := seedDecisionModel(t, db, "tenant-1", "chat-model", int(entity.ModelTypeChat))
- if err := db.Create(&entity.Tenant{ID: "tenant-1", DecisionID: &modelID}).Error; err != nil {
- t.Fatalf("seed tenant: %v", err)
- }
+ seedTenantDecisionDefault(t, db, "tenant-1", modelID, nil)
srv := decisionStub(t, []float64{0.9, 0.9, 0.9, 0.9}, 200, nil)
defer srv.Close()
@@ -213,9 +219,7 @@ func TestResolveDecisionBackendRejectsForeignTenant(t *testing.T) {
setupDecisionConfigDB(t)
db := dao.DB
_, _, modelID := seedDecisionModel(t, db, "tenant-2", "decision-model-preview", int(entity.ModelTypeDecision))
- if err := db.Create(&entity.Tenant{ID: "tenant-1", DecisionID: &modelID}).Error; err != nil {
- t.Fatalf("seed tenant: %v", err)
- }
+ seedTenantDecisionDefault(t, db, "tenant-1", modelID, nil)
srv := decisionStub(t, []float64{0.9, 0.9, 0.9, 0.9}, 200, nil)
defer srv.Close()
@@ -234,9 +238,7 @@ func TestDecisionModelIDPrefersResolvedRowID(t *testing.T) {
db := dao.DB
_, _, modelID := seedDecisionModel(t, db, "tenant-1", "resolved", int(entity.ModelTypeDecision))
composite := "resolved@systemone@chat"
- if err := db.Create(&entity.Tenant{ID: "tenant-1", DecisionID: &composite, TenantDecisionID: &modelID}).Error; err != nil {
- t.Fatalf("seed tenant: %v", err)
- }
+ seedTenantDecisionDefault(t, db, "tenant-1", composite, &modelID)
got := decisionModelIDFor(context.Background(), decisionScope{tenantID: "tenant-1"})
if got != modelID {
@@ -249,9 +251,7 @@ func TestDecisionModelIDFallsBackToRequestedValue(t *testing.T) {
setupDecisionConfigDB(t)
db := dao.DB
_, _, modelID := seedDecisionModel(t, db, "tenant-1", "legacy", int(entity.ModelTypeDecision))
- if err := db.Create(&entity.Tenant{ID: "tenant-1", DecisionID: &modelID}).Error; err != nil {
- t.Fatalf("seed tenant: %v", err)
- }
+ seedTenantDecisionDefault(t, db, "tenant-1", modelID, nil)
if got := decisionModelIDFor(context.Background(), decisionScope{tenantID: "tenant-1"}); got != modelID {
t.Errorf("model id = %q, want %q", got, modelID)
@@ -270,9 +270,7 @@ func TestDecisionBackendCacheIsScopedToTenant(t *testing.T) {
_, _, modelID := seedDecisionModel(t, db, "tenant-a", "shared", int(entity.ModelTypeDecision))
for _, tenantID := range []string{"tenant-a", "tenant-b"} {
id := modelID
- if err := db.Create(&entity.Tenant{ID: tenantID, TenantDecisionID: &id}).Error; err != nil {
- t.Fatalf("seed tenant %s: %v", tenantID, err)
- }
+ seedTenantDecisionDefault(t, db, tenantID, "", &id)
}
if got := resolveDecisionBackend(withDecisionScope(context.Background(), "tenant-a", "")); got == nil {
diff --git a/internal/dao/database.go b/internal/dao/database.go
index 43c3b02a9b..9aafa1694e 100644
--- a/internal/dao/database.go
+++ b/internal/dao/database.go
@@ -261,6 +261,9 @@ func InitDB(ctx context.Context, migrateDB bool) error {
if err = migratePermissions(ctx, DB); err != nil {
return fmt.Errorf("failed to migrate permissions: %w", err)
}
+ if err = migrateTenantDefaultModels(ctx, DB); err != nil {
+ return fmt.Errorf("failed to migrate tenant default models: %w", err)
+ }
if err = migrateTenantModelProviderUserUniqueIndex(ctx, DB); err != nil {
return fmt.Errorf("failed to migrate tenant model provider unique index: %w", err)
}
diff --git a/internal/dao/document.go b/internal/dao/document.go
index bb3f3c8bbc..32b649542d 100644
--- a/internal/dao/document.go
+++ b/internal/dao/document.go
@@ -397,12 +397,13 @@ func (dao *DocumentDAO) GetChunkingConfig(ctx context.Context, db *gorm.DB, docI
knowledgebase.language,
knowledgebase.embd_id,
tenant.id AS tenant_id,
- tenant.img2txt_id,
- tenant.asr_id,
- tenant.llm_id
+ user_tenant.img2txt_id,
+ user_tenant.asr_id,
+ user_tenant.llm_id
`).
Joins("JOIN knowledgebase ON document.kb_id = knowledgebase.id").
Joins("JOIN tenant ON knowledgebase.tenant_id = tenant.id").
+ Joins("LEFT JOIN user_tenant ON user_tenant.id = (SELECT id FROM user_tenant WHERE tenant_id = tenant.id AND status = '1' AND (role = 'owner' OR user_id = tenant.id) ORDER BY CASE WHEN role = 'owner' THEN 0 ELSE 1 END LIMIT 1)").
Where("document.id = ?", docID).
Take(&row).Error
if err != nil {
diff --git a/internal/dao/document_test.go b/internal/dao/document_test.go
index f127c33883..56502e1b8a 100644
--- a/internal/dao/document_test.go
+++ b/internal/dao/document_test.go
@@ -39,6 +39,7 @@ func setupDocumentTestDB(t *testing.T) *gorm.DB {
&entity.Document{},
&entity.Knowledgebase{},
&entity.Tenant{},
+ &entity.UserTenant{},
); err != nil {
t.Fatalf("failed to migrate: %v", err)
}
@@ -506,17 +507,16 @@ func TestDocumentGetByDocumentIDAndDatasetIDUsesKBID(t *testing.T) {
func TestDocumentGetChunkingConfigScansParserConfig(t *testing.T) {
db := setupDocumentTestDB(t)
- if err := db.Create(&entity.Tenant{
- ID: "tenant1",
- LLMID: "llm1",
- EmbdID: "embd1",
- ASRID: "asr1",
- Img2TxtID: "img2txt1",
- RerankID: "rerank1",
- ParserIDs: "naive",
- }).Error; err != nil {
+ if err := db.Create(&entity.Tenant{ID: "tenant1", ParserIDs: "naive"}).Error; err != nil {
t.Fatalf("create tenant: %v", err)
}
+ joined := entity.TenantMembershipStatusJoined
+ if err := db.Create(&entity.UserTenant{
+ ID: "ut-tenant1", UserID: "tenant1", TenantID: "tenant1", Role: "owner", Status: &joined,
+ LLMID: "llm1", EmbdID: "embd1", ASRID: "asr1", Img2TxtID: "img2txt1", RerankID: "rerank1",
+ }).Error; err != nil {
+ t.Fatalf("create owner membership: %v", err)
+ }
if err := db.Create(&entity.Knowledgebase{
ID: "kb1",
TenantID: "tenant1",
diff --git a/internal/dao/file.go b/internal/dao/file.go
index 0988e90033..387519fa73 100644
--- a/internal/dao/file.go
+++ b/internal/dao/file.go
@@ -67,25 +67,19 @@ func (dao *FileDAO) GetByIDAndTenant(ctx context.Context, db *gorm.DB, id, tenan
// When keywords is empty, only direct children of pfID are listed; when
// keywords is non-empty, the search covers the whole subtree under pfID so
// files and folders nested in sub-folders can be found too.
-func (dao *FileDAO) GetByPfID(ctx context.Context, db *gorm.DB, tenantID, pfID string, page, pageSize int, terms []OrderTerm, keywords string, excludeSkills bool) ([]*entity.File, int64, error) {
+func (dao *FileDAO) GetByPfID(ctx context.Context, db *gorm.DB, tenantID, pfID string, page, pageSize int, terms []OrderTerm, keywords string, excludeSkills bool, visibilityScopes ...func(*gorm.DB) *gorm.DB) ([]*entity.File, int64, error) {
var files []*entity.File
var total int64
-
- query := db.WithContext(ctx).Model(&entity.File{}).
- Where("tenant_id = ? AND id != ?", tenantID, pfID)
-
- if keywords != "" {
- descendantIDs, err := dao.GetSubtreeIDs(ctx, db, tenantID, pfID)
- if err != nil {
- return nil, 0, err
- }
- query = query.Where("parent_id IN ?", descendantIDs).
- Where("LOWER(name) LIKE ?", "%"+strings.ToLower(keywords)+"%")
- } else {
- query = query.Where("parent_id = ?", pfID)
+ query, err := dao.fileListQuery(ctx, db, tenantID, pfID, keywords, excludeSkills)
+ if err != nil {
+ return nil, 0, err
}
- if excludeSkills {
- query = query.Where("NOT (parent_id = ? AND name = ?)", pfID, SkillsFolderName)
+ if len(visibilityScopes) > 0 {
+ if visibilityScopes[0] == nil {
+ query = query.Where("1 = 0")
+ } else {
+ query = visibilityScopes[0](query)
+ }
}
// Count total
@@ -115,6 +109,68 @@ func (dao *FileDAO) GetByPfID(ctx context.Context, db *gorm.DB, tenantID, pfID s
return files, total, nil
}
+func (dao *FileDAO) fileListQuery(ctx context.Context, db *gorm.DB, tenantID, pfID, keywords string, excludeSkills bool) (*gorm.DB, error) {
+ query := db.WithContext(ctx).Model(&entity.File{}).
+ Where("tenant_id = ? AND id != ?", tenantID, pfID)
+ if keywords != "" {
+ descendantIDs, err := dao.GetSubtreeIDs(ctx, db, tenantID, pfID)
+ if err != nil {
+ return nil, err
+ }
+ query = query.Where("parent_id IN ?", descendantIDs).
+ Where("LOWER(name) LIKE ?", "%"+strings.ToLower(keywords)+"%")
+ } else {
+ query = query.Where("parent_id = ?", pfID)
+ }
+ if excludeSkills {
+ query = query.Where("NOT (parent_id = ? AND name = ?)", pfID, SkillsFolderName)
+ }
+ return query, nil
+}
+
+// ListDescendants loads every direct and nested entry under a folder. It walks
+// folder levels in batches so the caller can authorize a whole tree without a
+// database round trip for every node. Parent IDs are chunked to stay below
+// database parameter limits.
+func (dao *FileDAO) ListDescendants(ctx context.Context, db *gorm.DB, folderID string) ([]entity.File, error) {
+ const parentBatchSize = 500
+ if folderID == "" {
+ return nil, nil
+ }
+ seen := map[string]struct{}{folderID: {}}
+ frontier := []string{folderID}
+ descendants := make([]entity.File, 0)
+ for len(frontier) > 0 {
+ next := make([]string, 0)
+ for start := 0; start < len(frontier); start += parentBatchSize {
+ end := start + parentBatchSize
+ if end > len(frontier) {
+ end = len(frontier)
+ }
+ var children []entity.File
+ if err := db.WithContext(ctx).Model(&entity.File{}).
+ Select("id", "parent_id", "type").
+ Where("parent_id IN ?", frontier[start:end]).
+ Find(&children).Error; err != nil {
+ return nil, err
+ }
+ for i := range children {
+ child := children[i]
+ if _, exists := seen[child.ID]; exists {
+ continue
+ }
+ seen[child.ID] = struct{}{}
+ descendants = append(descendants, child)
+ if child.Type == "folder" {
+ next = append(next, child.ID)
+ }
+ }
+ }
+ frontier = next
+ }
+ return descendants, nil
+}
+
// GetSubtreeIDs returns pfID itself plus the IDs of all entries nested under
// it (folders and files), used to scope recursive keyword searches.
func (dao *FileDAO) GetSubtreeIDs(ctx context.Context, db *gorm.DB, tenantID, pfID string) ([]string, error) {
@@ -346,12 +402,12 @@ func (dao *FileDAO) GetIDListByID(ctx context.Context, db *gorm.DB, id string, n
}
// CreateFolder creates a folder in the database
-func (dao *FileDAO) CreateFolder(ctx context.Context, db *gorm.DB, parentID, tenantID, name, fileType string) (*entity.File, error) {
+func (dao *FileDAO) CreateFolder(ctx context.Context, db *gorm.DB, parentID, tenantID, createdBy, name, fileType string) (*entity.File, error) {
file := &entity.File{
ID: common.GenerateToken(),
ParentID: parentID,
TenantID: tenantID,
- CreatedBy: tenantID,
+ CreatedBy: createdBy,
Name: name,
Type: fileType,
Size: 0,
diff --git a/internal/dao/permission_migration.go b/internal/dao/permission_migration.go
index 40ed87aa16..929b47f786 100644
--- a/internal/dao/permission_migration.go
+++ b/internal/dao/permission_migration.go
@@ -26,7 +26,7 @@ import (
"gorm.io/gorm"
)
-const permissionMigrationTargetVersion = "v1.0.0-rc3.dev3"
+const permissionMigrationTargetVersion = "v1.0.0-rc3.dev4"
// migratePermissions applies the permission schema migration and records its version.
func migratePermissions(ctx context.Context, db *gorm.DB) error {
@@ -43,6 +43,9 @@ func migratePermissions(ctx context.Context, db *gorm.DB) error {
if shouldSkipMigration(version, permissionMigrationTargetVersion) {
return nil
}
+ if err := migrateLegacyTenantInvitationStatuses(ctx, db); err != nil {
+ return err
+ }
if err := migrateInvitedByNullable(ctx, db); err != nil {
return err
}
@@ -61,6 +64,21 @@ func migratePermissions(ctx context.Context, db *gorm.DB) error {
return nil
}
+func migrateLegacyTenantInvitationStatuses(ctx context.Context, db *gorm.DB) error {
+ scoped := db.WithContext(ctx)
+ migrator := scoped.Migrator()
+ if !migrator.HasTable(&entity.UserTenant{}) || !migrator.HasColumn(&entity.UserTenant{}, "role") || !migrator.HasColumn(&entity.UserTenant{}, "status") {
+ return nil
+ }
+ result := scoped.Model(&entity.UserTenant{}).
+ Where("role = ? AND (status = ? OR status IS NULL)", "invite", entity.TenantMembershipStatusJoined).
+ Updates(map[string]interface{}{"role": "", "status": entity.TenantMembershipStatusInvited})
+ if result.Error != nil {
+ return fmt.Errorf("migrate legacy Tenant invitations to pending status: %w", result.Error)
+ }
+ return nil
+}
+
// migrateUserTenantDuplicates removes duplicate legacy memberships before
// AutoMigrate creates the unique (user_id, tenant_id) index.
func migrateUserTenantDuplicates(ctx context.Context, db *gorm.DB) error {
diff --git a/internal/dao/permission_migration_test.go b/internal/dao/permission_migration_test.go
index 7ebc9de347..ceef198d7d 100644
--- a/internal/dao/permission_migration_test.go
+++ b/internal/dao/permission_migration_test.go
@@ -39,7 +39,8 @@ func TestMigratePermissions(t *testing.T) {
t.Fatalf("create existing membership table: %v", err)
}
if err := db.Exec(`INSERT INTO user_tenant (id, user_id, tenant_id, role, invited_by, status)
- VALUES ('membership-1', 'user-1', 'tenant-1', 'normal', 'owner-1', '1')`).Error; err != nil {
+ VALUES ('membership-1', 'user-1', 'tenant-1', 'normal', 'owner-1', '1'),
+ ('membership-owner', 'tenant-1', 'tenant-1', 'owner', '', '1')`).Error; err != nil {
t.Fatalf("create existing membership: %v", err)
}
if err := db.Exec(`CREATE TABLE api_token (tenant_id varchar(32) NOT NULL, token varchar(255) NOT NULL,
@@ -251,3 +252,44 @@ func TestMigrateUserTenantDuplicates(t *testing.T) {
t.Fatal("duplicate user_tenant membership was accepted after AutoMigrate")
}
}
+
+func TestMigrateLegacyTenantInvitationStatuses(t *testing.T) {
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+ if err != nil {
+ t.Fatalf("open database: %v", err)
+ }
+ if err := db.AutoMigrate(&entity.UserTenant{}); err != nil {
+ t.Fatalf("auto-migrate user_tenant: %v", err)
+ }
+ joined := entity.TenantMembershipStatusJoined
+ if err := db.Create(&entity.UserTenant{
+ ID: "invitation-1", UserID: "user-1", TenantID: "tenant-1", Role: "invite", Status: &joined,
+ }).Error; err != nil {
+ t.Fatalf("create legacy invitation: %v", err)
+ }
+ if err := db.Create(&entity.UserTenant{
+ ID: "member-1", UserID: "user-2", TenantID: "tenant-1", Role: "normal", Status: &joined,
+ }).Error; err != nil {
+ t.Fatalf("create joined member: %v", err)
+ }
+ if err := migrateLegacyTenantInvitationStatuses(t.Context(), db); err != nil {
+ t.Fatalf("migrate legacy invitations: %v", err)
+ }
+ var invitation, member entity.UserTenant
+ if err := db.Where("id = ?", "invitation-1").Take(&invitation).Error; err != nil {
+ t.Fatalf("read migrated invitation: %v", err)
+ }
+ if invitation.Role != "" || invitation.Status == nil || *invitation.Status != entity.TenantMembershipStatusInvited {
+ status := "<nil>"
+ if invitation.Status != nil {
+ status = *invitation.Status
+ }
+ t.Fatalf("legacy invitation = role %q status %q, want empty role and invited status", invitation.Role, status)
+ }
+ if err := db.Where("id = ?", "member-1").Take(&member).Error; err != nil {
+ t.Fatalf("read joined member: %v", err)
+ }
+ if member.Role != "normal" || member.Status == nil || *member.Status != entity.TenantMembershipStatusJoined {
+ t.Fatalf("joined member changed: role %q status %v", member.Role, member.Status)
+ }
+}
diff --git a/internal/dao/tenant.go b/internal/dao/tenant.go
index 236979de05..3f1398b21d 100644
--- a/internal/dao/tenant.go
+++ b/internal/dao/tenant.go
@@ -36,7 +36,7 @@ func (dao *TenantDAO) GetJoinedTenantsByUserID(ctx context.Context, db *gorm.DB,
var results []*TenantWithRole
err := db.WithContext(ctx).Model(&entity.Tenant{}).
- Select("tenant.id as tenant_id, tenant.name, tenant.llm_id, tenant.embd_id, tenant.asr_id, tenant.img2txt_id, user_tenant.role").
+ Select("tenant.id as tenant_id, tenant.name, user_tenant.role").
Joins("INNER JOIN user_tenant ON user_tenant.tenant_id = tenant.id").
Where("user_tenant.user_id = ? AND user_tenant.status = ? AND user_tenant.role = ? AND tenant.status = ?", userID, "1", "normal", "1").
Scan(&results).Error
@@ -46,50 +46,9 @@ func (dao *TenantDAO) GetJoinedTenantsByUserID(ctx context.Context, db *gorm.DB,
// TenantWithRole tenant with role information
type TenantWithRole struct {
- TenantID string `gorm:"column:tenant_id" json:"tenant_id"`
- Name string `gorm:"column:name" json:"name"`
- LLMID string `gorm:"column:llm_id" json:"llm_id"`
- EmbDID string `gorm:"column:embd_id" json:"embd_id"`
- ASRID string `gorm:"column:asr_id" json:"asr_id"`
- Img2TxtID string `gorm:"column:img2txt_id" json:"img2txt_id"`
- Role string `gorm:"column:role" json:"role"`
-}
-
-// TenantInfo tenant information with role (for owner tenant)
-type TenantInfo struct {
- TenantID string `gorm:"column:tenant_id" json:"tenant_id"`
- Name *string `gorm:"column:name" json:"name,omitempty"`
- LLMID string `gorm:"column:llm_id" json:"llm_id"`
- TenantLLMID *string `gorm:"column:tenant_llm_id" json:"tenant_llm_id,omitempty"`
- EmbDID string `gorm:"column:embd_id" json:"embd_id"`
- TenantEmbdID *string `gorm:"column:tenant_embd_id" json:"tenant_embd_id,omitempty"`
- RerankID string `gorm:"column:rerank_id" json:"rerank_id"`
- TenantRerankID *string `gorm:"column:tenant_rerank_id" json:"tenant_rerank_id,omitempty"`
- ASRID string `gorm:"column:asr_id" json:"asr_id"`
- TenantASRID *string `gorm:"column:tenant_asr_id" json:"tenant_asr_id,omitempty"`
- Img2TxtID string `gorm:"column:img2txt_id" json:"img2txt_id"`
- TenantImg2TxtID *string `gorm:"column:tenant_img2txt_id" json:"tenant_img2txt_id,omitempty"`
- TTSID string `gorm:"column:tts_id" json:"tts_id"`
- TenantTTSID *string `gorm:"column:tenant_tts_id" json:"tenant_tts_id,omitempty"`
- OCRID string `gorm:"column:ocr_id" json:"ocr_id,omitempty"`
- TenantOCRID *string `gorm:"column:tenant_ocr_id" json:"tenant_ocr_id,omitempty"`
- DecisionID *string `gorm:"column:decision_id" json:"decision_id,omitempty"`
- TenantDecisionID *string `gorm:"column:tenant_decision_id" json:"tenant_decision_id,omitempty"`
- ParserIDs string `gorm:"column:parser_ids" json:"parser_ids"`
- Role string `gorm:"column:role" json:"role"`
-}
-
-// GetInfoByUserID get tenant information for the owner tenant of a user
-func (dao *TenantDAO) GetInfoByUserID(ctx context.Context, db *gorm.DB, userID string) ([]*TenantInfo, error) {
- var results []*TenantInfo
-
- err := db.WithContext(ctx).Model(&entity.Tenant{}).
- Select("tenant.id as tenant_id, tenant.name, tenant.llm_id, tenant.tenant_llm_id, tenant.embd_id, tenant.tenant_embd_id, tenant.rerank_id, tenant.tenant_rerank_id, tenant.asr_id, tenant.tenant_asr_id, tenant.img2txt_id, tenant.tenant_img2txt_id, tenant.tts_id, tenant.tenant_tts_id, tenant.ocr_id, tenant.tenant_ocr_id, tenant.decision_id, tenant.tenant_decision_id, tenant.parser_ids, user_tenant.role").
- Joins("INNER JOIN user_tenant ON user_tenant.tenant_id = tenant.id").
- Where("user_tenant.user_id = ? AND user_tenant.status = ? AND user_tenant.role = ? AND tenant.status = ?", userID, "1", "owner", "1").
- Scan(&results).Error
-
- return results, err
+ TenantID string `gorm:"column:tenant_id" json:"tenant_id"`
+ Name string `gorm:"column:name" json:"name"`
+ Role string `gorm:"column:role" json:"role"`
}
// GetByID gets tenant by ID
diff --git a/internal/dao/tenant_default_models_migration.go b/internal/dao/tenant_default_models_migration.go
new file mode 100644
index 0000000000..c1003e2ba2
--- /dev/null
+++ b/internal/dao/tenant_default_models_migration.go
@@ -0,0 +1,155 @@
+//
+// 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 dao
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "ragflow/internal/entity"
+
+ "gorm.io/gorm"
+)
+
+const tenantDefaultModelsTargetVersion = "v1.0.0-rc3.dev5"
+
+var tenantDefaultModelColumns = []string{
+ "llm_id", "tenant_llm_id",
+ "embd_id", "tenant_embd_id",
+ "asr_id", "tenant_asr_id",
+ "img2txt_id", "tenant_img2txt_id",
+ "rerank_id", "tenant_rerank_id",
+ "tts_id", "tenant_tts_id",
+ "ocr_id", "tenant_ocr_id",
+ "decision_id", "tenant_decision_id",
+}
+
+type tenantDefaultModelsLegacySchema struct {
+ ID string `gorm:"column:id;primaryKey"`
+ LLMID string `gorm:"column:llm_id"`
+ TenantLLMID *string `gorm:"column:tenant_llm_id"`
+ EmbdID string `gorm:"column:embd_id"`
+ TenantEmbdID *string `gorm:"column:tenant_embd_id"`
+ ASRID string `gorm:"column:asr_id"`
+ TenantASRID *string `gorm:"column:tenant_asr_id"`
+ Img2TxtID string `gorm:"column:img2txt_id"`
+ TenantImg2TxtID *string `gorm:"column:tenant_img2txt_id"`
+ RerankID string `gorm:"column:rerank_id"`
+ TenantRerankID *string `gorm:"column:tenant_rerank_id"`
+ TTSID *string `gorm:"column:tts_id"`
+ TenantTTSID *string `gorm:"column:tenant_tts_id"`
+ OCRID *string `gorm:"column:ocr_id"`
+ TenantOCRID *string `gorm:"column:tenant_ocr_id"`
+ DecisionID *string `gorm:"column:decision_id"`
+ TenantDecisionID *string `gorm:"column:tenant_decision_id"`
+}
+
+func (tenantDefaultModelsLegacySchema) TableName() string {
+ return "tenant"
+}
+
+func tenantDefaultModelColumnExists(migrator gorm.Migrator, name string) (bool, error) {
+ columns, err := migrator.ColumnTypes(&tenantDefaultModelsLegacySchema{})
+ if err != nil {
+ return false, err
+ }
+ for _, column := range columns {
+ if strings.EqualFold(column.Name(), name) {
+ return true, nil
+ }
+ }
+ return false, nil
+}
+
+// migrateTenantDefaultModels moves the old tenant-wide model selections to
+// the tenant owner's membership, then removes the tenant-wide columns.
+func migrateTenantDefaultModels(ctx context.Context, db *gorm.DB) error {
+ version, err := GetDatabaseMigrationVersion(ctx, db)
+ if err != nil {
+ return fmt.Errorf("read database migration version: %w", err)
+ }
+ if shouldSkipMigration(version, tenantDefaultModelsTargetVersion) {
+ return nil
+ }
+
+ scoped := db.WithContext(ctx)
+ migrator := scoped.Migrator()
+ if migrator.HasTable("tenant") && migrator.HasTable(&entity.UserTenant{}) {
+ if err := scoped.Transaction(func(tx *gorm.DB) error {
+ for _, column := range tenantDefaultModelColumns {
+ exists, err := tenantDefaultModelColumnExists(tx.Migrator(), column)
+ if err != nil {
+ return fmt.Errorf("inspect tenant.%s: %w", column, err)
+ }
+ if !exists {
+ continue
+ }
+ if !tx.Migrator().HasColumn(&entity.UserTenant{}, column) {
+ return fmt.Errorf("user_tenant.%s is missing", column)
+ }
+ query := fmt.Sprintf(
+ "UPDATE user_tenant SET %s = (SELECT tenant.%s FROM tenant WHERE tenant.id = user_tenant.tenant_id) "+
+ "WHERE (user_tenant.%s IS NULL OR user_tenant.%s = '') "+
+ "AND (user_tenant.role = 'owner' OR user_tenant.user_id = user_tenant.tenant_id) "+
+ "AND EXISTS (SELECT 1 FROM tenant WHERE tenant.id = user_tenant.tenant_id)",
+ column, column, column, column,
+ )
+ if err := tx.Exec(query).Error; err != nil {
+ return fmt.Errorf("copy tenant.%s to user_tenant: %w", column, err)
+ }
+ }
+ return nil
+ }); err != nil {
+ return fmt.Errorf("copy tenant default models: %w", err)
+ }
+
+ for _, column := range tenantDefaultModelColumns {
+ exists, err := tenantDefaultModelColumnExists(migrator, column)
+ if err != nil {
+ return fmt.Errorf("inspect tenant.%s: %w", column, err)
+ }
+ if !exists {
+ continue
+ }
+ if err := migrator.DropColumn(&tenantDefaultModelsLegacySchema{}, column); err != nil {
+ return fmt.Errorf("drop tenant.%s: %w", column, err)
+ }
+ exists, err = tenantDefaultModelColumnExists(migrator, column)
+ if err != nil {
+ return fmt.Errorf("inspect tenant.%s after dropping it: %w", column, err)
+ }
+ if exists {
+ if err := scoped.Exec("ALTER TABLE tenant DROP COLUMN " + column).Error; err != nil {
+ return fmt.Errorf("drop tenant.%s: %w", column, err)
+ }
+ }
+ exists, err = tenantDefaultModelColumnExists(migrator, column)
+ if err != nil {
+ return fmt.Errorf("inspect tenant.%s after dropping it: %w", column, err)
+ }
+ if exists {
+ return fmt.Errorf("tenant.%s still exists after dropping it", column)
+ }
+ }
+ }
+
+ if err := setDatabaseMigrationVersion(ctx, db, tenantDefaultModelsTargetVersion); err != nil {
+ return fmt.Errorf("mark tenant default model migration version: %w", err)
+ }
+ return nil
+}
diff --git a/internal/dao/tenant_default_models_migration_test.go b/internal/dao/tenant_default_models_migration_test.go
new file mode 100644
index 0000000000..2b87006be8
--- /dev/null
+++ b/internal/dao/tenant_default_models_migration_test.go
@@ -0,0 +1,129 @@
+//
+// 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 dao
+
+import (
+ "strings"
+ "testing"
+
+ "github.com/glebarez/sqlite"
+ "gorm.io/gorm"
+
+ "ragflow/internal/entity"
+)
+
+func TestMigrateTenantDefaultModelsOnlyMovesValuesToOwner(t *testing.T) {
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+ if err != nil {
+ t.Fatalf("open sqlite: %v", err)
+ }
+ if err := db.AutoMigrate(&entity.SystemSettings{}, &entity.UserTenant{}); err != nil {
+ t.Fatalf("migrate destination tables: %v", err)
+ }
+
+ columns := append([]string{"id"}, tenantDefaultModelColumns...)
+ definitions := "id TEXT PRIMARY KEY"
+ for _, column := range tenantDefaultModelColumns {
+ definitions += ", " + column + " TEXT"
+ }
+ if err := db.Exec("CREATE TABLE tenant (" + definitions + ")").Error; err != nil {
+ t.Fatalf("create legacy tenant table: %v", err)
+ }
+
+ for _, tenantID := range []string{"tenant-1", "tenant-2"} {
+ placeholders := "?"
+ args := []any{tenantID}
+ for _, column := range tenantDefaultModelColumns {
+ placeholders += ", ?"
+ args = append(args, tenantID+"-"+column)
+ }
+ query := "INSERT INTO tenant (" + strings.Join(columns, ", ") + ") VALUES (" + placeholders + ")"
+ if err := db.Exec(query, args...).Error; err != nil {
+ t.Fatalf("seed legacy tenant %q: %v", tenantID, err)
+ }
+ }
+
+ joined := entity.TenantMembershipStatusJoined
+ memberships := []entity.UserTenant{
+ {ID: "owner-role", UserID: "owner-user", TenantID: "tenant-1", Role: "owner", Status: &joined},
+ {ID: "member-1", UserID: "member-user", TenantID: "tenant-1", Role: "member-role-id", Status: &joined},
+ {ID: "owner-id-match", UserID: "tenant-2", TenantID: "tenant-2", Role: "owner-role-id", Status: &joined},
+ {ID: "member-2", UserID: "member-user-2", TenantID: "tenant-2", Role: "member-role-id", Status: &joined},
+ }
+ if err := db.Create(&memberships).Error; err != nil {
+ t.Fatalf("seed memberships: %v", err)
+ }
+ if err := setDatabaseMigrationVersion(t.Context(), db, "v1.0.0-rc3.dev4"); err != nil {
+ t.Fatalf("set previous migration version: %v", err)
+ }
+
+ if err := migrateTenantDefaultModels(t.Context(), db); err != nil {
+ t.Fatalf("migrate tenant default models: %v", err)
+ }
+
+ for _, membership := range []struct {
+ id string
+ tenantID string
+ migrated bool
+ }{
+ {id: "owner-role", tenantID: "tenant-1", migrated: true},
+ {id: "member-1", tenantID: "tenant-1"},
+ {id: "owner-id-match", tenantID: "tenant-2", migrated: true},
+ {id: "member-2", tenantID: "tenant-2"},
+ } {
+ var got entity.UserTenant
+ if err := db.Where("id = ?", membership.id).Take(&got).Error; err != nil {
+ t.Fatalf("load membership %q: %v", membership.id, err)
+ }
+ wantLLMID := ""
+ if membership.migrated {
+ wantLLMID = membership.tenantID + "-llm_id"
+ }
+ if got.LLMID != wantLLMID {
+ t.Errorf("membership %q llm_id = %q, want %q", membership.id, got.LLMID, wantLLMID)
+ }
+ if membership.migrated {
+ wantTenantLLMID := membership.tenantID + "-tenant_llm_id"
+ if got.TenantLLMID == nil || *got.TenantLLMID != wantTenantLLMID {
+ t.Errorf("membership %q tenant_llm_id = %v, want %q", membership.id, got.TenantLLMID, wantTenantLLMID)
+ }
+ } else if got.TenantLLMID != nil && *got.TenantLLMID != "" {
+ t.Errorf("non-owner membership %q tenant_llm_id = %q, want empty", membership.id, *got.TenantLLMID)
+ }
+ }
+
+ for _, column := range tenantDefaultModelColumns {
+ exists, err := tenantDefaultModelColumnExists(db.Migrator(), column)
+ if err != nil {
+ t.Fatalf("inspect legacy tenant.%s: %v", column, err)
+ }
+ if exists {
+ t.Errorf("legacy tenant.%s column still exists", column)
+ }
+ }
+
+ version, err := GetDatabaseMigrationVersion(t.Context(), db)
+ if err != nil {
+ t.Fatalf("read migration version: %v", err)
+ }
+ if version != tenantDefaultModelsTargetVersion {
+ t.Fatalf("migration version = %q, want %q", version, tenantDefaultModelsTargetVersion)
+ }
+ if err := migrateTenantDefaultModels(t.Context(), db); err != nil {
+ t.Fatalf("repeat migration: %v", err)
+ }
+}
diff --git a/internal/dao/tenant_model_instance.go b/internal/dao/tenant_model_instance.go
index 01204f803d..221cc4b9b8 100644
--- a/internal/dao/tenant_model_instance.go
+++ b/internal/dao/tenant_model_instance.go
@@ -34,23 +34,25 @@ func NewTenantModelInstanceDAO() *TenantModelInstanceDAO {
}
func (dao *TenantModelInstanceDAO) Create(ctx context.Context, db *gorm.DB, instance *entity.TenantModelInstance) error {
- // begin tx and check if the same provider instance exists
- tx := db.WithContext(ctx).Begin()
- defer tx.Rollback()
- var existingInstance entity.TenantModelInstance
- err := tx.WithContext(ctx).Where("provider_id = ? AND instance_name = ?", instance.ProviderID, instance.InstanceName).First(&existingInstance).Error
- if err == nil {
- return fmt.Errorf("instance %s already exists", instance.InstanceName)
+ db = db.WithContext(ctx)
+ create := func(tx *gorm.DB) error {
+ var existingInstance entity.TenantModelInstance
+ err := tx.Where("provider_id = ? AND instance_name = ?", instance.ProviderID, instance.InstanceName).First(&existingInstance).Error
+ if err == nil {
+ return fmt.Errorf("instance %s already exists", instance.InstanceName)
+ }
+ if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return err
+ }
+ return tx.Create(instance).Error
}
- if !errors.Is(err, gorm.ErrRecordNotFound) {
- return err
+ if _, inTransaction := db.Statement.ConnPool.(interface {
+ Commit() error
+ Rollback() error
+ }); inTransaction {
+ return create(db)
}
- err = tx.WithContext(ctx).Create(instance).Error
- if err != nil {
- return err
- }
- tx.Commit()
- return nil
+ return db.Transaction(create)
}
func (dao *TenantModelInstanceDAO) GetAllInstancesByProviderID(ctx context.Context, db *gorm.DB, providerID string) ([]*entity.TenantModelInstance, error) {
diff --git a/internal/dao/tenant_model_instance_test.go b/internal/dao/tenant_model_instance_test.go
index bb69b776af..34e7056413 100644
--- a/internal/dao/tenant_model_instance_test.go
+++ b/internal/dao/tenant_model_instance_test.go
@@ -65,3 +65,40 @@ func TestTenantModelInstanceDAOGetAllInstancesByProviderIDOrdersByCreateTimeDesc
}
}
}
+
+func TestTenantModelInstanceDAOCreateUsesCallerTransaction(t *testing.T) {
+ db := setupTenantModelInstanceDAOTestDB(t)
+ dao := NewTenantModelInstanceDAO()
+ instance := &entity.TenantModelInstance{
+ ID: "transactional-instance", InstanceName: "transactional", ProviderID: "provider-1",
+ APIKey: "key", Status: "active", Extra: "{}",
+ }
+
+ tx := db.Begin()
+ if tx.Error != nil {
+ t.Fatalf("begin transaction: %v", tx.Error)
+ }
+ if err := dao.Create(t.Context(), tx, instance); err != nil {
+ t.Fatalf("create instance inside caller transaction: %v", err)
+ }
+ if err := tx.Rollback().Error; err != nil {
+ t.Fatalf("rollback caller transaction: %v", err)
+ }
+ var count int64
+ if err := db.Model(&entity.TenantModelInstance{}).Where("id = ?", instance.ID).Count(&count).Error; err != nil {
+ t.Fatalf("count created instances: %v", err)
+ }
+ if count != 0 {
+ t.Fatalf("instance count after rollback = %d, want 0", count)
+ }
+
+ if err := dao.Create(t.Context(), db, instance); err != nil {
+ t.Fatalf("create instance with DAO-managed transaction: %v", err)
+ }
+ if err := db.Model(&entity.TenantModelInstance{}).Where("id = ?", instance.ID).Count(&count).Error; err != nil {
+ t.Fatalf("count committed instances: %v", err)
+ }
+ if count != 1 {
+ t.Fatalf("instance count after DAO transaction = %d, want 1", count)
+ }
+}
diff --git a/internal/dao/tenant_test.go b/internal/dao/tenant_test.go
index ee69b482ef..f5b1e833dd 100644
--- a/internal/dao/tenant_test.go
+++ b/internal/dao/tenant_test.go
@@ -57,11 +57,6 @@ func TestTenantDAOGetByIDSkipsInactiveTenant(t *testing.T) {
t.Helper()
tenant := &entity.Tenant{
ID: id,
- LLMID: "llm",
- EmbdID: "embd",
- ASRID: "asr",
- Img2TxtID: "img2txt",
- RerankID: "rerank",
ParserIDs: "naive",
Status: &status,
}
@@ -93,11 +88,6 @@ func TestTenantDAOUpdateStatus(t *testing.T) {
active := "1"
tenant := &entity.Tenant{
ID: "tenant-update",
- LLMID: "llm",
- EmbdID: "embd",
- ASRID: "asr",
- Img2TxtID: "img2txt",
- RerankID: "rerank",
ParserIDs: "naive",
Status: &active,
}
diff --git a/internal/dao/user_tenant.go b/internal/dao/user_tenant.go
index 1e2876a6a7..0c183861d8 100644
--- a/internal/dao/user_tenant.go
+++ b/internal/dao/user_tenant.go
@@ -18,6 +18,7 @@ package dao
import (
"context"
+ "errors"
"fmt"
"ragflow/internal/entity"
@@ -88,6 +89,51 @@ func (dao *UserTenantDAO) FilterByUserIDAndTenantID(ctx context.Context, db *gor
return &userTenant, nil
}
+// GetOwnerByUserID returns the user's owner membership, falling back to the
+// personal tenant row identified by user_id == tenant_id.
+func (dao *UserTenantDAO) GetOwnerByUserID(ctx context.Context, db *gorm.DB, userID string) (*entity.UserTenant, error) {
+ var membership entity.UserTenant
+ err := db.WithContext(ctx).
+ Where("user_id = ? AND role = ? AND status = ?", userID, "owner", entity.TenantMembershipStatusJoined).
+ Take(&membership).Error
+ if err == nil {
+ return &membership, nil
+ }
+ if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, err
+ }
+ err = db.WithContext(ctx).
+ Where("user_id = ? AND tenant_id = ? AND status = ?", userID, userID, entity.TenantMembershipStatusJoined).
+ Take(&membership).Error
+ if err != nil {
+ return nil, err
+ }
+ return &membership, nil
+}
+
+// GetOwnerByTenantID returns the joined owner membership for tenantID, falling
+// back to the personal tenant row identified by user_id == tenant_id.
+func (dao *UserTenantDAO) GetOwnerByTenantID(ctx context.Context, db *gorm.DB, tenantID string) (*entity.UserTenant, error) {
+ var membership entity.UserTenant
+ err := db.WithContext(ctx).
+ Where("tenant_id = ? AND role = ? AND status = ?", tenantID, "owner", entity.TenantMembershipStatusJoined).
+ Take(&membership).Error
+ if err == nil {
+ return &membership, nil
+ }
+ if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, err
+ }
+
+ err = db.WithContext(ctx).
+ Where("tenant_id = ? AND user_id = ? AND status = ?", tenantID, tenantID, entity.TenantMembershipStatusJoined).
+ Take(&membership).Error
+ if err != nil {
+ return nil, err
+ }
+ return &membership, nil
+}
+
// GetByUserIDAndRole get user tenant relationships by user ID and role
func (dao *UserTenantDAO) GetByUserIDAndRole(ctx context.Context, db *gorm.DB, userID, role string) ([]*entity.UserTenant, error) {
var relations []*entity.UserTenant
@@ -140,8 +186,12 @@ func (dao *UserTenantDAO) GetMembersByTenantID(ctx context.Context, db *gorm.DB,
"user.status AS is_active, user.is_anonymous, user.is_superuser, "+
"DATE_FORMAT(user.update_date, '%Y-%m-%dT%H:%i:%s') AS update_date").
Joins("JOIN user ON user_tenant.user_id = user.id").
- Where("user_tenant.tenant_id = ? AND user_tenant.status = ? AND user_tenant.role != ?",
- tenantID, "1", "owner").
+ Where("user_tenant.tenant_id = ? AND user_tenant.status IN ? AND user_tenant.role != ?",
+ tenantID, []string{
+ entity.TenantMembershipStatusJoined,
+ entity.TenantMembershipStatusInvited,
+ entity.TenantMembershipStatusRequested,
+ }, "owner").
Scan(&results).Error
return results, err
}
diff --git a/internal/dao/user_tenant_test.go b/internal/dao/user_tenant_test.go
new file mode 100644
index 0000000000..42485db432
--- /dev/null
+++ b/internal/dao/user_tenant_test.go
@@ -0,0 +1,52 @@
+//
+// 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 dao
+
+import (
+ "testing"
+
+ "github.com/glebarez/sqlite"
+ "gorm.io/gorm"
+
+ "ragflow/internal/entity"
+)
+
+func TestGetOwnerByTenantIDFallsBackToTenantIDUserID(t *testing.T) {
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+ if err != nil {
+ t.Fatalf("open sqlite: %v", err)
+ }
+ if err := db.AutoMigrate(&entity.UserTenant{}); err != nil {
+ t.Fatalf("migrate user_tenant: %v", err)
+ }
+
+ status := entity.TenantMembershipStatusJoined
+ if err := db.Create(&entity.UserTenant{
+ ID: "owner-link", UserID: "tenant-1", TenantID: "tenant-1", Status: &status,
+ LLMID: "owner-default@provider",
+ }).Error; err != nil {
+ t.Fatalf("create owner membership: %v", err)
+ }
+
+ membership, err := NewUserTenantDAO().GetOwnerByTenantID(t.Context(), db, "tenant-1")
+ if err != nil {
+ t.Fatalf("GetOwnerByTenantID() error = %v", err)
+ }
+ if membership.UserID != "tenant-1" || membership.LLMID != "owner-default@provider" {
+ t.Fatalf("GetOwnerByTenantID() = %#v, want the tenant_id=user_id membership", membership)
+ }
+}
diff --git a/internal/entity/chat.go b/internal/entity/chat.go
index f3f4f43c46..ae4ea2905b 100644
--- a/internal/entity/chat.go
+++ b/internal/entity/chat.go
@@ -56,6 +56,7 @@ type Chat struct {
TenantRerankID *string `gorm:"column:tenant_rerank_id;size:32;index" json:"tenant_rerank_id,omitempty"`
KBIDs JSONSlice `gorm:"column:kb_ids;type:longtext;not null" json:"kb_ids"`
Status *string `gorm:"column:status;size:1;index" json:"status,omitempty"`
+ OperatorPermission int32 `gorm:"-" json:"operator_permission,omitempty"`
BaseModel
}
diff --git a/internal/entity/dataset.go b/internal/entity/dataset.go
index 381cc8b854..a07f90faac 100644
--- a/internal/entity/dataset.go
+++ b/internal/entity/dataset.go
@@ -141,6 +141,7 @@ type Knowledgebase struct {
SessionGraphTaskFinishAt *time.Time `gorm:"column:session_graph_task_finish_at" json:"session_graph_task_finish_at,omitempty"`
SessionEssenceTaskID *string `gorm:"column:session_essence_task_id;size:32;index" json:"session_essence_task_id,omitempty"`
SessionEssenceTaskFinishAt *time.Time `gorm:"column:session_essence_task_finish_at" json:"session_essence_task_finish_at,omitempty"`
+ OperatorPermission int32 `gorm:"-" json:"operator_permission,omitempty"`
Status *string `gorm:"column:status;size:1;index;default:'1'" json:"status,omitempty"`
BaseModel
}
diff --git a/internal/entity/memory.go b/internal/entity/memory.go
index 3ee294f9a5..4ed2594c7a 100644
--- a/internal/entity/memory.go
+++ b/internal/entity/memory.go
@@ -18,23 +18,24 @@ package entity
// Memory memory model
type Memory struct {
- ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
- Name string `gorm:"column:name;size:128;not null" json:"name"`
- Avatar *string `gorm:"column:avatar;type:longtext" json:"avatar,omitempty"`
- TenantID string `gorm:"column:tenant_id;size:32;not null;index" json:"tenant_id"`
- MemoryType int64 `gorm:"column:memory_type;default:1;index" json:"memory_type"`
- StorageType string `gorm:"column:storage_type;size:32;not null;default:table;index" json:"storage_type"`
- EmbdID string `gorm:"column:embd_id;size:128;not null" json:"embd_id"`
- TenantEmbdID *string `gorm:"column:tenant_embd_id;size:32;index" json:"tenant_embd_id,omitempty"`
- LLMID string `gorm:"column:llm_id;size:128;not null" json:"llm_id"`
- TenantLLMID *string `gorm:"column:tenant_llm_id;size:32;index" json:"tenant_llm_id,omitempty"`
- Permissions string `gorm:"column:permissions;size:16;not null;default:me;index" json:"permissions"`
- Description *string `gorm:"column:description;type:longtext" json:"description,omitempty"`
- MemorySize int64 `gorm:"column:memory_size;default:5242880;not null" json:"memory_size"`
- ForgettingPolicy string `gorm:"column:forgetting_policy;size:32;not null;default:FIFO" json:"forgetting_policy"`
- Temperature float64 `gorm:"column:temperature;default:0.5;not null" json:"temperature"`
- SystemPrompt *string `gorm:"column:system_prompt;type:longtext" json:"system_prompt,omitempty"`
- UserPrompt *string `gorm:"column:user_prompt;type:longtext" json:"user_prompt,omitempty"`
+ ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
+ Name string `gorm:"column:name;size:128;not null" json:"name"`
+ Avatar *string `gorm:"column:avatar;type:longtext" json:"avatar,omitempty"`
+ TenantID string `gorm:"column:tenant_id;size:32;not null;index" json:"tenant_id"`
+ MemoryType int64 `gorm:"column:memory_type;default:1;index" json:"memory_type"`
+ StorageType string `gorm:"column:storage_type;size:32;not null;default:table;index" json:"storage_type"`
+ EmbdID string `gorm:"column:embd_id;size:128;not null" json:"embd_id"`
+ TenantEmbdID *string `gorm:"column:tenant_embd_id;size:32;index" json:"tenant_embd_id,omitempty"`
+ LLMID string `gorm:"column:llm_id;size:128;not null" json:"llm_id"`
+ TenantLLMID *string `gorm:"column:tenant_llm_id;size:32;index" json:"tenant_llm_id,omitempty"`
+ Permissions string `gorm:"column:permissions;size:16;not null;default:me;index" json:"permissions"`
+ Description *string `gorm:"column:description;type:longtext" json:"description,omitempty"`
+ MemorySize int64 `gorm:"column:memory_size;default:5242880;not null" json:"memory_size"`
+ ForgettingPolicy string `gorm:"column:forgetting_policy;size:32;not null;default:FIFO" json:"forgetting_policy"`
+ Temperature float64 `gorm:"column:temperature;default:0.5;not null" json:"temperature"`
+ SystemPrompt *string `gorm:"column:system_prompt;type:longtext" json:"system_prompt,omitempty"`
+ UserPrompt *string `gorm:"column:user_prompt;type:longtext" json:"user_prompt,omitempty"`
+ OperatorPermission int32 `gorm:"-" json:"operator_permission,omitempty"`
BaseModel
}
diff --git a/internal/entity/search.go b/internal/entity/search.go
index e882cc9961..2b2ab53869 100644
--- a/internal/entity/search.go
+++ b/internal/entity/search.go
@@ -18,14 +18,15 @@ package entity
// Search search model
type Search struct {
- ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
- Avatar *string `gorm:"column:avatar;type:longtext" json:"avatar,omitempty"`
- TenantID string `gorm:"column:tenant_id;size:32;not null;index" json:"tenant_id"`
- Name string `gorm:"column:name;size:128;not null;index" json:"name"`
- Description *string `gorm:"column:description;type:longtext" json:"description,omitempty"`
- CreatedBy string `gorm:"column:created_by;size:32;not null;index" json:"created_by"`
- SearchConfig JSONMap `gorm:"column:search_config;type:longtext;not null" json:"search_config"`
- Status *string `gorm:"column:status;size:1;index" json:"status,omitempty"`
+ ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
+ Avatar *string `gorm:"column:avatar;type:longtext" json:"avatar,omitempty"`
+ TenantID string `gorm:"column:tenant_id;size:32;not null;index" json:"tenant_id"`
+ Name string `gorm:"column:name;size:128;not null;index" json:"name"`
+ Description *string `gorm:"column:description;type:longtext" json:"description,omitempty"`
+ CreatedBy string `gorm:"column:created_by;size:32;not null;index" json:"created_by"`
+ SearchConfig JSONMap `gorm:"column:search_config;type:longtext;not null" json:"search_config"`
+ Status *string `gorm:"column:status;size:1;index" json:"status,omitempty"`
+ OperatorPermission int32 `gorm:"-" json:"operator_permission,omitempty"`
BaseModel
}
diff --git a/internal/entity/tenant.go b/internal/entity/tenant.go
index fe35ee7f9c..1a5896008f 100644
--- a/internal/entity/tenant.go
+++ b/internal/entity/tenant.go
@@ -18,34 +18,14 @@ package entity
// Tenant tenant model
type Tenant struct {
- ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
- Name *string `gorm:"column:name;size:100;index" json:"name,omitempty"`
- PublicKey *string `gorm:"column:public_key;size:255;index" json:"public_key,omitempty"`
- LLMID string `gorm:"column:llm_id;size:128;not null;index" json:"llm_id"`
- TenantLLMID *string `gorm:"column:tenant_llm_id;size:32;index" json:"tenant_llm_id,omitempty"`
- EmbdID string `gorm:"column:embd_id;size:128;not null;index" json:"embd_id"`
- TenantEmbdID *string `gorm:"column:tenant_embd_id;size:32;index" json:"tenant_embd_id,omitempty"`
- ASRID string `gorm:"column:asr_id;size:128;not null;index" json:"asr_id"`
- TenantASRID *string `gorm:"column:tenant_asr_id;size:32;index" json:"tenant_asr_id,omitempty"`
- Img2TxtID string `gorm:"column:img2txt_id;size:128;not null;index" json:"img2txt_id"`
- TenantImg2TxtID *string `gorm:"column:tenant_img2txt_id;size:32;index" json:"tenant_img2txt_id,omitempty"`
- RerankID string `gorm:"column:rerank_id;size:128;not null;index" json:"rerank_id"`
- TenantRerankID *string `gorm:"column:tenant_rerank_id;size:32;index" json:"tenant_rerank_id,omitempty"`
- TTSID *string `gorm:"column:tts_id;size:256;index" json:"tts_id,omitempty"`
- TenantTTSID *string `gorm:"column:tenant_tts_id;size:32;index" json:"tenant_tts_id,omitempty"`
- ParserIDs string `gorm:"column:parser_ids;size:256;not null;index" json:"parser_ids"`
- OCRID *string `gorm:"column:ocr_id;size:256;index" json:"ocr_id,omitempty"`
- TenantOCRID *string `gorm:"column:tenant_ocr_id;size:32;index" json:"tenant_ocr_id,omitempty"`
- // DecisionID is the tenant's default decision model: the one that judges
- // whether a retrieved passage is worth showing the chat model. Nullable
- // because the decision gate is optional — a tenant that never sets it runs
- // without one, which must not be an error.
- DecisionID *string `gorm:"column:decision_id;size:256;index" json:"decision_id,omitempty"`
- TenantDecisionID *string `gorm:"column:tenant_decision_id;size:32;index" json:"tenant_decision_id,omitempty"`
- Credit int `gorm:"column:credit;default:512;index" json:"credit"`
- InviteEnabled bool `gorm:"column:invite_enabled;not null;default:false" json:"invite_enabled"`
- RoleID *int32 `gorm:"column:role_id" json:"role_id,omitempty"`
- Status *string `gorm:"column:status;size:1;index;default:'1'" json:"status,omitempty"`
+ ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
+ Name *string `gorm:"column:name;size:100;index" json:"name,omitempty"`
+ PublicKey *string `gorm:"column:public_key;size:255;index" json:"public_key,omitempty"`
+ ParserIDs string `gorm:"column:parser_ids;size:256;not null;index" json:"parser_ids"`
+ Credit int `gorm:"column:credit;default:512;index" json:"credit"`
+ InviteEnabled bool `gorm:"column:invite_enabled;not null;default:false" json:"invite_enabled"`
+ RoleID *int32 `gorm:"column:role_id" json:"role_id,omitempty"`
+ Status *string `gorm:"column:status;size:1;index;default:'1'" json:"status,omitempty"`
BaseModel
}
diff --git a/internal/entity/user_tenant.go b/internal/entity/user_tenant.go
index b1df27aaea..1a1e9cc849 100644
--- a/internal/entity/user_tenant.go
+++ b/internal/entity/user_tenant.go
@@ -27,12 +27,28 @@ const (
// UserTenant user tenant relationship model
type UserTenant struct {
- ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
- UserID string `gorm:"column:user_id;size:32;not null;index;uniqueIndex:idx_user_tenant_user_tenant,priority:1" json:"user_id"`
- TenantID string `gorm:"column:tenant_id;size:32;not null;index;uniqueIndex:idx_user_tenant_user_tenant,priority:2" json:"tenant_id"`
- Role string `gorm:"column:role;size:32;not null;index" json:"role"`
- InvitedBy string `gorm:"column:invited_by;size:32;index" json:"invited_by"`
- Status *string `gorm:"column:status;size:16;index;default:'1'" json:"status,omitempty"`
+ ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
+ UserID string `gorm:"column:user_id;size:32;not null;index;uniqueIndex:idx_user_tenant_user_tenant,priority:1" json:"user_id"`
+ TenantID string `gorm:"column:tenant_id;size:32;not null;index;uniqueIndex:idx_user_tenant_user_tenant,priority:2" json:"tenant_id"`
+ Role string `gorm:"column:role;size:32;not null;index" json:"role"`
+ InvitedBy string `gorm:"column:invited_by;size:32;index" json:"invited_by"`
+ Status *string `gorm:"column:status;size:16;index;default:'1'" json:"status,omitempty"`
+ LLMID string `gorm:"column:llm_id;size:128;not null;default:''" json:"llm_id"`
+ TenantLLMID *string `gorm:"column:tenant_llm_id;size:32" json:"tenant_llm_id,omitempty"`
+ EmbdID string `gorm:"column:embd_id;size:128;not null;default:''" json:"embd_id"`
+ TenantEmbdID *string `gorm:"column:tenant_embd_id;size:32" json:"tenant_embd_id,omitempty"`
+ ASRID string `gorm:"column:asr_id;size:128;not null;default:''" json:"asr_id"`
+ TenantASRID *string `gorm:"column:tenant_asr_id;size:32" json:"tenant_asr_id,omitempty"`
+ Img2TxtID string `gorm:"column:img2txt_id;size:128;not null;default:''" json:"img2txt_id"`
+ TenantImg2TxtID *string `gorm:"column:tenant_img2txt_id;size:32" json:"tenant_img2txt_id,omitempty"`
+ RerankID string `gorm:"column:rerank_id;size:128;not null;default:''" json:"rerank_id"`
+ TenantRerankID *string `gorm:"column:tenant_rerank_id;size:32" json:"tenant_rerank_id,omitempty"`
+ TTSID *string `gorm:"column:tts_id;size:256" json:"tts_id,omitempty"`
+ TenantTTSID *string `gorm:"column:tenant_tts_id;size:32" json:"tenant_tts_id,omitempty"`
+ OCRID *string `gorm:"column:ocr_id;size:256" json:"ocr_id,omitempty"`
+ TenantOCRID *string `gorm:"column:tenant_ocr_id;size:32" json:"tenant_ocr_id,omitempty"`
+ DecisionID *string `gorm:"column:decision_id;size:256" json:"decision_id,omitempty"`
+ TenantDecisionID *string `gorm:"column:tenant_decision_id;size:32" json:"tenant_decision_id,omitempty"`
BaseModel
}
diff --git a/internal/handler/auth.go b/internal/handler/auth.go
index 91d8155c14..cf9c185e36 100644
--- a/internal/handler/auth.go
+++ b/internal/handler/auth.go
@@ -22,6 +22,7 @@ import (
"net/http"
"ragflow/internal/common"
"ragflow/internal/entity"
+ "ragflow/internal/permission"
"ragflow/internal/server/local"
"ragflow/internal/service"
@@ -176,4 +177,8 @@ func setAuthIdentity(c *gin.Context, identity *service.AuthIdentity) {
c.Set("user", identity.User)
c.Set("user_id", identity.User.ID)
c.Set("tenant_id", identity.TenantID)
+ c.Request = c.Request.WithContext(permission.WithSubject(c.Request.Context(), permission.Subject{
+ UserID: identity.User.ID,
+ TenantID: identity.TenantID,
+ }))
}
diff --git a/internal/handler/chat_audio_test.go b/internal/handler/chat_audio_test.go
index 91f3746c1d..238889d572 100644
--- a/internal/handler/chat_audio_test.go
+++ b/internal/handler/chat_audio_test.go
@@ -53,7 +53,6 @@ func TestChatAudioSpeechFailureOmitsProviderError(t *testing.T) {
if err = db.Create(&entity.Tenant{
ID: "user-1",
Name: &tenantName,
- TTSID: &ttsModelID,
ParserIDs: "naive",
}).Error; err != nil {
t.Fatalf("failed to create tenant: %v", err)
@@ -66,6 +65,7 @@ func TestChatAudioSpeechFailureOmitsProviderError(t *testing.T) {
Role: "owner",
InvitedBy: "user-1",
Status: &activeStatus,
+ TTSID: &ttsModelID,
}).Error; err != nil {
t.Fatalf("failed to create tenant owner membership: %v", err)
}
diff --git a/internal/handler/chat_test.go b/internal/handler/chat_test.go
index 7423016b96..f62776c05d 100644
--- a/internal/handler/chat_test.go
+++ b/internal/handler/chat_test.go
@@ -36,16 +36,17 @@ func setupChatHandlerTestDB(t *testing.T) *gorm.DB {
status := string(entity.StatusValid)
if err = db.Create(&entity.Tenant{
ID: "user-1",
- LLMID: "model-a",
- EmbdID: "embd-a",
- ASRID: "asr-a",
- Img2TxtID: "img2txt-a",
- RerankID: "rerank-a",
ParserIDs: "naive",
Status: &status,
}).Error; err != nil {
t.Fatalf("failed to create tenant: %v", err)
}
+ if err = db.Create(&entity.UserTenant{
+ ID: "owner-user-1", UserID: "user-1", TenantID: "user-1", Role: "owner", Status: &status,
+ LLMID: "model-a", EmbdID: "embd-a", ASRID: "asr-a", Img2TxtID: "img2txt-a", RerankID: "rerank-a",
+ }).Error; err != nil {
+ t.Fatalf("failed to create owner membership: %v", err)
+ }
return db
}
diff --git a/internal/handler/common.go b/internal/handler/common.go
index 20870b86bf..bb25113839 100644
--- a/internal/handler/common.go
+++ b/internal/handler/common.go
@@ -47,11 +47,6 @@ func respondPermissionErrorIf(c *gin.Context, err error, hideResource bool) bool
return true
}
-func respondPermissionFailure(c *gin.Context, err error, hideResource bool) {
- code, message := permissionErrorResult(err, hideResource)
- common.ErrorWithCode(c, code, message)
-}
-
func respondHTTPPermissionError(c *gin.Context, err error, hideResource bool) {
code, message := permissionErrorResult(err, hideResource)
common.ResponseWithHttpCodeData(c, int(code), code, nil, message)
diff --git a/internal/handler/compilation_template_group.go b/internal/handler/compilation_template_group.go
index 5f8d9b9ac0..e39d72fec5 100644
--- a/internal/handler/compilation_template_group.go
+++ b/internal/handler/compilation_template_group.go
@@ -76,7 +76,7 @@ func (h *CompilationTemplateGroupHandler) List(c *gin.Context) {
} else if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(
c.Request.Context(), permission.Subject{UserID: user.ID}, tenantID, permission.TenantMember,
); err != nil {
- respondPermissionFailure(c, err, false)
+ respondPermissionError(c, err, false)
return
}
orderby := c.DefaultQuery("orderby", "create_time")
diff --git a/internal/handler/dataset.go b/internal/handler/dataset.go
index ec2159fae5..eef9f50033 100644
--- a/internal/handler/dataset.go
+++ b/internal/handler/dataset.go
@@ -268,9 +268,13 @@ func (h *DatasetsHandler) CreateDataset(c *gin.Context) {
ctx := c.Request.Context()
+ tenantID := strings.TrimSpace(c.GetString("tenant_id"))
+ if tenantID == "" {
+ tenantID = user.ID
+ }
result, code, err := h.datasetsService.CreateDataset(ctx, &req, permission.Subject{
UserID: user.ID,
- TenantID: user.ID,
+ TenantID: tenantID,
})
if err != nil {
common.ErrorWithCode(c, code, err.Error())
@@ -723,9 +727,13 @@ func (h *DatasetsHandler) DeleteDatasets(c *gin.Context) {
ctx := c.Request.Context()
+ tenantID := strings.TrimSpace(c.GetString("tenant_id"))
+ if tenantID == "" {
+ tenantID = user.ID
+ }
result, code, err := h.datasetsService.DeleteDatasets(ctx, ids, req.DeleteAll, permission.Subject{
UserID: user.ID,
- TenantID: user.ID,
+ TenantID: tenantID,
})
if err != nil {
common.ErrorWithCode(c, code, err.Error())
diff --git a/internal/handler/dataset_artifact.go b/internal/handler/dataset_artifact.go
index 79011f9c78..91bc80efa2 100644
--- a/internal/handler/dataset_artifact.go
+++ b/internal/handler/dataset_artifact.go
@@ -74,7 +74,7 @@ func (h *DatasetArtifactHandler) datasetOwner(c *gin.Context, datasetID string)
return nil, "", ""
}
if err := h.datasetSvc.CheckAccess(c.Request.Context(), permission.Subject{UserID: user.ID}, datasetID, permission.OperationRead); err != nil {
- respondPermissionFailure(c, err, false)
+ respondPermissionError(c, err, false)
return nil, "", ""
}
return user, kb.TenantID, msg
diff --git a/internal/handler/document.go b/internal/handler/document.go
index 105d486bf5..461cd128b0 100644
--- a/internal/handler/document.go
+++ b/internal/handler/document.go
@@ -126,29 +126,23 @@ func (h *DocumentHandler) GetDocumentByID(c *gin.Context) {
id := c.Param("id")
if id == "" {
- c.JSON(http.StatusBadRequest, gin.H{
- "error": "invalid document id",
- })
+ common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "invalid document id")
return
}
ctx := c.Request.Context()
doc, err := h.documentService.GetDocumentByID(ctx, id)
if err != nil {
- c.JSON(http.StatusNotFound, gin.H{
- "error": "document not found",
- })
+ common.ResponseWithCodeData(c, common.CodeNotFound, nil, "document not found")
return
}
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, doc.KbID, permission.OperationRead); err != nil {
- respondHTTPPermissionError(c, err, false)
+ if err := service.CheckDocumentAccess(ctx, permission.Subject{UserID: user.ID}, doc.ID, doc.KbID, permission.OperationRead); err != nil {
+ respondPermissionError(c, err, false)
return
}
- c.JSON(http.StatusOK, gin.H{
- "data": doc,
- })
+ common.SuccessWithData(c, doc, "")
}
// GetThumbnail Get thumbnails for documents.
@@ -376,7 +370,7 @@ func (h *DocumentHandler) UpdateDocument(c *gin.Context) {
common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 1, nil, "document not found!")
return
}
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, doc.KbID, permission.OperationUpdate); err != nil {
+ if err := service.CheckDocumentAccess(ctx, permission.Subject{UserID: user.ID}, doc.ID, doc.KbID, permission.OperationUpdate); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -431,7 +425,7 @@ func (h *DocumentHandler) DeleteDocument(c *gin.Context) {
common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 1, nil, "document not found!")
return
}
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, doc.KbID, permission.OperationDeleteContent); err != nil {
+ if err := service.CheckDocumentAccess(ctx, permission.Subject{UserID: user.ID}, doc.ID, doc.KbID, permission.OperationDeleteContent); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -1196,8 +1190,23 @@ func (h *DocumentHandler) DownloadDocument(c *gin.Context) {
}
ctx := c.Request.Context()
// Authorize the caller before serving file bytes. Answer exactly like the
- // missing-document case so dataset existence is not leaked.
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, datasetID, permission.OperationRead); err != nil {
+ // missing-document case so document existence is not leaked.
+ doc, err := h.documentService.GetDocumentByID(ctx, docID)
+ if err != nil {
+ if dao.IsNotFoundErr(err) {
+ common.ErrorWithCode(c, common.CodeNotFound, "Resource not found")
+ return
+ }
+ common.Error("DownloadDocument failed to load document", err,
+ zap.String("dataset_id", datasetID), zap.String("document_id", docID), zap.String("user_id", user.ID))
+ common.ErrorWithCode(c, common.CodeServerError, "Failed to download document")
+ return
+ }
+ if doc == nil || doc.KbID != datasetID {
+ common.ErrorWithCode(c, common.CodeNotFound, "Resource not found")
+ return
+ }
+ if err := service.CheckDocumentAccess(ctx, permission.Subject{UserID: user.ID}, doc.ID, doc.KbID, permission.OperationRead); err != nil {
respondPermissionError(c, err, true)
return
}
@@ -1555,7 +1564,7 @@ func (h *DocumentHandler) MetadataSummaryByDataset(c *gin.Context) {
}
ctx := c.Request.Context()
if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, datasetID, permission.OperationRead); err != nil {
- respondPermissionFailure(c, err, false)
+ respondPermissionError(c, err, false)
return
}
diff --git a/internal/handler/document_test.go b/internal/handler/document_test.go
index 4d5a66c95d..033396d5e2 100644
--- a/internal/handler/document_test.go
+++ b/internal/handler/document_test.go
@@ -36,6 +36,7 @@ import (
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
+ "ragflow/internal/permission"
"ragflow/internal/service"
dataset "ragflow/internal/service/dataset"
"ragflow/internal/service/document"
@@ -249,7 +250,7 @@ func (f *fakeDocumentService) GetDocumentByID(ctx context.Context, id string) (*
if f.doc != nil {
return f.doc, nil
}
- return nil, fmt.Errorf("document not found")
+ return nil, gorm.ErrRecordNotFound
}
func (f *fakeDocumentService) UpdateDocument(ctx context.Context, id string, req *document.UpdateDocumentRequest) (common.ErrorCode, error) {
f.updateCalled = true
@@ -386,6 +387,7 @@ func setupDocumentPermissionDB(t *testing.T, accessible bool) {
if err := db.AutoMigrate(
&entity.Knowledgebase{},
&entity.UserTenant{},
+ &entity.Document{},
); err != nil {
t.Fatalf("failed to migrate permission tables: %v", err)
}
@@ -400,6 +402,12 @@ func setupDocumentPermissionDB(t *testing.T, accessible bool) {
}).Error; err != nil {
t.Fatalf("insert knowledgebase: %v", err)
}
+ if err := db.Create(&entity.Document{
+ ID: "doc-1", KbID: "kb-owner", ParserID: "naive", ParserConfig: entity.JSONMap{},
+ CreatedBy: "owner-user", Type: "pdf", Suffix: "pdf", Status: sptr(string(entity.StatusValid)),
+ }).Error; err != nil {
+ t.Fatalf("insert document: %v", err)
+ }
if err := db.Create(&entity.UserTenant{
ID: "ut-owner",
UserID: "owner-user",
@@ -444,12 +452,15 @@ func TestDocumentReadHandlersForbidden(t *testing.T) {
handler gin.HandlerFunc
status int
}{
- {"document detail", http.MethodGet, "/api/v1/documents/doc-1", "", gin.Params{{Key: "id", Value: "doc-1"}}, h.GetDocumentByID, http.StatusForbidden},
+ {"document detail", http.MethodGet, "/api/v1/documents/doc-1", "", gin.Params{{Key: "id", Value: "doc-1"}}, h.GetDocumentByID, http.StatusOK},
{"metadata summary", http.MethodGet, "/api/v1/datasets/kb-owner/metadata/summary?doc_ids=doc-1", "", gin.Params{{Key: "dataset_id", Value: "kb-owner"}}, h.MetadataSummaryByDataset, http.StatusOK},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c, w := setupGinContextWithUser(tt.method, tt.path, tt.body)
+ c.Request = c.Request.WithContext(permission.WithSubject(c.Request.Context(), permission.Subject{
+ UserID: "user-1", TenantID: "tenant-owner",
+ }))
c.Params = tt.params
tt.handler(c)
if w.Code != tt.status {
@@ -466,6 +477,13 @@ func TestDocumentReadHandlersForbidden(t *testing.T) {
if resp.Code != common.CodeForbidden || resp.Message != "Permission denied" || resp.Data != nil {
t.Fatalf("unexpected response: %s", w.Body.String())
}
+ var responseFields map[string]json.RawMessage
+ if err := json.Unmarshal(w.Body.Bytes(), &responseFields); err != nil {
+ t.Fatal(err)
+ }
+ if _, ok := responseFields["data"]; !ok {
+ t.Fatalf("permission error response is missing data field: %s", w.Body.String())
+ }
if fake.metadataKBID != "" {
t.Fatal("GetMetadataSummary should not be called without dataset access")
}
@@ -683,19 +701,20 @@ func setupUploadHandlerDB(t *testing.T, role string) *gorm.DB {
&entity.Tenant{},
&entity.UserTenant{},
&entity.Knowledgebase{},
+ &entity.Document{},
); err != nil {
t.Fatalf("failed to migrate: %v", err)
}
if err := db.Create(&entity.User{ID: "user-1", Nickname: "test", Email: "[email protected]", Password: sptr("x")}).Error; err != nil {
t.Fatalf("insert user: %v", err)
}
- if err := db.Create(&entity.Tenant{ID: "tenant-1", LLMID: "llm-1", EmbdID: "embd-1", ASRID: "asr-1", Status: sptr(string(entity.StatusValid))}).Error; err != nil {
+ if err := db.Create(&entity.Tenant{ID: "tenant-1", Status: sptr(string(entity.StatusValid))}).Error; err != nil {
t.Fatalf("insert tenant: %v", err)
}
if err := db.Create(&entity.UserTenant{ID: "ut-1", UserID: "user-1", TenantID: "tenant-1", Role: role, Status: sptr(string(entity.StatusValid))}).Error; err != nil {
t.Fatalf("insert user_tenant: %v", err)
}
- if err := db.Create(&entity.UserTenant{ID: "ut-owner", UserID: "owner-1", TenantID: "tenant-1", Role: "owner", Status: sptr(string(entity.StatusValid))}).Error; err != nil {
+ if err := db.Create(&entity.UserTenant{ID: "ut-owner", UserID: "owner-1", TenantID: "tenant-1", Role: "owner", Status: sptr(string(entity.StatusValid)), LLMID: "llm-1", EmbdID: "embd-1", ASRID: "asr-1"}).Error; err != nil {
t.Fatalf("insert tenant owner: %v", err)
}
pipelineID := "pipe-1"
@@ -1228,6 +1247,7 @@ func setupHandlerAccessDB(t *testing.T) *gorm.DB {
&entity.Tenant{},
&entity.UserTenant{},
&entity.Knowledgebase{},
+ &entity.Document{},
); err != nil {
t.Fatalf("failed to migrate: %v", err)
}
@@ -1235,16 +1255,20 @@ func setupHandlerAccessDB(t *testing.T) *gorm.DB {
// Insert user
db.Create(&entity.User{ID: "user-1", Nickname: "test", Email: "[email protected]", Password: sptr("x")})
// Insert tenant
- db.Create(&entity.Tenant{ID: "tenant-1", LLMID: "llm-1", EmbdID: "embd-1", ASRID: "asr-1"})
+ db.Create(&entity.Tenant{ID: "tenant-1"})
// Insert user_tenant mapping
- db.Create(&entity.UserTenant{ID: "ut-owner", UserID: "owner-1", TenantID: "tenant-1", Role: "owner", Status: sptr(string(entity.StatusValid))})
+ db.Create(&entity.UserTenant{ID: "ut-owner", UserID: "owner-1", TenantID: "tenant-1", Role: "owner", Status: sptr(string(entity.StatusValid)), LLMID: "llm-1", EmbdID: "embd-1", ASRID: "asr-1"})
db.Create(&entity.UserTenant{ID: "ut-1", UserID: "user-1", TenantID: "tenant-1", Role: "normal", Status: sptr(string(entity.StatusValid))})
- // Insert knowledgebase
+ // Insert knowledgebase and its document for the resource-level access check.
db.Create(&entity.Knowledgebase{
ID: "ds-1", TenantID: "tenant-1", Name: "test-kb", EmbdID: "embd-1",
CreatedBy: "user-1", Permission: string(entity.TenantPermissionTeam),
Status: sptr(string(entity.StatusValid)),
})
+ db.Create(&entity.Document{
+ ID: "doc-1", KbID: "ds-1", ParserID: "naive", ParserConfig: entity.JSONMap{},
+ CreatedBy: "user-1", Type: "pdf", Suffix: "pdf", Status: sptr(string(entity.StatusValid)),
+ })
return db
}
@@ -2130,8 +2154,10 @@ func downloadHandlerWithAccessDB(t *testing.T) *DocumentHandler {
dao.DB = db
t.Cleanup(func() { dao.DB = orig })
return &DocumentHandler{
- documentService: &fakeDocumentService{},
- datasetService: dataset.NewDatasetService(),
+ documentService: &fakeDocumentService{doc: &document.DocumentResponse{
+ ID: "doc-1", KbID: "ds-1", CreatedBy: "user-1", Type: "pdf", Status: sptr(string(entity.StatusValid)),
+ }},
+ datasetService: dataset.NewDatasetService(),
}
}
@@ -2182,9 +2208,39 @@ func TestDownloadDocument_NotFound(t *testing.T) {
}
}
+func TestDownloadDocument_LookupErrorReturnsServerError(t *testing.T) {
+ h := downloadHandlerWithAccessDB(t)
+ h.documentService = &fakeDocumentService{docErr: errors.New("database connection failed")}
+ c, w := downloadContextAs("user-1", "ds-1", "doc-1")
+
+ h.DownloadDocument(c)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("expected 200 response envelope, got %d", w.Code)
+ }
+ var resp map[string]interface{}
+ if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+ t.Fatalf("decode response: %v", err)
+ }
+ if resp["code"] != float64(common.CodeServerError) {
+ t.Fatalf("expected code %d, got %v", common.CodeServerError, resp["code"])
+ }
+ if resp["message"] != "Failed to download document" {
+ t.Fatalf("unexpected client-visible error: %v", resp["message"])
+ }
+ if strings.Contains(w.Body.String(), "database connection failed") {
+ t.Fatal("database error detail leaked to the client")
+ }
+}
+
func TestDownloadDocument_ServiceErrorReturnsServerError(t *testing.T) {
h := downloadHandlerWithAccessDB(t)
- h.documentService = &fakeDocumentService{downloadErr: errors.New("database connection failed")}
+ h.documentService = &fakeDocumentService{
+ doc: &document.DocumentResponse{
+ ID: "doc-1", KbID: "ds-1", CreatedBy: "user-1", Type: "pdf", Status: sptr(string(entity.StatusValid)),
+ },
+ downloadErr: errors.New("database connection failed"),
+ }
c, w := downloadContextAs("user-1", "ds-1", "doc-1")
h.DownloadDocument(c)
diff --git a/internal/handler/file.go b/internal/handler/file.go
index 3d8ada706e..836a197954 100644
--- a/internal/handler/file.go
+++ b/internal/handler/file.go
@@ -262,7 +262,11 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
}
parentID := c.PostForm("parent_id")
if parentID == "" {
- rootFolder, err := h.fileService.GetRootFolder(ctx, userID)
+ tenantID := strings.TrimSpace(c.GetString("tenant_id"))
+ if tenantID == "" {
+ tenantID = userID
+ }
+ rootFolder, err := h.fileService.GetRootFolder(ctx, tenantID)
if err != nil {
respondFileServiceError(c, err)
return
@@ -306,7 +310,11 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
parentID := req.ParentID
if parentID == "" {
- rootFolder, err := h.fileService.GetRootFolder(ctx, userID)
+ tenantID := strings.TrimSpace(c.GetString("tenant_id"))
+ if tenantID == "" {
+ tenantID = userID
+ }
+ rootFolder, err := h.fileService.GetRootFolder(ctx, tenantID)
if err != nil {
respondFileServiceError(c, err)
return
diff --git a/internal/handler/file_commit.go b/internal/handler/file_commit.go
index 2ba8acb169..5ea68ef3da 100644
--- a/internal/handler/file_commit.go
+++ b/internal/handler/file_commit.go
@@ -102,7 +102,7 @@ func CommitFolderResolver(h *FileCommitHandler, entityType, urlParam string) gin
operation = permission.OperationRead
}
if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: user.ID}, id, operation); err != nil {
- respondHTTPPermissionError(c, err, true)
+ respondPermissionError(c, err, true)
c.Abort()
return
}
diff --git a/internal/handler/providers.go b/internal/handler/providers.go
index 1c26ddef7e..ae12926dc4 100644
--- a/internal/handler/providers.go
+++ b/internal/handler/providers.go
@@ -17,7 +17,7 @@
package handler
import (
- "bytes"
+ "context"
"encoding/json"
"errors"
"fmt"
@@ -26,7 +26,6 @@ import (
"ragflow/internal/dao"
"ragflow/internal/entity/models"
"ragflow/internal/service"
- "regexp"
"sort"
"strings"
"time"
@@ -179,6 +178,44 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
return
}
+ apiKey := strings.TrimSpace(c.Query("api_key"))
+ baseURL := strings.TrimSpace(c.Query("base_url"))
+ if instanceName := strings.TrimSpace(c.Query("instance_name")); instanceName != "" && (apiKey == "" || baseURL == "") {
+ instanceModels, err := h.modelProviderService.ListSupportedModels(c.Request.Context(), providerName, instanceName, c.GetString("user_id"))
+ if err == nil {
+ for _, model := range instanceModels {
+ if _, ok := model["max_tokens"]; !ok {
+ if contextLength, ok := model["context_length"]; ok && contextLength != nil {
+ model["max_tokens"] = contextLength
+ }
+ }
+ }
+ common.SuccessWithData(c, instanceModels, "success")
+ return
+ }
+ if apiKey == "" && baseURL == "" {
+ common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ return
+ }
+ }
+
+ result, err := FetchProviderModels(c.Request.Context(), providerName, apiKey, baseURL)
+ if err != nil {
+ var codedErr *common.CodedError
+ if errors.As(err, &codedErr) {
+ common.ErrorWithCode(c, codedErr.Code, codedErr.Message)
+ } else {
+ common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ }
+ return
+ }
+ common.SuccessWithData(c, result, "success")
+}
+
+// FetchProviderModels returns the bundled model catalog, optionally enriched
+// with models discovered from the configured provider endpoint. Admin uses the
+// same catalog behavior while resolving its system-scoped provider data.
+func FetchProviderModels(ctx context.Context, providerName, apiKey, baseURL string) ([]map[string]interface{}, error) {
// 1. Get static models from config (maybe nil when models list is empty)
staticModels, _ := dao.GetModelProviderManager().ListModels(providerName)
if staticModels == nil {
@@ -186,11 +223,8 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
}
// 2. Attempt live API fetch when the provider has enough connection data.
- // Both are trimmed: a key pasted from a console routinely carries a trailing
- // newline, and the upstream answers that with 401 "invalid key" rather than
- // with anything that points at the whitespace.
- apiKey := strings.TrimSpace(c.Query("api_key"))
- baseURL := strings.TrimSpace(c.Query("base_url"))
+ apiKey = strings.TrimSpace(apiKey)
+ baseURL = strings.TrimSpace(baseURL)
var remoteModels []map[string]interface{}
remoteFetched := false
// remoteFetchErr records why a requested live fetch produced nothing, so it
@@ -212,37 +246,6 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
}
}
- // A refresh on an already-saved instance carries no credential: the browser
- // never sees the stored key. Resolve the instance server-side and list from
- // it, so the picker behaves the same before and after saving. Without this,
- // a provider with no static catalog (SystemOne) lists nothing once saved,
- // and there is no model left to pick.
- if instanceName := strings.TrimSpace(c.Query("instance_name")); instanceName != "" && (apiKey == "" || baseURL == "") {
- instanceModels, err := h.modelProviderService.ListSupportedModels(c.Request.Context(), providerName, instanceName, c.GetString("user_id"))
- if err == nil {
- for _, m := range instanceModels {
- // Keep the response shape identical to the credentials-based
- // branch below: the picker reads max_tokens and would show an
- // empty context window otherwise.
- if _, ok := m["max_tokens"]; !ok {
- if contextLength, ok := m["context_length"]; ok && contextLength != nil {
- m["max_tokens"] = contextLength
- }
- }
- }
- common.SuccessWithData(c, instanceModels, "success")
- return
- }
- if apiKey == "" && baseURL == "" {
- // Nothing else to try: the instance is the only source of
- // credentials, so its failure is the answer.
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
- return
- }
- // The name may belong to a draft that is not saved yet. Fall through and
- // use the credentials sent with this request instead.
- }
-
canFetchRemote := baseURL != ""
if bedrockProvider {
// Bedrock's existing SigV4 modes keep using the static catalog. Only
@@ -260,7 +263,7 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
ApiKey: &apiKey,
Region: &region,
}
- if liveModels, err := driver.ListModels(c.Request.Context(), apiConfig); err == nil {
+ if liveModels, err := driver.ListModels(ctx, apiConfig); err == nil {
remoteFetched = true
for _, m := range liveModels {
legacyMaxTokens := 0
@@ -276,8 +279,7 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
})
}
} else if bedrockAPIKeyAuth {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
- return
+ return nil, common.NewCodedError(common.CodeServerError, err.Error())
} else {
remoteFetchErr = err
}
@@ -286,8 +288,7 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
}
if remoteFetched && bedrockAPIKeyAuth {
if len(remoteModels) == 0 {
- common.ErrorWithCode(c, common.CodeDataError, "No Bedrock models were discovered")
- return
+ return nil, common.NewCodedError(common.CodeDataError, "No Bedrock models were discovered")
}
remoteNames := make(map[string]struct{}, len(remoteModels))
for _, model := range remoteModels {
@@ -312,11 +313,9 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
// success makes a wrong credential look like a provider with no models.
if len(staticModels) == 0 && len(remoteModels) == 0 {
if remoteFetchErr != nil {
- common.ErrorWithCode(c, common.CodeDataError, remoteFetchErr.Error())
- return
+ return nil, common.NewCodedError(common.CodeDataError, remoteFetchErr.Error())
}
- common.SuccessWithData(c, []map[string]interface{}{}, "success")
- return
+ return []map[string]interface{}{}, nil
}
// 4. Merge: static as base, remote overrides on name conflicts.
@@ -325,7 +324,7 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
// 5. Fill missing model types using only the merged list.
fillProviderModelMapTypes(result)
- common.SuccessWithData(c, result, "success")
+ return result, nil
}
// mergeProviderModels collapses the bundled catalog listing and a live upstream
@@ -461,50 +460,6 @@ func (h *ProviderHandler) ShowModel(c *gin.Context) {
common.SuccessWithData(c, model, "success")
}
-type CreateProviderInstanceRequest struct {
- InstanceName string `json:"instance_name" binding:"required"`
- APIKey json.RawMessage `json:"api_key"`
- BaseURL string `json:"base_url"`
- Region string `json:"region"`
- ModelInfo []service.CreateInstanceModelInfo `json:"model_info"`
-}
-
-// normalizeAPIKey accepts api_key as either a JSON string or a JSON object
-// (credential bundles such as XunFei Spark's
-// {"spark_api_password": ..., "spark_app_id": ..., ...}) and normalizes it to
-// the string form persisted on the instance.
-func normalizeAPIKey(raw json.RawMessage) string {
- trimmed := strings.TrimSpace(string(raw))
- if trimmed == "" || trimmed == "null" {
- return ""
- }
- var s string
- if err := json.Unmarshal(raw, &s); err == nil {
- return s
- }
- var buf bytes.Buffer
- if err := json.Compact(&buf, raw); err != nil {
- return trimmed
- }
- return buf.String()
-}
-
-// instanceNamePattern restricts an instance name to digits, underscores,
-// hyphens, and ASCII letters in both cases.
-var instanceNamePattern = regexp.MustCompile(`^[0-9A-Za-z_-]+$`)
-
-// validateInstanceName rejects an empty instance name or one carrying any
-// character outside digits, underscores, hyphens, and ASCII letters.
-func validateInstanceName(instanceName string) error {
- if instanceName == "" {
- return errors.New("instance name is required")
- }
- if !instanceNamePattern.MatchString(instanceName) {
- return errors.New("instance name may only contain digits, underscores, hyphens, and letters")
- }
- return nil
-}
-
func (h *ProviderHandler) CreateProviderInstance(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
@@ -513,19 +468,19 @@ func (h *ProviderHandler) CreateProviderInstance(c *gin.Context) {
}
ctx := c.Request.Context()
- var req CreateProviderInstanceRequest
+ var req service.CreateProviderInstanceRequest
if err := c.ShouldBindJSON(&req); err != nil {
common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
return
}
- if err := validateInstanceName(req.InstanceName); err != nil {
+ if err := service.ValidateProviderInstanceName(req.InstanceName); err != nil {
common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
return
}
userID := c.GetString("user_id")
- apiKey := normalizeAPIKey(req.APIKey)
+ apiKey := service.NormalizeAPIKey(req.APIKey)
// If the request body only contains "instance_name", create a name-only
// instance without API key validation or model creation.
@@ -634,7 +589,7 @@ func (h *ProviderHandler) CheckConnection(c *gin.Context) {
}
userID := c.GetString("user_id")
- errCode, err := h.modelProviderService.CheckConnection(ctx, providerName, normalizeAPIKey(req.APIKey), req.Region, req.BaseURL, req.InstanceID, userID, req.ModelInfo)
+ errCode, err := h.modelProviderService.CheckConnection(ctx, providerName, service.NormalizeAPIKey(req.APIKey), req.Region, req.BaseURL, req.InstanceID, userID, req.ModelInfo)
if err != nil {
common.ErrorWithCode(c, errCode, err.Error())
return
@@ -736,14 +691,6 @@ func (h *ProviderHandler) ShowTask(c *gin.Context) {
common.SuccessWithData(c, taskResponse, "success")
}
-type AlterProviderInstanceRequest struct {
- InstanceName string `json:"instance_name"`
- APIKey json.RawMessage `json:"api_key"`
- BaseURL string `json:"base_url"`
- Region string `json:"region"`
- ModelInfo *[]service.CreateInstanceModelInfo `json:"model_info" binding:"required"`
-}
-
func (h *ProviderHandler) AlterProviderInstance(c *gin.Context) {
ctx := c.Request.Context()
providerName := c.Param("provider_id_or_name")
@@ -758,7 +705,7 @@ func (h *ProviderHandler) AlterProviderInstance(c *gin.Context) {
return
}
- var req AlterProviderInstanceRequest
+ var req service.AlterProviderInstanceRequest
if err := c.ShouldBindJSON(&req); err != nil {
common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
return
@@ -770,7 +717,7 @@ func (h *ProviderHandler) AlterProviderInstance(c *gin.Context) {
return
}
- code, err := h.modelProviderService.AlterProviderInstance(ctx, userID, providerName, instanceName, req.InstanceName, normalizeAPIKey(req.APIKey), req.BaseURL, req.Region, *req.ModelInfo)
+ code, err := h.modelProviderService.AlterProviderInstance(ctx, userID, providerName, instanceName, req.InstanceName, service.NormalizeAPIKey(req.APIKey), req.BaseURL, req.Region, *req.ModelInfo)
if err != nil {
common.ErrorWithCode(c, code, err.Error())
return
@@ -779,17 +726,13 @@ func (h *ProviderHandler) AlterProviderInstance(c *gin.Context) {
common.SuccessWithMessage(c, "success")
}
-type DropProviderInstanceRequest struct {
- Instances []string `json:"instances" binding:"required,min=1,dive,required"`
-}
-
func (h *ProviderHandler) DropProviderInstance(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
- var req DropProviderInstanceRequest
+ var req service.DropProviderInstanceRequest
if err := c.ShouldBindJSON(&req); err != nil {
common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
return
@@ -848,14 +791,6 @@ func (h *ProviderHandler) ListInstanceModels(c *gin.Context) {
common.SuccessWithData(c, modelInstances, "success")
}
-type AlterModelRequest struct {
- ModelID string `json:"model_id"`
- Status string `json:"status"`
- MaxTokens int `json:"max_tokens"`
- ModelType interface{} `json:"model_type"`
- Extra interface{} `json:"extra"`
-}
-
func (h *ProviderHandler) AlterModel(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
@@ -869,7 +804,7 @@ func (h *ProviderHandler) AlterModel(c *gin.Context) {
return
}
- var req AlterModelRequest
+ var req service.AlterModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
return
@@ -973,10 +908,6 @@ func (h *ProviderHandler) AddModel(c *gin.Context) {
common.ErrorWithCode(c, code, "success")
}
-type DropInstanceModelRequest struct {
- ModelNames []string `json:"model_name"`
-}
-
func (h *ProviderHandler) DropInstanceModels(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
@@ -989,7 +920,7 @@ func (h *ProviderHandler) DropInstanceModels(c *gin.Context) {
return
}
- var req DropInstanceModelRequest
+ var req service.DropInstanceModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
return
diff --git a/internal/handler/providers_test.go b/internal/handler/providers_test.go
index b7e0fa4db8..9f5b9e70cf 100644
--- a/internal/handler/providers_test.go
+++ b/internal/handler/providers_test.go
@@ -33,7 +33,7 @@ func TestDropProviderInstanceRequestRequiresNonEmptyInstances(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- var req DropProviderInstanceRequest
+ var req service.DropProviderInstanceRequest
if err := json.Unmarshal([]byte(tt.payload), &req); err != nil {
t.Fatal(err)
}
@@ -241,8 +241,8 @@ func TestValidateInstanceName(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- if err := validateInstanceName(tt.name); (err == nil) != tt.valid {
- t.Fatalf("validateInstanceName(%q) error = %v, valid = %v", tt.name, err, tt.valid)
+ if err := service.ValidateProviderInstanceName(tt.name); (err == nil) != tt.valid {
+ t.Fatalf("ValidateProviderInstanceName(%q) error = %v, valid = %v", tt.name, err, tt.valid)
}
})
}
diff --git a/internal/handler/tenant.go b/internal/handler/tenant.go
index ca093ef236..370768b3d9 100644
--- a/internal/handler/tenant.go
+++ b/internal/handler/tenant.go
@@ -560,11 +560,6 @@ func (h *TenantHandler) RemoveTenantMember(c *gin.Context) {
common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
return
}
- if !matchesActiveTenant(c, tenantID) {
- common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")
- return
- }
-
var body struct {
UserID string `json:"user_id"`
}
@@ -572,6 +567,10 @@ func (h *TenantHandler) RemoveTenantMember(c *gin.Context) {
common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "user_id is required")
return
}
+ if body.UserID != user.ID && !matchesActiveTenant(c, tenantID) {
+ common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")
+ return
+ }
ctx := c.Request.Context()
code, err := h.tenantService.RemoveMember(ctx, user.ID, tenantID, body.UserID)
@@ -582,7 +581,7 @@ func (h *TenantHandler) RemoveTenantMember(c *gin.Context) {
common.SuccessWithData(c, true, "success")
}
-// AcceptTenantInvite accepts a pending team invitation, transitioning role invite → normal.
+// AcceptTenantInvite accepts a pending invitation, transitioning membership status to joined.
// @Summary Accept tenant invitation
// @Tags tenants
// @Produce json
@@ -600,11 +599,6 @@ func (h *TenantHandler) AcceptTenantInvite(c *gin.Context) {
common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
return
}
- if !matchesActiveTenant(c, tenantID) {
- common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")
- return
- }
-
ctx := c.Request.Context()
code, err := h.tenantService.AcceptInvite(ctx, user.ID, tenantID)
if err != nil {
diff --git a/internal/ingestion/component/dispatch_model.go b/internal/ingestion/component/dispatch_model.go
index a703a985d7..e28b6adddc 100644
--- a/internal/ingestion/component/dispatch_model.go
+++ b/internal/ingestion/component/dispatch_model.go
@@ -30,6 +30,7 @@ import (
"ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
"ragflow/internal/ingestion/component/schema"
+ "ragflow/internal/permission"
"gorm.io/gorm"
)
@@ -63,39 +64,35 @@ func configuredAudioModelID(setup schema.ParserSetup) string {
return getStringOr(setup, "llm_id", "")
}
-// defaultResolveTenantModelByType resolves the tenant's configured default for
-// modelType, requiring a nonempty default model reference first. It then tries
-// the enrolled tenant-model ID and falls back to the configured reference if
-// that ID is absent or cannot be resolved.
+// defaultResolveTenantModelByType resolves the current member's configured default.
func defaultResolveTenantModelByType(ctx context.Context, db *gorm.DB, tenantID string, modelType entity.ModelType) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- tenantDAO := dao.NewTenantDAO()
- tenant, err := tenantDAO.GetByID(ctx, db, tenantID)
+ membership, err := resolveDefaultModelMembership(ctx, db, tenantID)
if err != nil {
- return nil, "", nil, 0, err
+ return nil, "", nil, 0, fmt.Errorf("load default model settings for tenant %s: %w", tenantID, err)
}
var modelID string
switch modelType {
case entity.ModelTypeChat:
- modelID = tenant.LLMID
+ modelID = membership.LLMID
case entity.ModelTypeEmbedding:
- modelID = tenant.EmbdID
+ modelID = membership.EmbdID
case entity.ModelTypeRerank:
- modelID = tenant.RerankID
+ modelID = membership.RerankID
case entity.ModelTypeSpeech2Text:
- modelID = tenant.ASRID
+ modelID = membership.ASRID
case entity.ModelTypeImage2Text:
- modelID = tenant.Img2TxtID
+ modelID = membership.Img2TxtID
case entity.ModelTypeTTS:
- modelID = *tenant.TTSID
+ modelID = stringValue(membership.TTSID)
case entity.ModelTypeOCR:
- modelID = *tenant.OCRID
+ modelID = stringValue(membership.OCRID)
default:
return nil, "", nil, 0, fmt.Errorf("invalid model type: %s", modelType)
}
if modelID == "" {
return nil, "", nil, 0, fmt.Errorf("no default %s model is set", modelType)
}
- if tenantModelID := tenantModelIDByType(tenant, modelType); tenantModelID != "" {
+ if tenantModelID := tenantModelIDByType(membership, modelType); tenantModelID != "" {
resolved, err := resolveModelConfigByID(ctx, db, tenantID, modelType, tenantModelID)
if err == nil {
return resolved.driver, resolved.model.ModelName, resolved.apiConfig, resolved.contextLength, nil
@@ -177,25 +174,36 @@ func ocrProviderAliases(providerName string) []string {
}
}
-func tenantModelIDByType(tenant *entity.Tenant, modelType entity.ModelType) string {
- if tenant == nil {
+func resolveDefaultModelMembership(ctx context.Context, db *gorm.DB, tenantID string) (*entity.UserTenant, error) {
+ membershipDAO := dao.NewUserTenantDAO()
+ if subject, ok := permission.SubjectFromContext(ctx); ok && subject.UserID != "" && (subject.TenantID == "" || subject.TenantID == tenantID) {
+ membership, err := membershipDAO.FilterByUserIDAndTenantID(ctx, db, subject.UserID, tenantID)
+ if err == nil {
+ return membership, nil
+ }
+ }
+ return membershipDAO.GetOwnerByTenantID(ctx, db, tenantID)
+}
+
+func tenantModelIDByType(membership *entity.UserTenant, modelType entity.ModelType) string {
+ if membership == nil {
return ""
}
switch modelType {
case entity.ModelTypeChat:
- return stringValue(tenant.TenantLLMID)
+ return stringValue(membership.TenantLLMID)
case entity.ModelTypeEmbedding:
- return stringValue(tenant.TenantEmbdID)
+ return stringValue(membership.TenantEmbdID)
case entity.ModelTypeRerank:
- return stringValue(tenant.TenantRerankID)
+ return stringValue(membership.TenantRerankID)
case entity.ModelTypeSpeech2Text:
- return stringValue(tenant.TenantASRID)
+ return stringValue(membership.TenantASRID)
case entity.ModelTypeImage2Text:
- return stringValue(tenant.TenantImg2TxtID)
+ return stringValue(membership.TenantImg2TxtID)
case entity.ModelTypeTTS:
- return stringValue(tenant.TenantTTSID)
+ return stringValue(membership.TenantTTSID)
case entity.ModelTypeOCR:
- return stringValue(tenant.TenantOCRID)
+ return stringValue(membership.TenantOCRID)
default:
return ""
}
diff --git a/internal/ingestion/component/extractor.go b/internal/ingestion/component/extractor.go
index 3c13debdeb..7296a51afb 100644
--- a/internal/ingestion/component/extractor.go
+++ b/internal/ingestion/component/extractor.go
@@ -1680,14 +1680,14 @@ func defaultChatModelRef(ctx context.Context, db *gorm.DB, tenantID string) stri
// No database to read the tenant's default chat model from.
return ""
}
- tenant, err := dao.NewTenantDAO().GetByID(ctx, db, tenantID)
- if err != nil || tenant == nil {
+ membership, err := resolveDefaultModelMembership(ctx, db, tenantID)
+ if err != nil || membership == nil {
return ""
}
- if tenant.TenantLLMID != nil && *tenant.TenantLLMID != "" {
- return *tenant.TenantLLMID
+ if membership.TenantLLMID != nil && *membership.TenantLLMID != "" {
+ return *membership.TenantLLMID
}
- return tenant.LLMID
+ return membership.LLMID
}
// extractorContextFitBudget returns 97% of the model's context window as the
diff --git a/internal/ingestion/component/extractor_test.go b/internal/ingestion/component/extractor_test.go
index e3195ce08b..ea5d441190 100644
--- a/internal/ingestion/component/extractor_test.go
+++ b/internal/ingestion/component/extractor_test.go
@@ -1368,7 +1368,7 @@ func openExtractorContextTestDB(t *testing.T) *gorm.DB {
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
- if err := db.AutoMigrate(&entity.Tenant{}, &entity.TenantModelProvider{}, &entity.TenantModelInstance{}, &entity.TenantModel{}); err != nil {
+ if err := db.AutoMigrate(&entity.Tenant{}, &entity.UserTenant{}, &entity.TenantModelProvider{}, &entity.TenantModelInstance{}, &entity.TenantModel{}); err != nil {
t.Fatalf("migrate: %v", err)
}
return db
@@ -1377,16 +1377,16 @@ func openExtractorContextTestDB(t *testing.T) *gorm.DB {
func seedExtractorContextModel(t *testing.T, db *gorm.DB, tenantLLMID string) {
t.Helper()
status := "1"
- tenant := entity.Tenant{
- ID: "tenant-1",
- LLMID: "gpt-4o@openai",
- Status: &status,
+ tenant := entity.Tenant{ID: "tenant-1", Status: &status}
+ if err := db.Create(&tenant).Error; err != nil {
+ t.Fatalf("create tenant: %v", err)
}
+ membership := entity.UserTenant{ID: "ut-tenant1", UserID: "tenant-1", TenantID: "tenant-1", Role: "owner", Status: &status, LLMID: "gpt-4o@openai"}
if tenantLLMID != "" {
- tenant.TenantLLMID = &tenantLLMID
+ membership.TenantLLMID = &tenantLLMID
}
- if err := db.Create(&tenant).Error; err != nil {
- t.Fatalf("create tenant: %v", err)
+ if err := db.Create(&membership).Error; err != nil {
+ t.Fatalf("create owner membership: %v", err)
}
if err := db.Create(&entity.TenantModelProvider{
ID: "provider-openai",
diff --git a/internal/ingestion/pipeline/real_storage_integration_test.go b/internal/ingestion/pipeline/real_storage_integration_test.go
index 387a123b0c..e28461298d 100644
--- a/internal/ingestion/pipeline/real_storage_integration_test.go
+++ b/internal/ingestion/pipeline/real_storage_integration_test.go
@@ -52,6 +52,7 @@ func TestPipelineRun_TemplateGeneral_RealMySQLMinIO_OutputShape(t *testing.T) {
realDB := mustOpenRealMySQL(t, cfg)
if err := realDB.AutoMigrate(
&entity.Tenant{},
+ &entity.UserTenant{},
&entity.Knowledgebase{},
&entity.Document{},
&entity.File{},
@@ -396,11 +397,20 @@ func mustSeedRealPipelineDocument(
t.Helper()
if err := db.Create(&entity.Tenant{
ID: tenantID,
- LLMID: "gpt-4",
Status: strPtr("1"),
}).Error; err != nil {
t.Fatalf("create tenant: %v", err)
}
+ if err := db.Create(&entity.UserTenant{
+ ID: tenantID,
+ UserID: tenantID,
+ TenantID: tenantID,
+ Role: "owner",
+ Status: strPtr(entity.TenantMembershipStatusJoined),
+ LLMID: "gpt-4",
+ }).Error; err != nil {
+ t.Fatalf("create tenant owner membership: %v", err)
+ }
if err := db.Create(&entity.Knowledgebase{
ID: kbID,
TenantID: tenantID,
@@ -450,6 +460,7 @@ func mustSeedRealPipelineDocument(
}
func cleanupRealPipelineDocument(db *gorm.DB, stg storage.Storage, tenantID, kbID, docID, fileID, bucket, objectPath string) {
+ _ = db.Where("tenant_id = ?", tenantID).Delete(&entity.UserTenant{}).Error
_ = db.Where("document_id = ?", docID).Delete(&entity.File2Document{}).Error
_ = db.Where("id = ?", docID).Delete(&entity.Document{}).Error
_ = db.Where("id = ?", fileID).Delete(&entity.File{}).Error
diff --git a/internal/ingestion/service/worker_dispatcher_helpers_test.go b/internal/ingestion/service/worker_dispatcher_helpers_test.go
index 1367aa465e..4cc8c249a7 100644
--- a/internal/ingestion/service/worker_dispatcher_helpers_test.go
+++ b/internal/ingestion/service/worker_dispatcher_helpers_test.go
@@ -30,9 +30,12 @@ import (
func seedBurstTasks(t *testing.T, db *gorm.DB, n int) []string {
t.Helper()
const tenantID, kbID = "burst-tenant", "burst-kb"
- if err := db.Create(&entity.Tenant{ID: tenantID, LLMID: "gpt-4", Status: testutil.StrPtr("1")}).Error; err != nil {
+ if err := db.Create(&entity.Tenant{ID: tenantID, Status: testutil.StrPtr("1")}).Error; err != nil {
t.Fatalf("create tenant: %v", err)
}
+ if err := db.Create(&entity.UserTenant{ID: "owner-" + tenantID, UserID: tenantID, TenantID: tenantID, Role: "owner", Status: testutil.StrPtr("1"), LLMID: "gpt-4"}).Error; err != nil {
+ t.Fatalf("create owner membership: %v", err)
+ }
if err := db.Create(&entity.Knowledgebase{
ID: kbID, TenantID: tenantID, EmbdID: "embd-1", Status: testutil.StrPtr("1"), ParserConfig: entity.JSONMap{},
}).Error; err != nil {
diff --git a/internal/ingestion/task/pipeline_real_integration_test.go b/internal/ingestion/task/pipeline_real_integration_test.go
index c1b447f074..73d3d6a77b 100644
--- a/internal/ingestion/task/pipeline_real_integration_test.go
+++ b/internal/ingestion/task/pipeline_real_integration_test.go
@@ -433,6 +433,7 @@ func mustOpenTaskTestDB(t *testing.T) *gorm.DB {
}
if err = db.AutoMigrate(
&entity.Tenant{},
+ &entity.UserTenant{},
&entity.Knowledgebase{},
&entity.Document{},
&entity.File{},
@@ -611,16 +612,17 @@ func mustSeedTaskRealPipelineDocumentBytes(
ocrID := "ocr-default"
if err := db.Create(&entity.Tenant{
ID: tenantID,
- LLMID: "gpt-4",
- ASRID: "asr-default",
- Img2TxtID: "img2txt-default",
- RerankID: "rerank-default",
ParserIDs: "parser-default",
- OCRID: &ocrID,
Status: taskStrPtr("1"),
}).Error; err != nil {
t.Fatalf("create tenant: %v", err)
}
+ if err := db.Create(&entity.UserTenant{
+ ID: "owner-" + tenantID, UserID: tenantID, TenantID: tenantID, Role: "owner", Status: taskStrPtr("1"),
+ LLMID: "gpt-4", ASRID: "asr-default", Img2TxtID: "img2txt-default", RerankID: "rerank-default", OCRID: &ocrID,
+ }).Error; err != nil {
+ t.Fatalf("create tenant owner membership: %v", err)
+ }
if err := db.Create(&entity.Knowledgebase{
ID: kbID,
TenantID: tenantID,
diff --git a/internal/ingestion/task/real_consumer_test.go b/internal/ingestion/task/real_consumer_test.go
index 253e3f2e29..37c467badf 100644
--- a/internal/ingestion/task/real_consumer_test.go
+++ b/internal/ingestion/task/real_consumer_test.go
@@ -59,7 +59,8 @@ func TestRealProducerConsumer(t *testing.T) {
cleanup := testutil.ReplaceDBForTest(t, db)
defer cleanup()
- db.Create(&entity.Tenant{ID: "t1", LLMID: "gpt-4", Status: testutil.StrPtr("1")})
+ db.Create(&entity.Tenant{ID: "t1", Status: testutil.StrPtr("1")})
+ db.Create(&entity.UserTenant{ID: "owner-t1", UserID: "t1", TenantID: "t1", Role: "owner", Status: testutil.StrPtr("1"), LLMID: "gpt-4"})
db.Create(&entity.Knowledgebase{ID: "kb1", TenantID: "t1", EmbdID: "e1", Status: testutil.StrPtr("1"), ParserConfig: entity.JSONMap{}})
docName := "doc-real.pdf"
db.Create(&entity.Document{ID: "doc-real", KbID: "kb1", ParserID: "naive", ParserConfig: entity.JSONMap{}, Name: &docName})
diff --git a/internal/ingestion/testutil/helpers.go b/internal/ingestion/testutil/helpers.go
index 78c4a295a9..7f8d634cce 100644
--- a/internal/ingestion/testutil/helpers.go
+++ b/internal/ingestion/testutil/helpers.go
@@ -69,6 +69,7 @@ func SetupTestDB(t *testing.T, tables ...any) *gorm.DB {
&entity.Document{},
&entity.Knowledgebase{},
&entity.Tenant{},
+ &entity.UserTenant{},
&entity.File{},
&entity.File2Document{},
}
@@ -77,6 +78,9 @@ func SetupTestDB(t *testing.T, tables ...any) *gorm.DB {
if err = db.AutoMigrate(tables...); err != nil {
t.Fatalf("auto-migrate: %v", err)
}
+ if err = db.AutoMigrate(&entity.UserTenant{}); err != nil {
+ t.Fatalf("auto-migrate user_tenant: %v", err)
+ }
return db
}
@@ -161,13 +165,15 @@ func SeedTestData(t *testing.T, db *gorm.DB, opts ...TestDataOption) (string, st
}
// Create Tenant
- if err := db.Create(&entity.Tenant{
- ID: cfg.tenantID,
- LLMID: "gpt-4",
- Status: StrPtr("1"),
- }).Error; err != nil {
+ if err := db.Create(&entity.Tenant{ID: cfg.tenantID, Status: StrPtr("1")}).Error; err != nil {
t.Fatalf("create tenant: %v", err)
}
+ if err := db.Create(&entity.UserTenant{
+ ID: "owner-" + cfg.tenantID, UserID: cfg.tenantID, TenantID: cfg.tenantID, Role: "owner",
+ Status: StrPtr("1"), LLMID: "gpt-4",
+ }).Error; err != nil {
+ t.Fatalf("create tenant owner membership: %v", err)
+ }
// Create Knowledgebase
if err := db.Create(&entity.Knowledgebase{
diff --git a/internal/permission/database_source.go b/internal/permission/database_source.go
index 7816b6da69..6d5e0e4b78 100644
--- a/internal/permission/database_source.go
+++ b/internal/permission/database_source.go
@@ -1248,6 +1248,19 @@ func fileResource(kind ResourceKind, file *entity.File, datasetIDs []string, dat
if ownerUserID == "" {
ownerUserID = strings.TrimSpace(file.TenantID)
}
+ if file.ParentID == file.ID {
+ return Resource{
+ Ref: ResourceRef{Kind: kind, ID: file.ID},
+ TenantID: file.TenantID,
+ CreatedBy: file.CreatedBy,
+ OwnerUserID: ownerUserID,
+ Visibility: VisibilityTenant,
+ TenantRequirement: TenantMember,
+ OwnerOperations: []Operation{OperationRead, OperationCreate, OperationUpdate, OperationDelete, OperationShare, OperationRun, OperationUse},
+ TenantOperations: []Operation{OperationRead, OperationCreate},
+ Active: true,
+ }
+ }
return Resource{
Ref: ResourceRef{Kind: kind, ID: file.ID},
TenantID: file.TenantID,
diff --git a/internal/permission/database_source_test.go b/internal/permission/database_source_test.go
index ed00d340f5..853d90988a 100644
--- a/internal/permission/database_source_test.go
+++ b/internal/permission/database_source_test.go
@@ -689,6 +689,37 @@ func TestDatabaseCheckerAuthorizesFilesThroughLinkedDatasetAccess(t *testing.T)
}
}
+func TestDatabaseSourceResolvesFileOwnerFromItsTenant(t *testing.T) {
+ db, err := gorm.Open(sqlite.Open("file:"+url.QueryEscape(t.Name())+"?mode=memory&cache=shared"), &gorm.Config{})
+ if err != nil {
+ t.Fatalf("open sqlite: %v", err)
+ }
+ if err := db.AutoMigrate(&entity.File{}, &entity.File2Document{}, &entity.Document{}, &entity.Knowledgebase{}, &entity.UserTenant{}); err != nil {
+ t.Fatalf("migrate permission tables: %v", err)
+ }
+
+ valid := string(entity.StatusValid)
+ if err := db.Create(&entity.UserTenant{
+ ID: "tenant-owner-membership", UserID: "tenant-owner", TenantID: "tenant-1",
+ Role: string(RoleOwner), Status: &valid,
+ }).Error; err != nil {
+ t.Fatalf("create tenant owner membership: %v", err)
+ }
+ if err := db.Create(&entity.File{
+ ID: "legacy-file", TenantID: "tenant-1", CreatedBy: "", Name: "legacy.pdf", Type: "pdf",
+ }).Error; err != nil {
+ t.Fatalf("create legacy file: %v", err)
+ }
+
+ resources, err := (&databaseSource{db: db}).GetResources(context.Background(), []ResourceRef{{Kind: ResourceKindFile, ID: "legacy-file"}})
+ if err != nil {
+ t.Fatalf("load file authorization facts: %v", err)
+ }
+ if len(resources) != 1 || resources[0].TenantID != "tenant-1" || resources[0].OwnerUserID != "tenant-owner" {
+ t.Fatalf("file authorization facts = %+v, want tenant tenant-1 and owner tenant-owner", resources)
+ }
+}
+
func TestDatabaseCheckerScopesFilesAndFoldersToOwnedFolder(t *testing.T) {
db, err := gorm.Open(sqlite.Open("file:"+url.QueryEscape(t.Name())+"?mode=memory&cache=shared"), &gorm.Config{})
if err != nil {
@@ -752,37 +783,6 @@ func TestFileResourceFallsBackToTenantOwnerWhenCreatorIsMissing(t *testing.T) {
}
}
-func TestDatabaseSourceResolvesFileOwnerFromItsTenant(t *testing.T) {
- db, err := gorm.Open(sqlite.Open("file:"+url.QueryEscape(t.Name())+"?mode=memory&cache=shared"), &gorm.Config{})
- if err != nil {
- t.Fatalf("open sqlite: %v", err)
- }
- if err := db.AutoMigrate(&entity.File{}, &entity.File2Document{}, &entity.Document{}, &entity.Knowledgebase{}, &entity.UserTenant{}); err != nil {
- t.Fatalf("migrate permission tables: %v", err)
- }
-
- valid := string(entity.StatusValid)
- if err := db.Create(&entity.UserTenant{
- ID: "tenant-owner-membership", UserID: "tenant-owner", TenantID: "tenant-1",
- Role: string(RoleOwner), Status: &valid,
- }).Error; err != nil {
- t.Fatalf("create tenant owner membership: %v", err)
- }
- if err := db.Create(&entity.File{
- ID: "legacy-file", TenantID: "tenant-1", CreatedBy: "", Name: "legacy.pdf", Type: "pdf",
- }).Error; err != nil {
- t.Fatalf("create legacy file: %v", err)
- }
-
- resources, err := (&databaseSource{db: db}).GetResources(context.Background(), []ResourceRef{{Kind: ResourceKindFile, ID: "legacy-file"}})
- if err != nil {
- t.Fatalf("load file authorization facts: %v", err)
- }
- if len(resources) != 1 || resources[0].TenantID != "tenant-1" || resources[0].OwnerUserID != "tenant-owner" {
- t.Fatalf("file authorization facts = %+v, want tenant tenant-1 and owner tenant-owner", resources)
- }
-}
-
func TestDatabaseCheckerKeepsChatsPrivateToTheirOwner(t *testing.T) {
db, err := gorm.Open(sqlite.Open("file:"+url.QueryEscape(t.Name())+"?mode=memory&cache=shared"), &gorm.Config{})
if err != nil {
diff --git a/internal/permission/file_query_scope_test.go b/internal/permission/file_query_scope_test.go
new file mode 100644
index 0000000000..0eeeb76e21
--- /dev/null
+++ b/internal/permission/file_query_scope_test.go
@@ -0,0 +1,132 @@
+//go:build !enterprise
+
+package permission
+
+import (
+ "context"
+ "net/url"
+ "testing"
+
+ "ragflow/internal/entity"
+
+ "github.com/glebarez/sqlite"
+ "gorm.io/gorm"
+)
+
+func TestFileQueryScopeFiltersInSQLAndReturnsBatchAccessMasks(t *testing.T) {
+ db, err := gorm.Open(sqlite.Open("file:"+url.QueryEscape(t.Name())+"?mode=memory&cache=shared"), &gorm.Config{})
+ if err != nil {
+ t.Fatalf("open sqlite: %v", err)
+ }
+ if err := db.AutoMigrate(&entity.File{}, &entity.File2Document{}, &entity.Document{}, &entity.Knowledgebase{}, &entity.UserTenant{}); err != nil {
+ t.Fatalf("migrate permission tables: %v", err)
+ }
+
+ valid := string(entity.StatusValid)
+ for _, membership := range []entity.UserTenant{
+ {ID: "file-owner-membership", UserID: "file-owner", TenantID: "file-tenant", Role: string(RoleOwner), Status: &valid},
+ {ID: "file-reader-membership", UserID: "reader", TenantID: "file-tenant", Role: string(RoleNormal), Status: &valid},
+ {ID: "dataset-owner-membership", UserID: "dataset-owner", TenantID: "dataset-tenant", Role: string(RoleOwner), Status: &valid},
+ {ID: "dataset-reader-membership", UserID: "reader", TenantID: "dataset-tenant", Role: string(RoleNormal), Status: &valid},
+ } {
+ if err := db.Create(&membership).Error; err != nil {
+ t.Fatalf("create membership %q: %v", membership.ID, err)
+ }
+ }
+
+ for _, dataset := range []entity.Knowledgebase{
+ {ID: "team-dataset", TenantID: "dataset-tenant", Name: "Team", EmbdID: "embedding", Permission: string(entity.TenantPermissionTeam), CreatedBy: "dataset-owner", Status: &valid},
+ {ID: "private-dataset", TenantID: "dataset-tenant", Name: "Private", EmbdID: "embedding", Permission: string(entity.TenantPermissionMe), CreatedBy: "dataset-owner", Status: &valid},
+ } {
+ if err := db.Create(&dataset).Error; err != nil {
+ t.Fatalf("create dataset %q: %v", dataset.ID, err)
+ }
+ }
+
+ for _, file := range []entity.File{
+ {ID: "root", ParentID: "root", TenantID: "file-tenant", CreatedBy: "file-owner", Name: "/", Type: "folder"},
+ {ID: "reader-owned", ParentID: "root", TenantID: "file-tenant", CreatedBy: "reader", Name: "reader.pdf", Type: "pdf"},
+ {ID: "owner-private", ParentID: "root", TenantID: "file-tenant", CreatedBy: "file-owner", Name: "private.pdf", Type: "pdf"},
+ {ID: "empty-owner", ParentID: "root", TenantID: "file-tenant", CreatedBy: "", Name: "legacy.pdf", Type: "pdf"},
+ {ID: "team-linked", ParentID: "root", TenantID: "file-tenant", CreatedBy: "file-owner", Name: "team.pdf", Type: "pdf"},
+ {ID: "private-linked", ParentID: "root", TenantID: "file-tenant", CreatedBy: "file-owner", Name: "private-dataset.pdf", Type: "pdf"},
+ } {
+ if err := db.Create(&file).Error; err != nil {
+ t.Fatalf("create file %q: %v", file.ID, err)
+ }
+ }
+
+ for _, document := range []entity.Document{
+ {ID: "team-document", KbID: "team-dataset", ParserID: "general", ParserConfig: entity.JSONMap{}, SourceType: "local", Type: "pdf", CreatedBy: "dataset-owner", Suffix: "pdf", Status: &valid},
+ {ID: "private-document", KbID: "private-dataset", ParserID: "general", ParserConfig: entity.JSONMap{}, SourceType: "local", Type: "pdf", CreatedBy: "dataset-owner", Suffix: "pdf", Status: &valid},
+ } {
+ if err := db.Create(&document).Error; err != nil {
+ t.Fatalf("create document %q: %v", document.ID, err)
+ }
+ }
+ for _, link := range []entity.File2Document{
+ {ID: "team-link", FileID: stringPointer("team-linked"), DocumentID: stringPointer("team-document")},
+ {ID: "private-link", FileID: stringPointer("private-linked"), DocumentID: stringPointer("private-document")},
+ } {
+ if err := db.Create(&link).Error; err != nil {
+ t.Fatalf("create file-dataset link %q: %v", link.ID, err)
+ }
+ }
+
+ checker := newCommunityDatabaseChecker(db)
+ ctx := context.Background()
+ scope, err := checker.QueryScope(ctx, Subject{UserID: "reader", TenantID: "file-tenant"}, ScopeQuery{
+ Kind: ResourceKindFile,
+ Parent: ResourceRef{Kind: ResourceKindFolder, ID: "root"},
+ Operation: OperationRead,
+ })
+ if err != nil {
+ t.Fatalf("build file query scope: %v", err)
+ }
+ var visible []entity.File
+ query := scope.Apply(db.Model(&entity.File{})).
+ Where("file.tenant_id = ? AND file.parent_id = ? AND file.id <> ?", "file-tenant", "root", "root").
+ Order("file.id")
+ if err := query.Find(&visible).Error; err != nil {
+ t.Fatalf("query visible files: %v", err)
+ }
+ if len(visible) != 2 || visible[0].ID != "reader-owned" || visible[1].ID != "team-linked" {
+ t.Fatalf("visible file IDs = %v, want [reader-owned team-linked]", fileIDs(visible))
+ }
+
+ refs := []ResourceRef{
+ {Kind: ResourceKindFile, ID: "reader-owned"},
+ {Kind: ResourceKindFile, ID: "team-linked"},
+ }
+ accesses, err := checker.FilterAccesses(ctx, Subject{UserID: "reader", TenantID: "file-tenant"}, refs, OperationRead)
+ if err != nil {
+ t.Fatalf("resolve page access masks: %v", err)
+ }
+ if accesses[refs[0]].PermissionMask != ResourcePermissionOwner {
+ t.Errorf("owner access mask = %d, want %d", accesses[refs[0]].PermissionMask, ResourcePermissionOwner)
+ }
+ sharedMask := ResourcePermissionRead | ResourcePermissionWrite | ResourcePermissionManage
+ if accesses[refs[1]].PermissionMask != sharedMask {
+ t.Errorf("shared access mask = %d, want %d", accesses[refs[1]].PermissionMask, sharedMask)
+ }
+
+ statement := scope.Apply(db.Session(&gorm.Session{DryRun: true}).Model(&entity.File{})).
+ Where("file.tenant_id = ? AND file.parent_id = ? AND file.id <> ?", "file-tenant", "root", "root").
+ Find(&[]entity.File{}).Statement
+ if statement.SQL.String() == "" {
+ t.Fatal("file query scope produced no SQL")
+ }
+ if len(statement.Vars) > 40 {
+ t.Fatalf("file query scope used %d bind variables, expected a fixed-size predicate", len(statement.Vars))
+ }
+}
+
+func stringPointer(value string) *string { return &value }
+
+func fileIDs(files []entity.File) []string {
+ ids := make([]string, 0, len(files))
+ for _, file := range files {
+ ids = append(ids, file.ID)
+ }
+ return ids
+}
diff --git a/internal/permission/policy_ce.go b/internal/permission/policy_ce.go
index bb27074b9c..90da98504c 100644
--- a/internal/permission/policy_ce.go
+++ b/internal/permission/policy_ce.go
@@ -172,6 +172,9 @@ func (p *communityPolicy) Scope(ctx context.Context, subject Subject, query Scop
}
func (p *communityPolicy) QueryScope(ctx context.Context, subject Subject, query ScopeQuery) (QueryScope, bool, error) {
+ if query.Kind == ResourceKindFile || query.Kind == ResourceKindFolder {
+ return p.fileReadQueryScope(ctx, subject, query)
+ }
if query.Kind != ResourceKindDataset || query.Operation != OperationRead || query.Parent.ID != "" || query.Parent.Kind != "" || query.Entry != nil {
return QueryScope{}, false, nil
}
@@ -212,6 +215,61 @@ func (p *communityPolicy) QueryScope(ctx context.Context, subject Subject, query
}}, true, nil
}
+func (p *communityPolicy) fileReadQueryScope(ctx context.Context, subject Subject, query ScopeQuery) (QueryScope, bool, error) {
+ if query.Operation != OperationRead || query.Parent.Kind != ResourceKindFolder || strings.TrimSpace(query.Parent.ID) == "" || query.Entry != nil {
+ return QueryScope{}, false, nil
+ }
+ if err := validateSubject(subject); err != nil {
+ return QueryScope{}, true, err
+ }
+ source, ok := p.source.(*databaseSource)
+ if !ok || source.db == nil {
+ return QueryScope{}, false, nil
+ }
+ // Tenant role IDs are resolved by the enterprise policy. Keep its existing
+ // policy-driven scope until that policy supplies its own SQL predicate.
+ if tenantRoleMembershipEnabled(source.db) {
+ return QueryScope{}, false, nil
+ }
+
+ parentID := query.Parent.ID
+ return QueryScope{apply: func(query *gorm.DB) *gorm.DB {
+ db := source.db.WithContext(ctx)
+ parent := db.Model(&entity.File{}).
+ Select("tenant_id").
+ Where("id = ? AND type = ?", parentID, "folder")
+
+ fileOwner := db.Model(&entity.UserTenant{}).
+ Select("1").
+ Where("user_tenant.tenant_id = file.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?", subject.UserID, string(RoleOwner), string(entity.StatusValid))
+ anyFileOwner := db.Model(&entity.UserTenant{}).
+ Select("1").
+ Where("user_tenant.tenant_id = file.tenant_id AND user_tenant.role = ? AND user_tenant.status = ?", string(RoleOwner), string(entity.StatusValid))
+
+ rootMember := db.Model(&entity.UserTenant{}).
+ Select("1").
+ Where("user_tenant.tenant_id = file.tenant_id AND user_tenant.user_id = ? AND user_tenant.role IN ? AND user_tenant.status = ?", subject.UserID, []string{string(RoleOwner), string(RoleAdmin), string(RoleNormal)}, string(entity.StatusValid))
+ datasetOwner := db.Model(&entity.UserTenant{}).
+ Select("1").
+ Where("user_tenant.tenant_id = knowledgebase.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?", subject.UserID, string(RoleOwner), string(entity.StatusValid))
+ datasetMember := db.Model(&entity.UserTenant{}).
+ Select("1").
+ Where("user_tenant.tenant_id = knowledgebase.tenant_id AND user_tenant.user_id = ? AND user_tenant.role = ? AND user_tenant.status = ?", subject.UserID, string(RoleNormal), string(entity.StatusValid))
+ sharedDataset := db.Table("file2document AS f2d").
+ Select("1").
+ Joins("JOIN document ON document.id = f2d.document_id").
+ Joins("JOIN knowledgebase ON knowledgebase.id = document.kb_id").
+ Where("f2d.file_id = file.id AND knowledgebase.status = ?", string(entity.StatusValid)).
+ Where("(EXISTS (?) OR (knowledgebase.permission = ? AND EXISTS (?)))", datasetOwner, string(entity.TenantPermissionTeam), datasetMember)
+
+ return query.
+ Where("file.tenant_id = (?)", parent).
+ Where("(file.parent_id = file.id AND ((TRIM(file.created_by) = ?) OR (NULLIF(TRIM(file.created_by), '') IS NULL AND (EXISTS (?) OR (file.tenant_id = ? AND NOT EXISTS (?)))) OR EXISTS (?))) OR (file.parent_id <> file.id AND ((TRIM(file.created_by) = ?) OR (NULLIF(TRIM(file.created_by), '') IS NULL AND (EXISTS (?) OR (file.tenant_id = ? AND NOT EXISTS (?)))) OR EXISTS (?)))",
+ subject.UserID, fileOwner, subject.UserID, anyFileOwner, rootMember,
+ subject.UserID, fileOwner, subject.UserID, anyFileOwner, sharedDataset)
+ }}, true, nil
+}
+
func (s *databaseSource) validateDatasetTenants(ctx context.Context, userID string) error {
var tenantIDs []string
err := s.db.WithContext(ctx).Model(&entity.Knowledgebase{}).
@@ -227,6 +285,20 @@ func (s *databaseSource) validateDatasetTenants(ctx context.Context, userID stri
}
func (p *communityPolicy) FilterResources(ctx context.Context, subject Subject, refs []ResourceRef, operation Operation) ([]ResourceRef, error) {
+ accesses, err := p.FilterAccesses(ctx, subject, refs, operation)
+ if err != nil {
+ return nil, err
+ }
+ accessible := make([]ResourceRef, 0, len(accesses))
+ for _, ref := range uniqueRefs(refs) {
+ if _, ok := accesses[ref]; ok {
+ accessible = append(accessible, ref)
+ }
+ }
+ return accessible, nil
+}
+
+func (p *communityPolicy) FilterAccesses(ctx context.Context, subject Subject, refs []ResourceRef, operation Operation) (map[ResourceRef]Access, error) {
if err := validateSubject(subject); err != nil {
return nil, err
}
@@ -238,11 +310,14 @@ func (p *communityPolicy) FilterResources(ctx context.Context, subject Subject,
if err := evaluation.loadResources(ctx, refs); err != nil {
return nil, err
}
- accessible := make([]ResourceRef, 0, len(refs))
+ accesses := make(map[ResourceRef]Access, len(refs))
for _, ref := range refs {
- err := evaluation.checkResource(ctx, subject, ref, operation)
+ access, err := evaluation.resolveAccess(ctx, subject, ref)
+ if err == nil && access.Allows(operation) {
+ accesses[ref] = access
+ continue
+ }
if err == nil {
- accessible = append(accessible, ref)
continue
}
if errorsIsPermissionDenial(err) || errors.Is(err, ErrResourceNotFound) {
@@ -250,7 +325,7 @@ func (p *communityPolicy) FilterResources(ctx context.Context, subject Subject,
}
return nil, err
}
- return accessible, nil
+ return accesses, nil
}
func newEvaluation(source Source) *evaluation {
diff --git a/internal/permission/types.go b/internal/permission/types.go
index 7bd09fa424..aaddbef476 100644
--- a/internal/permission/types.go
+++ b/internal/permission/types.go
@@ -280,6 +280,10 @@ type queryScopePolicy interface {
QueryScope(context.Context, Subject, ScopeQuery) (QueryScope, bool, error)
}
+type accessFilterPolicy interface {
+ FilterAccesses(context.Context, Subject, []ResourceRef, Operation) (map[ResourceRef]Access, error)
+}
+
type resourceOwnerGranter interface {
GrantResourceOwner(context.Context, Subject, ResourceRef) error
}
@@ -427,3 +431,37 @@ func (c *Checker) FilterResources(ctx context.Context, subject Subject, resource
}
return c.policy.FilterResources(ctx, subject, resources, operation)
}
+
+// FilterAccesses resolves permissions for a batch of resources and returns the
+// effective access for each resource that allows operation. Database-backed
+// policies can load resource facts once for the whole batch.
+func (c *Checker) FilterAccesses(ctx context.Context, subject Subject, resources []ResourceRef, operation Operation) (map[ResourceRef]Access, error) {
+ if c == nil || c.policy == nil {
+ return nil, ErrSourceUnavailable
+ }
+ if !validOperation(operation) {
+ return nil, ErrInvalidPermission
+ }
+ var err error
+ if subject, err = resolveSubject(ctx, subject); err != nil {
+ return nil, err
+ }
+ if batchPolicy, ok := c.policy.(accessFilterPolicy); ok {
+ return batchPolicy.FilterAccesses(ctx, subject, resources, operation)
+ }
+
+ accesses := make(map[ResourceRef]Access, len(resources))
+ for _, resource := range uniqueRefs(resources) {
+ access, err := c.policy.ResolveAccess(ctx, subject, resource)
+ if err != nil {
+ if errorsIsPermissionDenial(err) || errors.Is(err, ErrResourceNotFound) {
+ continue
+ }
+ return nil, err
+ }
+ if access.Allows(operation) {
+ accesses[resource] = access
+ }
+ }
+ return accesses, nil
+}
diff --git a/internal/service/chat.go b/internal/service/chat.go
index 3c2fc428bf..7d25cd538c 100644
--- a/internal/service/chat.go
+++ b/internal/service/chat.go
@@ -29,6 +29,7 @@ import (
"strings"
"unicode/utf8"
+ "gorm.io/gorm"
"ragflow/internal/dao"
"ragflow/internal/dao/transaction"
)
@@ -130,7 +131,16 @@ func (s *ChatService) ListChats(ctx context.Context, userID, status, keywords, i
// Enrich with knowledge base names
chatsWithKBNames := make([]*ChatWithKBNames, 0, len(chats))
+ checker := permission.NewDatabaseChecker(dao.DB)
for _, chat := range chats {
+ access, err := checker.ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
+ Kind: permission.ResourceKindChat,
+ ID: chat.ID,
+ })
+ if err != nil {
+ return nil, err
+ }
+ chat.Chat.OperatorPermission = access.PermissionMask
kbNames, datasetIDs := s.getDatasetNamesAndIDs(ctx, chat.KBIDs)
chatsWithKBNames = append(chatsWithKBNames, &ChatWithKBNames{
Chat: &chat.Chat,
@@ -173,8 +183,16 @@ type CreateChatRequest struct {
}
func (s *ChatService) Create(ctx context.Context, userID string, req map[string]interface{}) (map[string]interface{}, common.ErrorCode, error) {
- tenant, err := s.tenantDAO.GetByID(ctx, dao.DB, userID)
+ tenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
+ code, normalized := permissionresponse.Normalize(err)
+ return nil, code, normalized
+ }
+ if err := checkFeatureAction(ctx, userID, "chat", permission.ActionWrite); err != nil {
+ code, normalized := permissionresponse.Normalize(err)
+ return nil, code, normalized
+ }
+ if _, err := s.tenantDAO.GetByID(ctx, dao.DB, tenantID); err != nil {
return nil, common.CodeDataError, errors.New("tenant not found")
}
@@ -203,7 +221,7 @@ func (s *ChatService) Create(ctx context.Context, userID string, req map[string]
if llmIDValue, ok := req["llm_id"]; ok {
llmID := stringFromValue(llmIDValue)
llmSetting, _ := mapFromValue(req["llm_setting"])
- tenantLLMID, err := resolveCreateLLMID(ctx, llmID, userID, llmSetting)
+ tenantLLMID, err := resolveCreateLLMID(ctx, llmID, tenantID, llmSetting)
if err != nil {
return nil, common.CodeDataError, err
}
@@ -214,7 +232,7 @@ func (s *ChatService) Create(ctx context.Context, userID string, req map[string]
if rerankIDValue, ok := req["rerank_id"]; ok {
rerankID := stringFromValue(rerankIDValue)
- tenantRerankID, err := resolveCreateRerankID(ctx, rerankID, userID)
+ tenantRerankID, err := resolveCreateRerankID(ctx, rerankID, tenantID)
if err != nil {
return nil, common.CodeDataError, err
}
@@ -243,14 +261,19 @@ func (s *ChatService) Create(ctx context.Context, userID string, req map[string]
req["kb_ids"] = []string{}
}
if _, ok := req["llm_id"]; !ok || req["llm_id"] == nil {
- req["llm_id"] = tenant.LLMID
- if tenant.TenantLLMID != nil {
- req["tenant_llm_id"] = *tenant.TenantLLMID
+ membership, membershipErr := dao.NewUserTenantDAO().FilterByUserIDAndTenantID(ctx, dao.DB, userID, tenantID)
+ if membershipErr != nil {
+ return nil, common.CodeForbidden, membershipErr
+ }
+ modelName, modelID := defaultModelRefs(membership, entity.ModelTypeChat)
+ req["llm_id"] = modelName
+ if modelID != "" {
+ req["tenant_llm_id"] = modelID
}
}
if stringFromValue(req["llm_id"]) != "" && !isTruthy(req["tenant_llm_id"]) {
llmSetting, _ := mapFromValue(req["llm_setting"])
- tenantLLMID, err := resolveCreateLLMID(ctx, stringFromValue(req["llm_id"]), userID, llmSetting)
+ tenantLLMID, err := resolveCreateLLMID(ctx, stringFromValue(req["llm_id"]), tenantID, llmSetting)
if err != nil {
return nil, common.CodeDataError, err
}
@@ -297,15 +320,20 @@ func (s *ChatService) Create(ctx context.Context, userID string, req map[string]
filterCreateChatPersistedFields(req)
name, err = common.UniqueName(name, 255, func(candidate string) (bool, error) {
- return s.chatDAO.ExistsByNameTenantStatus(ctx, dao.DB, candidate, userID, string(entity.StatusValid))
+ return s.chatDAO.ExistsByNameTenantStatus(ctx, dao.DB, candidate, tenantID, string(entity.StatusValid))
})
if err != nil {
return nil, common.CodeServerError, err
}
req["name"] = name
- chat := buildCreateChatEntity(req, userID)
- if err = s.chatDAO.Create(ctx, dao.DB, chat); err != nil {
+ chat := buildCreateChatEntity(req, tenantID)
+ if err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.chatDAO.Create(ctx, tx, chat); err != nil {
+ return err
+ }
+ return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindChat, chat.ID)
+ }); err != nil {
return nil, common.CodeDataError, fmt.Errorf("failed to create chat: %w", err)
}
@@ -1281,6 +1309,14 @@ func (s *ChatService) GetChat(ctx context.Context, userID string, chatID string)
if err != nil {
return nil, err
}
+ access, err := permission.NewDatabaseChecker(dao.DB).ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
+ Kind: permission.ResourceKindChat,
+ ID: chat.ID,
+ })
+ if err != nil {
+ return nil, err
+ }
+ chat.OperatorPermission = access.PermissionMask
// Step 4: Build response with kb_names (same as Python _build_chat_response)
// Resolve kb_ids to kb_names
diff --git a/internal/service/chat_channel.go b/internal/service/chat_channel.go
index 50ae66d64b..74e956943a 100644
--- a/internal/service/chat_channel.go
+++ b/internal/service/chat_channel.go
@@ -23,6 +23,7 @@ import (
"go.uber.org/zap"
+ "gorm.io/gorm"
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
@@ -87,6 +88,13 @@ func (s *ChatChannelService) CreateChatChannel(ctx context.Context, userID, name
if strings.TrimSpace(userID) == "" {
return nil, permission.ErrUnauthenticated
}
+ tenantID, err := requireCurrentTenantID(ctx, userID)
+ if err != nil {
+ return nil, err
+ }
+ if err := checkFeatureAction(ctx, userID, "chat", permission.ActionWrite); err != nil {
+ return nil, err
+ }
if chatID != nil && *chatID != "" {
if err := checkChatPermission(ctx, nil, userID, *chatID, permission.OperationUse); err != nil {
return nil, err
@@ -94,7 +102,7 @@ func (s *ChatChannelService) CreateChatChannel(ctx context.Context, userID, name
}
row := &entity.ChatChannel{
ID: common.GenerateUUID(),
- TenantID: userID,
+ TenantID: tenantID,
Name: name,
Channel: channelType,
Config: config,
@@ -102,7 +110,12 @@ func (s *ChatChannelService) CreateChatChannel(ctx context.Context, userID, name
Status: 1,
}
- if err := s.chatChannelDAO.Create(ctx, dao.DB, row); err != nil {
+ if err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.chatChannelDAO.Create(ctx, tx, row); err != nil {
+ return err
+ }
+ return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindChatChannel, row.ID)
+ }); err != nil {
return nil, err
}
diff --git a/internal/service/chat_list_test.go b/internal/service/chat_list_test.go
index ae973b78d1..bcc94d9f39 100644
--- a/internal/service/chat_list_test.go
+++ b/internal/service/chat_list_test.go
@@ -37,14 +37,19 @@ func setupChatListTestDB(t *testing.T) *gorm.DB {
status := string(entity.StatusValid)
if err = db.Create(&entity.Tenant{
ID: "user-1",
- LLMID: "model-a",
- EmbdID: "embd-a",
ParserIDs: "naive",
Status: &status,
}).Error; err != nil {
t.Fatalf("failed to create tenant: %v", err)
}
+ if err = db.Create(&entity.UserTenant{
+ ID: "user-tenant-1", UserID: "user-1", TenantID: "user-1", Role: "owner",
+ LLMID: "model-a", EmbdID: "embd-a", Status: &status,
+ }).Error; err != nil {
+ t.Fatalf("failed to create owner membership: %v", err)
+ }
+
if err = db.Create(&entity.User{
ID: "user-1",
Nickname: "tester",
diff --git a/internal/service/chat_pipeline_test.go b/internal/service/chat_pipeline_test.go
index 74fad9c6b0..afb5150555 100644
--- a/internal/service/chat_pipeline_test.go
+++ b/internal/service/chat_pipeline_test.go
@@ -1833,11 +1833,13 @@ func seedChatPipelineToolSupportTenant(t *testing.T, db *gorm.DB, defaultLLMID s
status := string(entity.StatusValid)
if err := db.Create(&entity.Tenant{
ID: "tenant-1",
- LLMID: defaultLLMID,
Status: &status,
}).Error; err != nil {
t.Fatalf("failed to create tenant: %v", err)
}
+ if err := db.Model(&entity.UserTenant{}).Where("id = ?", "user-tenant-1").Update("llm_id", defaultLLMID).Error; err != nil {
+ t.Fatalf("failed to configure owner default model: %v", err)
+ }
}
// configTools reports the is_tools flag getLLMModelConfig carries, read the way
diff --git a/internal/service/chat_pipeline_vision_test.go b/internal/service/chat_pipeline_vision_test.go
index 5064b86580..7afeefdb4e 100644
--- a/internal/service/chat_pipeline_vision_test.go
+++ b/internal/service/chat_pipeline_vision_test.go
@@ -64,11 +64,13 @@ func seedChatPipelineVisionTenant(t *testing.T, db *gorm.DB, defaultLLMID string
status := string(entity.StatusValid)
if err := db.Create(&entity.Tenant{
ID: "tenant-1",
- LLMID: defaultLLMID,
Status: &status,
}).Error; err != nil {
t.Fatalf("failed to create tenant: %v", err)
}
+ if err := db.Model(&entity.UserTenant{}).Where("id = ?", "user-tenant-1").Update("llm_id", defaultLLMID).Error; err != nil {
+ t.Fatalf("failed to configure owner default model: %v", err)
+ }
}
// A text-only chat model (glm-4-flash, enrolled as chat only) must resolve
diff --git a/internal/service/chat_rest_update_test.go b/internal/service/chat_rest_update_test.go
index 2e66c8390b..1b32c0675b 100644
--- a/internal/service/chat_rest_update_test.go
+++ b/internal/service/chat_rest_update_test.go
@@ -43,16 +43,17 @@ func setupChatRESTUpdateServiceTestDB(t *testing.T) *gorm.DB {
status := string(entity.StatusValid)
if err := db.Create(&entity.Tenant{
ID: "user-1",
- LLMID: "model-a",
- EmbdID: "embd-a",
- ASRID: "asr-a",
- Img2TxtID: "img2txt-a",
- RerankID: "rerank-a",
ParserIDs: "naive",
Status: &status,
}).Error; err != nil {
t.Fatalf("failed to create tenant: %v", err)
}
+ if err := db.Create(&entity.UserTenant{
+ ID: "owner-user-1", UserID: "user-1", TenantID: "user-1", Role: "owner", Status: &status,
+ LLMID: "model-a", EmbdID: "embd-a", ASRID: "asr-a", Img2TxtID: "img2txt-a", RerankID: "rerank-a",
+ }).Error; err != nil {
+ t.Fatalf("failed to create owner membership: %v", err)
+ }
if err := db.Create(&entity.TenantModelProvider{
ID: "provider-a",
TenantID: "user-1",
diff --git a/internal/service/chat_session.go b/internal/service/chat_session.go
index 4a4077a0ee..1a8c70b744 100644
--- a/internal/service/chat_session.go
+++ b/internal/service/chat_session.go
@@ -1252,11 +1252,14 @@ func (s *ChatSessionService) ChatCompletions(
dialog.LLMID = llmID
dialog.LLMSetting = genConfig
} else if dialog.LLMID == "" {
- tenant, err := dao.NewTenantDAO().GetByID(ctx, dao.DB, dialog.TenantID)
- if err != nil || tenant.LLMID == "" {
+ membership, err := NewTenantService().defaultModelMembership(ctx, userID, dialog.TenantID)
+ if err != nil || membership.LLMID == "" {
return fail(errors.New("no default chat model for tenant"))
}
- dialog.LLMID = tenant.LLMID
+ dialog.LLMID = membership.LLMID
+ if membership.TenantLLMID != nil && *membership.TenantLLMID != "" {
+ dialog.TenantLLMID = membership.TenantLLMID
+ }
if dialog.LLMSetting == nil {
dialog.LLMSetting = entity.JSONMap{}
}
diff --git a/internal/service/chunk/chunk.go b/internal/service/chunk/chunk.go
index a5d8039826..3ee6d51d8a 100644
--- a/internal/service/chunk/chunk.go
+++ b/internal/service/chunk/chunk.go
@@ -306,7 +306,7 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
if len(req.CrossLanguages) > 0 || (req.Keyword != nil && *req.Keyword) {
tenantSvc := service.NewTenantService()
var err error
- llmModelName, err = tenantSvc.GetDefaultModelName(ctx, tenantIDs[0], entity.ModelTypeChat)
+ llmModelName, err = tenantSvc.GetDefaultModelNameForTenant(ctx, tenantIDs[0], entity.ModelTypeChat)
if err != nil || llmModelName == "" {
common.Warn("Failed to get default chat model name for LLM transformations", zap.Error(err))
} else {
diff --git a/internal/service/compilation_template_group_service.go b/internal/service/compilation_template_group_service.go
index 4bc4f28583..be034b9d52 100644
--- a/internal/service/compilation_template_group_service.go
+++ b/internal/service/compilation_template_group_service.go
@@ -269,7 +269,7 @@ func (s *CompilationTemplateGroupService) buildGroupItem(ctx context.Context, te
Name: c.Name,
Description: derefString(c.Description),
Kind: c.Kind,
- Config: fillConfigDefaultLLM(ctx, s.tenantDAO, c.Config, c.TenantID),
+ Config: fillConfigDefaultLLM(ctx, c.Config, c.TenantID),
CreateTime: timeStr(c.CreateTime),
UpdateTime: timeStr(c.UpdateTime),
})
@@ -392,7 +392,7 @@ func (s *CompilationTemplateGroupService) insertChildren(ctx context.Context, db
}
}
desc := child.Description
- config := fillConfigDefaultLLM(ctx, s.tenantDAO, child.Config, &tenantID)
+ config := fillConfigDefaultLLM(ctx, child.Config, &tenantID)
if config == nil {
config = entity.JSONMap{}
}
@@ -496,7 +496,7 @@ func (s *CompilationTemplateGroupService) reconcileChildren(ctx context.Context,
// Pass 3: apply updates and inserts.
for _, item := range resolved {
- config := fillConfigDefaultLLM(ctx, s.tenantDAO, item.child.Config, &tenantID)
+ config := fillConfigDefaultLLM(ctx, item.child.Config, &tenantID)
if config == nil {
config = entity.JSONMap{}
}
diff --git a/internal/service/compilation_template_service.go b/internal/service/compilation_template_service.go
index a65c842e86..553a38e53b 100644
--- a/internal/service/compilation_template_service.go
+++ b/internal/service/compilation_template_service.go
@@ -38,22 +38,22 @@ import (
// fill_config_default_llm: when the config has no explicit llm_id it lazily
// fills the tenant's default chat model id (read-side only; the DB row is left
// untouched).
-func fillConfigDefaultLLM(ctx context.Context, tenantDAO *dao.TenantDAO, config entity.JSONMap, tenantID *string) entity.JSONMap {
+func fillConfigDefaultLLM(ctx context.Context, config entity.JSONMap, tenantID *string) entity.JSONMap {
if len(config) == 0 || tenantID == nil || *tenantID == "" {
return config
}
if _, ok := config["llm_id"]; ok {
return config
}
- tenant, err := tenantDAO.GetByID(ctx, dao.DB, *tenantID)
- if err != nil || tenant == nil || tenant.TenantLLMID == nil {
+ _, modelID, err := NewTenantService().GetDefaultModelRefsForTenant(ctx, *tenantID, entity.ModelTypeChat)
+ if err != nil || modelID == "" {
return config
}
out := make(entity.JSONMap, len(config)+1)
for k, v := range config {
out[k] = v
}
- out["llm_id"] = *tenant.TenantLLMID
+ out["llm_id"] = modelID
return out
}
@@ -121,7 +121,7 @@ func (s *CompilationTemplateService) ListBuiltins(ctx context.Context, tenantID
}
tenantPtr := &tenantID
for _, template := range templates {
- template.Config = fillConfigDefaultLLM(ctx, s.tenantDAO, template.Config, tenantPtr)
+ template.Config = fillConfigDefaultLLM(ctx, template.Config, tenantPtr)
}
return s.sortBuiltins(templates), nil
}
diff --git a/internal/service/connector.go b/internal/service/connector.go
index 167f5764cd..d81bdc09fd 100644
--- a/internal/service/connector.go
+++ b/internal/service/connector.go
@@ -278,6 +278,13 @@ func (s *ConnectorService) cancelConnectorTasks(ctx context.Context, connectorID
// CreateConnector creates a connector owned by the current user.
func (s *ConnectorService) CreateConnector(ctx context.Context, userID string, req *CreateConnectorRequest) (*entity.Connector, error) {
+ tenantID, err := requireCurrentTenantID(ctx, userID)
+ if err != nil {
+ return nil, err
+ }
+ if err := checkFeatureAction(ctx, userID, "file", permission.ActionWrite); err != nil {
+ return nil, err
+ }
if req.RefreshFreq != nil && *req.RefreshFreq <= 0 {
return nil, fmt.Errorf("%w: refresh_freq got %d", ErrConnectorInvalidFreq, *req.RefreshFreq)
}
@@ -301,7 +308,7 @@ func (s *ConnectorService) CreateConnector(ctx context.Context, userID string, r
connector := &entity.Connector{
ID: common.GenerateUUID(),
- TenantID: userID,
+ TenantID: tenantID,
Name: req.Name,
Source: req.Source,
InputType: connectorInputTypePoll,
@@ -312,7 +319,12 @@ func (s *ConnectorService) CreateConnector(ctx context.Context, userID string, r
Status: connectorStatusUnstarted,
}
- if err := s.connectorDAO.Create(ctx, dao.DB, connector); err != nil {
+ if err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.connectorDAO.Create(ctx, tx, connector); err != nil {
+ return err
+ }
+ return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindConnector, connector.ID)
+ }); err != nil {
return nil, err
}
@@ -350,7 +362,7 @@ func (s *ConnectorService) ListConnectors(ctx context.Context, userID, requested
tenantID := strings.TrimSpace(requestedTenantID)
if tenantID == "" {
var err error
- tenantID, err = requireOwnedTenantID(ctx, userID)
+ tenantID, err = requireCurrentTenantID(ctx, userID)
if errors.Is(err, permission.ErrMembershipNotFound) {
return &ListConnectorsResponse{Connectors: []*dao.ConnectorListItem{}}, nil
}
diff --git a/internal/service/dataset/create_test.go b/internal/service/dataset/create_test.go
index f29b26c009..2a769316fc 100644
--- a/internal/service/dataset/create_test.go
+++ b/internal/service/dataset/create_test.go
@@ -22,18 +22,21 @@ func insertCreateDatasetTenant(t *testing.T, tenantID string) {
var existing entity.Tenant
if err := dao.DB.Where("id = ?", tenantID).First(&existing).Error; err != nil {
tn := &entity.Tenant{
- ID: tenantID,
- LLMID: "llm-default",
- EmbdID: "embd-default",
- TenantEmbdID: sptr("embd-1"),
- ASRID: "asr-default",
- Status: sptr("1"),
+ ID: tenantID,
+ Status: sptr("1"),
}
if err := dao.DB.Create(tn).Error; err != nil {
t.Fatalf("insert test tenant: %v", err)
}
}
ensureDatasetTestMembership(t, tenantID, tenantID, "owner")
+ if err := dao.DB.Model(&entity.UserTenant{}).
+ Where("user_id = ? AND tenant_id = ?", tenantID, tenantID).
+ Updates(map[string]interface{}{
+ "llm_id": "llm-default", "embd_id": "embd-default", "tenant_embd_id": "embd-1", "asr_id": "asr-default",
+ }).Error; err != nil {
+ t.Fatalf("configure owner model defaults: %v", err)
+ }
}
func testDatasetCreateService(t *testing.T) *DatasetService {
diff --git a/internal/service/dataset/crud.go b/internal/service/dataset/crud.go
index 8757b42cf7..77326334cf 100644
--- a/internal/service/dataset/crud.go
+++ b/internal/service/dataset/crud.go
@@ -46,6 +46,10 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, subject, "dataset", permission.ActionWrite); err != nil {
+ code, permissionErr := permissionresponse.Normalize(err)
+ return nil, code, permissionErr
+ }
// parse_type is required on dataset creation: it explicitly selects BuiltIn
// (1) or Pipeline (2) mode. This replaces the previous silent default to
@@ -67,14 +71,14 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
}
parserID := string(entity.ParserTypeGeneral)
- permission := "me"
+ visibility := "me"
embeddingModel := ""
var language *string
pipelineID := req.PipelineID
if req.Permission != nil {
- permission = strings.TrimSpace(*req.Permission)
- if permission != "me" && permission != "team" {
+ visibility = strings.TrimSpace(*req.Permission)
+ if visibility != "me" && visibility != "team" {
return nil, common.CodeDataError, errors.New("Input should be 'me' or 'team'")
}
}
@@ -180,8 +184,10 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
var parserConfigMap map[string]interface{} = parserConfig
- embdID := tenant.EmbdID
- tenantEmbdID := ptrStringValue(tenant.TenantEmbdID)
+ embdID, tenantEmbdID, err := service.NewTenantService().GetDefaultModelRefsForUser(ctx, userID, tenantID, entity.ModelTypeEmbedding)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
if embeddingModel != "" {
ok, message := d.verifyEmbeddingAvailability(ctx, embeddingModel, service.ModelAccess{UserID: userID, TenantID: tenantID})
if !ok {
@@ -208,10 +214,11 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
}
name = dedupedName
- parserConfig = service.ApplyComponentScopedParserConfig(
- parserConfig,
- tenant.LLMID,
- )
+ llmID, _, err := service.NewTenantService().GetDefaultModelRefsForUser(ctx, userID, tenantID, entity.ModelTypeChat)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ parserConfig = service.ApplyComponentScopedParserConfig(parserConfig, llmID)
kb := &entity.Knowledgebase{
ID: kbID,
@@ -221,14 +228,19 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
ParserID: parserID,
PipelineID: pipelineID,
ParserConfig: entity.JSONMap(parserConfigMap),
- Permission: permission,
+ Permission: visibility,
Language: language,
EmbdID: embdID,
TenantEmbdID: stringPtrIfNotEmpty(tenantEmbdID),
Status: &status,
}
- if err = d.kbDAO.Create(ctx, dao.DB, kb); err != nil {
+ if err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := d.kbDAO.Create(ctx, tx, kb); err != nil {
+ return err
+ }
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, subject, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: kb.ID})
+ }); err != nil {
if dao.IsDuplicateKeyErr(err) {
return nil, common.CodeDataError, fmt.Errorf("dataset name '%s' already exists", name)
}
@@ -282,6 +294,15 @@ func (d *DatasetService) GetDataset(ctx context.Context, datasetID, userID strin
}
data := datasetToMap(kb)
+ operatorPermission, err := service.ResolveOperatorPermission(ctx, userID, permission.ResourceRef{
+ Kind: permission.ResourceKindDataset,
+ ID: kb.ID,
+ })
+ if err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
+ return nil, code, permissionErr
+ }
+ data["operator_permission"] = operatorPermission
size, err := d.documentDAO.SumSizeByDatasetID(ctx, dao.DB, datasetID)
if err != nil {
@@ -548,6 +569,7 @@ func (d *DatasetService) ListDatasets(ctx context.Context, id, name string, page
var kbs []*entity.KnowledgebaseListItem
var total int64
var deniedIDs []string
+ operatorPermissions := make(map[string]int32)
err := dao.DB.Transaction(func(tx *gorm.DB) error {
checker := permission.NewDatabaseChecker(tx)
subject := permission.Subject{UserID: userID}
@@ -612,6 +634,19 @@ func (d *DatasetService) ListDatasets(ctx context.Context, id, name string, page
return err
}
kbs, total = listed, count
+ for _, kb := range kbs {
+ if kb == nil {
+ continue
+ }
+ access, accessErr := checker.ResolveAccess(ctx, subject, permission.ResourceRef{
+ Kind: permission.ResourceKindDataset,
+ ID: kb.ID,
+ })
+ if accessErr != nil {
+ return accessErr
+ }
+ operatorPermissions[kb.ID] = access.PermissionMask
+ }
return nil
})
if err != nil {
@@ -636,6 +671,7 @@ func (d *DatasetService) ListDatasets(ctx context.Context, id, name string, page
continue
}
item := datasetListItemToMap(kb)
+ item["operator_permission"] = operatorPermissions[kb.ID]
// Mirror the memory list: surface the concrete model display name
// (modelName@instance@provider) instead of a raw tenant_model ID.
tenantEmbdID := ptrStringValue(kb.TenantEmbdID)
diff --git a/internal/service/dataset/metadata.go b/internal/service/dataset/metadata.go
index e6d2e9bbf9..cdfd8bc9ea 100644
--- a/internal/service/dataset/metadata.go
+++ b/internal/service/dataset/metadata.go
@@ -48,14 +48,10 @@ func (d *DatasetService) UpdateDocumentMetadataConfig(ctx context.Context, userI
if kb == nil {
return nil, common.CodeServerError, errors.New("database operation failed")
}
- tenant, tenantErr := d.tenantDAO.GetByID(ctx, dao.DB, kb.TenantID)
- if tenantErr != nil {
+ if _, tenantErr := d.tenantDAO.GetByID(ctx, dao.DB, kb.TenantID); tenantErr != nil {
return nil, common.CodeServerError, errors.New("database operation failed")
}
- llmID := ""
- if tenant != nil {
- llmID = tenant.LLMID
- }
+ llmID, _, _ := service.NewTenantService().GetDefaultModelRefsForUser(ctx, userID, kb.TenantID, entity.ModelTypeChat)
parserConfig = service.ApplyComponentScopedParserConfig(parserConfig, llmID)
if err = d.documentDAO.UpdateByID(ctx, dao.DB, doc.ID, map[string]interface{}{"parser_config": parserConfig}); err != nil {
@@ -122,6 +118,9 @@ func (d *DatasetService) UpdateMetadataConfig(ctx context.Context, datasetID, us
code, permissionErr := permissionresponse.Normalize(permission.ErrResourceNotFound)
return nil, code, permissionErr
}
+ if _, tenantErr := d.tenantDAO.GetByID(ctx, dao.DB, kb.TenantID); tenantErr != nil {
+ return nil, common.CodeServerError, errors.New("database operation failed")
+ }
if req == nil {
req = &service.MetadataConfigRequest{}
@@ -160,14 +159,7 @@ func (d *DatasetService) UpdateMetadataConfig(ctx context.Context, datasetID, us
}
delete(parserConfig, "enable_metadata")
delete(parserConfig, "built_in_metadata")
- tenant, tenantErr := d.tenantDAO.GetByID(ctx, dao.DB, kb.TenantID)
- if tenantErr != nil {
- return nil, common.CodeServerError, errors.New("database operation failed")
- }
- llmID := ""
- if tenant != nil {
- llmID = tenant.LLMID
- }
+ llmID, _, _ := service.NewTenantService().GetDefaultModelRefsForUser(ctx, userID, kb.TenantID, entity.ModelTypeChat)
parserConfig = service.ApplyComponentScopedParserConfig(parserConfig, llmID)
if err = d.kbDAO.UpdateByID(ctx, dao.DB, kb.ID, map[string]interface{}{"parser_config": parserConfig}); err != nil {
diff --git a/internal/service/dataset/update.go b/internal/service/dataset/update.go
index a89ac98b2d..f1b9fb77fd 100644
--- a/internal/service/dataset/update.go
+++ b/internal/service/dataset/update.go
@@ -353,8 +353,9 @@ func (d *DatasetService) UpdateDataset(ctx context.Context, datasetID, userID st
}
if effectiveParserConfig != nil {
llmID := ""
- if ownerTenant, tenantErr := d.tenantDAO.GetByID(ctx, tx, lockedKB.TenantID); tenantErr == nil && ownerTenant != nil {
- llmID = ownerTenant.LLMID
+ var membership entity.UserTenant
+ if tenantErr := tx.Where("user_id = ? AND tenant_id = ? AND status = ?", userID, lockedKB.TenantID, entity.TenantMembershipStatusJoined).Take(&membership).Error; tenantErr == nil {
+ llmID = membership.LLMID
}
effectiveParserConfig = service.ApplyComponentScopedParserConfig(
effectiveParserConfig,
diff --git a/internal/service/document/document_artifact.go b/internal/service/document/document_artifact.go
index 5d64eec8c0..b7f339d05d 100644
--- a/internal/service/document/document_artifact.go
+++ b/internal/service/document/document_artifact.go
@@ -41,7 +41,7 @@ func (s *DocumentService) GetDocumentImage(ctx context.Context, userID, imageID
// composite image ID belongs to an indexed chunk of an accessible document.
func (s *DocumentService) GetDocumentImageForDocument(ctx context.Context, userID, docID, imageID string) ([]byte, error) {
doc, err := s.documentDAO.GetByID(ctx, dao.DB, docID)
- if err != nil || doc == nil || service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, doc.KbID, permission.OperationRead) != nil {
+ if err != nil || doc == nil || service.CheckDocumentAccess(ctx, permission.Subject{UserID: userID}, doc.ID, doc.KbID, permission.OperationRead) != nil {
return nil, ErrDocumentImageNotFound
}
bucket, objectKey, ok := strings.Cut(imageID, "-")
@@ -69,7 +69,7 @@ func (s *DocumentService) GetDocumentImageForDocument(ctx context.Context, userI
// document metadata.
func (s *DocumentService) GetDocumentThumbnail(ctx context.Context, userID, docID string) ([]byte, error) {
doc, err := s.documentDAO.GetByID(ctx, dao.DB, docID)
- if err != nil || doc == nil || service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, doc.KbID, permission.OperationRead) != nil || doc.Thumbnail == nil || *doc.Thumbnail == "" || strings.HasPrefix(*doc.Thumbnail, imgBase64Prefix) {
+ if err != nil || doc == nil || service.CheckDocumentAccess(ctx, permission.Subject{UserID: userID}, doc.ID, doc.KbID, permission.OperationRead) != nil || doc.Thumbnail == nil || *doc.Thumbnail == "" || strings.HasPrefix(*doc.Thumbnail, imgBase64Prefix) {
return nil, ErrDocumentImageNotFound
}
storageImpl := storage.GetStorageFactory().GetStorage()
@@ -267,7 +267,7 @@ func (s *DocumentService) GetDocumentPreview(ctx context.Context, userID, docID
// Keep access denial indistinguishable from a missing document so callers
// cannot probe document IDs.
- if service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, doc.KbID, permission.OperationRead) != nil {
+ if service.CheckDocumentAccess(ctx, permission.Subject{UserID: userID}, doc.ID, doc.KbID, permission.OperationRead) != nil {
return nil, ErrPreviewDocumentNotFound
}
diff --git a/internal/service/document/document_crud.go b/internal/service/document/document_crud.go
index 5cd86a8198..e06649055f 100644
--- a/internal/service/document/document_crud.go
+++ b/internal/service/document/document_crud.go
@@ -219,14 +219,13 @@ func (s *DocumentService) DeleteDocument(ctx context.Context, id string) error {
// ids: specific document IDs; deleteAll: delete all docs in the dataset.
// Returns the number of successfully deleted documents.
func (s *DocumentService) DeleteDocuments(ctx context.Context, ids []string, deleteAll bool, datasetID, userID string) (int, error) {
- // 1. Check dataset is accessible by the user
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationDeleteContent); err != nil {
- _, permissionErr := permissionresponse.Normalize(err)
- return 0, permissionErr
- }
-
- // 2. Resolve document IDs
+ // Deleting the entire dataset requires dataset-level access; deleting
+ // explicit documents also accepts direct document grants.
if deleteAll {
+ if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationDeleteContent); err != nil {
+ _, permissionErr := permissionresponse.Normalize(err)
+ return 0, permissionErr
+ }
if err := dao.DB.Model(&entity.Document{}).
Where("kb_id = ?", datasetID).
Pluck("id", &ids).Error; err != nil {
@@ -236,15 +235,27 @@ func (s *DocumentService) DeleteDocuments(ctx context.Context, ids []string, del
if len(ids) == 0 {
return 0, nil
}
+ if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationDeleteContent); err != nil &&
+ !errors.Is(err, permission.ErrPermissionDenied) && !errors.Is(err, permission.ErrMembershipNotFound) {
+ _, permissionErr := permissionresponse.Normalize(err)
+ return 0, permissionErr
+ }
// 3. Deduplicate (before validation so dup count doesn't matter)
ids = common.Deduplicate(ids)
- // 4. Validate IDs belong to this dataset (only for explicit ids; deleteAll is already scoped)
+ // Validate IDs and permissions before mutating any document.
if !deleteAll {
- if _, err := s.validateDocsInDataset(ctx, ids, datasetID); err != nil {
+ documents, err := s.validateDocsInDataset(ctx, ids, datasetID)
+ if err != nil {
return 0, err
}
+ for _, doc := range documents {
+ if err := service.CheckDocumentAccess(ctx, permission.Subject{UserID: userID}, doc.ID, datasetID, permission.OperationDeleteContent); err != nil {
+ _, permissionErr := permissionresponse.Normalize(err)
+ return 0, permissionErr
+ }
+ }
}
// 5. Delete each document (non-critical failures are tolerated per doc)
@@ -352,8 +363,8 @@ func (s *DocumentService) RemoveDocumentKeepFile(ctx context.Context, docID stri
// counter in a single transaction. Mirrors Python DocumentService.insert, which
// updates dataset/document counters on insert. The document's ID and timestamps
// are populated by the caller / model hooks before insertion.
-func (s *DocumentService) InsertDocument(doc *entity.Document) error {
- return dao.DB.Transaction(func(tx *gorm.DB) error {
+func (s *DocumentService) InsertDocument(ctx context.Context, doc *entity.Document) error {
+ return dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Create(doc).Error; err != nil {
return fmt.Errorf("failed to create document: %w", err)
}
@@ -371,6 +382,9 @@ func (s *DocumentService) InsertDocument(doc *entity.Document) error {
if result.RowsAffected == 0 {
return fmt.Errorf("knowledgebase %s not found", doc.KbID)
}
+ if err := grantDocumentOwnerEE(ctx, tx, doc); err != nil {
+ return fmt.Errorf("grant document owner: %w", err)
+ }
return nil
})
}
diff --git a/internal/service/document/document_dataset_update.go b/internal/service/document/document_dataset_update.go
index 013235e6aa..83e256c786 100644
--- a/internal/service/document/document_dataset_update.go
+++ b/internal/service/document/document_dataset_update.go
@@ -22,14 +22,6 @@ import (
)
func (s *DocumentService) BatchUpdateDocumentStatus(ctx context.Context, userID, datasetID, status string, documentIDs []string) (map[string]interface{}, common.ErrorCode, error) {
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUpdate); err != nil {
- code, permissionErr := permissionresponse.Normalize(err)
- return nil, code, permissionErr
- }
- kb, err := s.kbDAO.GetByID(ctx, dao.DB, datasetID)
- if err != nil {
- return nil, common.CodeDataError, fmt.Errorf("you don't own the dataset")
- }
statusInt, convErr := strconv.Atoi(status)
if convErr != nil {
return nil, common.CodeArgumentError, fmt.Errorf("invalid status: %s", status)
@@ -46,20 +38,49 @@ func (s *DocumentService) BatchUpdateDocumentStatus(ctx context.Context, userID,
for _, doc := range documents {
documentByID[doc.ID] = doc
}
-
+ accessibleDocuments := make(map[string]*entity.Document, len(documentIDs))
+ var permissionDenied error
+ otherFailures := 0
for _, docID := range documentIDs {
doc, ok := documentByID[docID]
- if !ok {
- result[docID] = map[string]string{"error": "Document not found"}
+ if !ok || doc.KbID != datasetID {
+ result[docID] = map[string]string{"error": "Document not found in this dataset."}
+ otherFailures++
hasError = true
continue
}
-
- if doc.KbID != datasetID {
- result[docID] = map[string]string{"error": "Document not found in this dataset."}
+ if err := service.CheckDocumentAccess(ctx, permission.Subject{UserID: userID}, doc.ID, datasetID, permission.OperationUpdate); err != nil {
+ result[docID] = map[string]string{"error": "Permission denied"}
+ if permissionresponse.IsPermissionError(err) {
+ permissionDenied = err
+ } else {
+ otherFailures++
+ }
hasError = true
continue
}
+ accessibleDocuments[docID] = doc
+ }
+ if len(accessibleDocuments) == 0 {
+ if hasError {
+ if permissionDenied != nil && otherFailures == 0 {
+ code, normalizedErr := permissionresponse.Normalize(permissionDenied)
+ return result, code, normalizedErr
+ }
+ return result, common.CodeServerError, fmt.Errorf("partial failure")
+ }
+ return result, common.CodeSuccess, nil
+ }
+ kb, err := s.kbDAO.GetByID(ctx, dao.DB, datasetID)
+ if err != nil {
+ return result, common.CodeDataError, fmt.Errorf("dataset not found")
+ }
+
+ for _, docID := range documentIDs {
+ doc, ok := accessibleDocuments[docID]
+ if !ok {
+ continue
+ }
currentStatus := ""
if doc.Status != nil {
@@ -114,10 +135,11 @@ func (s *DocumentService) BatchUpdateDocumentStatus(ctx context.Context, userID,
}
func (s *DocumentService) UpdateDatasetDocument(ctx context.Context, userID, datasetID, documentID string, req *UpdateDatasetDocumentRequest, present map[string]bool) (*UpdateDatasetDocumentResponse, common.ErrorCode, error) {
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUpdate); err != nil {
+ if err := service.CheckDocumentAccess(ctx, permission.Subject{UserID: userID}, documentID, datasetID, permission.OperationUpdate); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
+
kb, err := s.kbDAO.GetByID(ctx, dao.DB, datasetID)
if err != nil {
if dao.IsNotFoundErr(err) {
@@ -133,7 +155,6 @@ func (s *DocumentService) UpdateDatasetDocument(ctx context.Context, userID, dat
}
return nil, common.CodeServerError, err
}
-
if code, err := s.validateDatasetDocumentUpdate(ctx, datasetID, documentID, userID, doc, req, present); err != nil {
return nil, code, err
}
@@ -167,7 +188,7 @@ func (s *DocumentService) UpdateDatasetDocument(ctx context.Context, userID, dat
accessErr := permission.NewDatabaseChecker(dao.DB).CheckDependency(
ctx,
permission.Subject{UserID: userID, TenantID: kb.TenantID},
- permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: kb.ID},
+ permission.ResourceRef{Kind: permission.ResourceKindDocument, ID: doc.ID},
permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: strings.TrimSpace(*effPipelineID)},
permission.OperationUpdate,
permission.OperationUse,
@@ -190,13 +211,8 @@ func (s *DocumentService) UpdateDatasetDocument(ctx context.Context, userID, dat
} else {
cleaned := pipelinepkg.BuildParserConfig(dslJSON, req.ParserConfig)
pipelinepkg.ApplyParentChildChunkerConfig(cleaned, req.ParserConfig)
- tenant, tenantErr := dao.NewTenantDAO().GetByID(ctx, dao.DB, kb.TenantID)
- if tenantErr == nil && tenant != nil {
- cleaned = service.ApplyComponentScopedParserConfig(
- cleaned,
- tenant.LLMID,
- )
- }
+ llmID, _, _ := service.NewTenantService().GetDefaultModelRefsForUser(ctx, userID, kb.TenantID, entity.ModelTypeChat)
+ cleaned = service.ApplyComponentScopedParserConfig(cleaned, llmID)
if err = s.documentDAO.UpdateByID(ctx, dao.DB, doc.ID, map[string]interface{}{
"parser_config": cleaned,
}); err != nil {
diff --git a/internal/service/document/document_dataset_update_test.go b/internal/service/document/document_dataset_update_test.go
index 58aaeff25d..5cda45b506 100644
--- a/internal/service/document/document_dataset_update_test.go
+++ b/internal/service/document/document_dataset_update_test.go
@@ -1,6 +1,11 @@
package document
-import "testing"
+import (
+ "testing"
+
+ "ragflow/internal/common"
+ "ragflow/internal/entity"
+)
// TestIsPresentationFile pins the name-based presentation guard used by the
// parser_id / chunk_method switch in document_dataset_update.go. A WPS
@@ -34,3 +39,59 @@ func TestIsPresentationFile(t *testing.T) {
})
}
}
+
+func TestBatchUpdateDocumentStatusReturnsPermissionErrorWhenAllDenied(t *testing.T) {
+ db := setupServiceTestDB(t)
+ pushServiceDB(t, db)
+ insertTestKB(t, "kb-1", "tenant-1", 1, 0, 0)
+ if err := db.Model(&entity.Knowledgebase{}).Where("id = ?", "kb-1").Update("permission", string(entity.TenantPermissionMe)).Error; err != nil {
+ t.Fatalf("make dataset private: %v", err)
+ }
+ insertTestDoc(t, "doc-1", "kb-1", 0, 0)
+ valid := string(entity.StatusValid)
+ if err := db.Create(&entity.UserTenant{
+ ID: "member-tenant-1", UserID: "member", TenantID: "tenant-1", Role: "normal", Status: &valid,
+ }).Error; err != nil {
+ t.Fatalf("create tenant member: %v", err)
+ }
+
+ svc := testDocumentService(t)
+ ctx := documentTestActorContext(t.Context(), "member", "tenant-1")
+ _, code, err := svc.BatchUpdateDocumentStatus(ctx, "member", "kb-1", "0", []string{"doc-1"})
+ if err == nil {
+ t.Fatal("expected permission error for an inaccessible document")
+ }
+ if code != common.CodeForbidden {
+ t.Fatalf("code = %d, want %d; error: %v", code, common.CodeForbidden, err)
+ }
+}
+
+func TestBatchUpdateDocumentStatusRetainsPartialFailure(t *testing.T) {
+ db := setupServiceTestDB(t)
+ pushServiceDB(t, db)
+ insertTestKB(t, "kb-1", "tenant-1", 1, 0, 0)
+ if err := db.Model(&entity.Knowledgebase{}).Where("id = ?", "kb-1").Update("permission", string(entity.TenantPermissionMe)).Error; err != nil {
+ t.Fatalf("make dataset private: %v", err)
+ }
+ insertTestDoc(t, "owner-doc", "kb-1", 0, 0)
+ insertTestDoc(t, "member-doc", "kb-1", 0, 0)
+ if err := db.Model(&entity.Document{}).Where("id = ?", "member-doc").Update("created_by", "member").Error; err != nil {
+ t.Fatalf("make one document member-owned: %v", err)
+ }
+ valid := string(entity.StatusValid)
+ if err := db.Create(&entity.UserTenant{
+ ID: "member-tenant-1", UserID: "member", TenantID: "tenant-1", Role: "normal", Status: &valid,
+ }).Error; err != nil {
+ t.Fatalf("create tenant member: %v", err)
+ }
+
+ svc := testDocumentService(t)
+ ctx := documentTestActorContext(t.Context(), "member", "tenant-1")
+ _, code, err := svc.BatchUpdateDocumentStatus(ctx, "member", "kb-1", "1", []string{"member-doc", "owner-doc"})
+ if err == nil {
+ t.Fatal("expected a partial failure")
+ }
+ if code != common.CodeServerError || err.Error() != "partial failure" {
+ t.Fatalf("result code/error = %d/%v, want partial failure", code, err)
+ }
+}
diff --git a/internal/service/document/document_list.go b/internal/service/document/document_list.go
index 91af98504a..7f4b719bfd 100644
--- a/internal/service/document/document_list.go
+++ b/internal/service/document/document_list.go
@@ -78,7 +78,7 @@ func (s *DocumentService) GetThumbnails(ctx context.Context, userID string, docI
result := make(map[string]string, len(documents))
for _, document := range documents {
- if document == nil || service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, document.KbID, permission.OperationRead) != nil {
+ if document == nil || service.CheckDocumentAccess(ctx, permission.Subject{UserID: userID}, document.ID, document.KbID, permission.OperationRead) != nil {
continue
}
@@ -118,7 +118,6 @@ func (s *DocumentService) ListDocumentsByDatasetIDWithOptions(ctx context.Contex
if err != nil {
return nil, 0, err
}
-
responses := make([]*entity.DocumentListItem, len(documents))
for i, doc := range documents {
responses[i] = doc
diff --git a/internal/service/document/document_modify_guard_test.go b/internal/service/document/document_modify_guard_test.go
index 95aa509676..421d454b42 100644
--- a/internal/service/document/document_modify_guard_test.go
+++ b/internal/service/document/document_modify_guard_test.go
@@ -55,7 +55,7 @@ func TestValidateDocumentModifiable_TaskStatuses(t *testing.T) {
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", *tc.taskStatus)
}
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
doc := &entity.Document{ID: "doc-1"}
code, err := svc.validateDocumentModifiable(ctx, doc)
if tc.wantErr {
@@ -91,7 +91,7 @@ func updateDatasetDocumentRejected(t *testing.T, status string, req *UpdateDatas
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", status)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", req, present)
if err == nil {
t.Fatalf("expected task-state rejection, got nil error (code=%v)", code)
@@ -117,7 +117,7 @@ func updateDatasetDocumentAllowed(t *testing.T, status string, req *UpdateDatase
}
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", req, present)
if err != nil && strings.Contains(err.Error(), "cannot be modified") {
t.Fatalf("editable doc was wrongly rejected: %v", err)
@@ -200,7 +200,7 @@ func TestUpdateDatasetDocumentRunningEmptyPresentNotRejected(t *testing.T) {
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", common.RUNNING)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1",
&UpdateDatasetDocumentRequest{}, map[string]bool{})
if err != nil {
@@ -230,7 +230,7 @@ func TestUpdateDatasetDocumentAllowsDoneRename(t *testing.T) {
name := "renamed.txt"
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1",
&UpdateDatasetDocumentRequest{Name: &name},
map[string]bool{"name": true})
diff --git a/internal/service/document/document_parser_selection.go b/internal/service/document/document_parser_selection.go
index 435199233c..95de880490 100644
--- a/internal/service/document/document_parser_selection.go
+++ b/internal/service/document/document_parser_selection.go
@@ -5,7 +5,6 @@ import (
"strings"
"ragflow/internal/common"
- "ragflow/internal/dao"
"ragflow/internal/entity"
componentpkg "ragflow/internal/ingestion/component"
"ragflow/internal/ingestion/component/schema"
@@ -198,8 +197,7 @@ func rebuildParserConfig(ctx context.Context, kb *entity.Knowledgebase, target,
cleaned["metadata"] = meta
}
pipelinepkg.ApplyParentChildChunkerConfig(cleaned, raw)
- if tenant, tenantErr := dao.NewTenantDAO().GetByID(ctx, dao.DB, kb.TenantID); tenantErr == nil && tenant != nil {
- cleaned = service.ApplyComponentScopedParserConfig(cleaned, tenant.LLMID)
- }
+ llmID, _ := service.NewTenantService().GetDefaultModelNameForTenant(ctx, kb.TenantID, entity.ModelTypeChat)
+ cleaned = service.ApplyComponentScopedParserConfig(cleaned, llmID)
return cleaned, true
}
diff --git a/internal/service/document/document_parser_selection_test.go b/internal/service/document/document_parser_selection_test.go
index 2f07e5af55..0d53875ba2 100644
--- a/internal/service/document/document_parser_selection_test.go
+++ b/internal/service/document/document_parser_selection_test.go
@@ -147,6 +147,20 @@ func tableParserConfig() entity.JSONMap {
}
}
+func seedDocumentParserTenant(t *testing.T, tenantID, ownerID string) {
+ t.Helper()
+ if err := dao.DB.Create(&entity.Tenant{ID: tenantID}).Error; err != nil {
+ t.Fatalf("insert tenant: %v", err)
+ }
+ status := string(entity.StatusValid)
+ if err := dao.DB.Create(&entity.UserTenant{
+ ID: "owner-" + tenantID, UserID: ownerID, TenantID: tenantID, Role: "owner", Status: &status,
+ LLMID: "llm-default", EmbdID: "embd-default", ASRID: "asr-default",
+ }).Error; err != nil {
+ t.Fatalf("insert tenant owner membership: %v", err)
+ }
+}
+
// TestResolveDocumentParser_Priority pins the resolution order: the dataset's
// selection governs the families its config declares, an undeclared family goes
// to the builtin pipeline that owns it, and failing that to general. Undetermined
@@ -156,9 +170,13 @@ func tableParserConfig() entity.JSONMap {
func TestResolveDocumentParser_Priority(t *testing.T) {
db := setupServiceTestDB(t)
pushServiceDB(t, db)
- if err := dao.DB.Create(&entity.Tenant{ID: "tenant-1", LLMID: "llm-default"}).Error; err != nil {
+ if err := dao.DB.Create(&entity.Tenant{ID: "tenant-1"}).Error; err != nil {
t.Fatalf("insert tenant: %v", err)
}
+ joined := entity.TenantMembershipStatusJoined
+ if err := dao.DB.Create(&entity.UserTenant{ID: "ut-tenant1", UserID: "tenant-1", TenantID: "tenant-1", Role: "owner", Status: &joined, LLMID: "llm-default"}).Error; err != nil {
+ t.Fatalf("insert tenant owner membership: %v", err)
+ }
canvasID := "canvas-1"
legacyConfig := entity.JSONMap{"llm_id": "ministral", "chunk_token_num": 512}
@@ -449,11 +467,7 @@ func TestUploadLocalDocuments_RoutesFileTypesToDedicatedParsers(t *testing.T) {
factory.SetStorage(mockStorage)
t.Cleanup(func() { factory.SetStorage(origStorage) })
- if err := dao.DB.Create(&entity.Tenant{
- ID: "tenant-1", LLMID: "llm-default", EmbdID: "embd-default", ASRID: "asr-default",
- }).Error; err != nil {
- t.Fatalf("insert tenant: %v", err)
- }
+ seedDocumentParserTenant(t, "tenant-1", "user-1")
kbConfig := entity.JSONMap{
"Parser:HipSignsRhyme": map[string]any{
@@ -562,11 +576,7 @@ func TestUploadLocalDocuments_FallsBackWhenSelectionLacksFamily(t *testing.T) {
factory.SetStorage(mockStorage)
t.Cleanup(func() { factory.SetStorage(origStorage) })
- if err := dao.DB.Create(&entity.Tenant{
- ID: "tenant-1", LLMID: "llm-default", EmbdID: "embd-default", ASRID: "asr-default",
- }).Error; err != nil {
- t.Fatalf("insert tenant: %v", err)
- }
+ seedDocumentParserTenant(t, "tenant-1", "user-1")
ctx := t.Context()
svc := testDocumentService(t)
@@ -652,11 +662,7 @@ func TestUploadLocalDocuments_SwitchesVideoToPicture(t *testing.T) {
factory.SetStorage(mockStorage)
t.Cleanup(func() { factory.SetStorage(origStorage) })
- if err := dao.DB.Create(&entity.Tenant{
- ID: "tenant-1", LLMID: "llm-default", EmbdID: "embd-default", ASRID: "asr-default",
- }).Error; err != nil {
- t.Fatalf("insert tenant: %v", err)
- }
+ seedDocumentParserTenant(t, "tenant-1", "user-1")
kb := &entity.Knowledgebase{
ID: "kb-video-block",
@@ -708,11 +714,7 @@ func TestInsertSyncDocument_FallsBackWhenSelectionLacksFamily(t *testing.T) {
factory.SetStorage(mockStorage)
t.Cleanup(func() { factory.SetStorage(origStorage) })
- if err := dao.DB.Create(&entity.Tenant{
- ID: "tenant-1", LLMID: "llm-default", EmbdID: "embd-default", ASRID: "asr-default",
- }).Error; err != nil {
- t.Fatalf("insert tenant: %v", err)
- }
+ seedDocumentParserTenant(t, "tenant-1", "user-1")
kb := &entity.Knowledgebase{
ID: "kb-sync",
diff --git a/internal/service/document/document_permission_ee.go b/internal/service/document/document_permission_ee.go
new file mode 100644
index 0000000000..7b8e258d5d
--- /dev/null
+++ b/internal/service/document/document_permission_ee.go
@@ -0,0 +1,29 @@
+//
+// 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 document
+
+import (
+ "context"
+
+ "gorm.io/gorm"
+
+ "ragflow/internal/entity"
+)
+
+func grantDocumentOwnerEE(context.Context, *gorm.DB, *entity.Document) error {
+ return nil
+}
diff --git a/internal/service/document/document_test.go b/internal/service/document/document_test.go
index 6b9c283f36..04418d7ddc 100644
--- a/internal/service/document/document_test.go
+++ b/internal/service/document/document_test.go
@@ -39,6 +39,7 @@ import (
"ragflow/internal/dao"
"ragflow/internal/engine/types"
"ragflow/internal/entity"
+ "ragflow/internal/permission"
"ragflow/internal/service"
"ragflow/internal/service/file"
"ragflow/internal/storage"
@@ -52,6 +53,18 @@ type recordingTaskPublisher struct {
messages []common.TaskMessage
}
+func documentTestContext(ctx context.Context) context.Context {
+ return permission.WithSubject(ctx, permission.Subject{TenantID: "tenant-1"})
+}
+
+func documentTestContextFor(ctx context.Context, tenantID string) context.Context {
+ return permission.WithSubject(ctx, permission.Subject{TenantID: tenantID})
+}
+
+func documentTestActorContext(ctx context.Context, userID, tenantID string) context.Context {
+ return permission.WithSubject(ctx, permission.Subject{UserID: userID, TenantID: tenantID})
+}
+
type runningTaskPublisher struct {
db *gorm.DB
published chan struct{}
@@ -621,6 +634,17 @@ func insertTestKB(t *testing.T, id, tenantID string, docNum, tokenNum, chunkNum
func ensureTestTenantOwner(t *testing.T, userID, tenantID string) {
t.Helper()
+ var user entity.User
+ if err := dao.DB.Where("id = ?", userID).First(&user).Error; err != nil {
+ if !dao.IsNotFoundErr(err) {
+ t.Fatalf("find test tenant owner user: %v", err)
+ }
+ user = entity.User{ID: userID, Nickname: "test-user", Email: userID + "@test.com"}
+ if err = dao.DB.Create(&user).Error; err != nil {
+ t.Fatalf("insert test tenant owner user: %v", err)
+ }
+ }
+
var owner entity.UserTenant
err := dao.DB.Where("tenant_id = ? AND role = ? AND status = ?", tenantID, "owner", string(entity.StatusValid)).First(&owner).Error
if err == nil {
@@ -645,9 +669,11 @@ func ensureTestTenantOwner(t *testing.T, userID, tenantID string) {
func insertTestCanvas(t *testing.T, canvasID, ownerID string) {
t.Helper()
+ tenantID := "tenant-1"
if err := dao.DB.Create(&entity.UserCanvas{
ID: canvasID,
UserID: ownerID,
+ TenantID: &tenantID,
Permission: string(entity.TenantPermissionMe),
}).Error; err != nil {
t.Fatalf("insert test canvas: %v", err)
@@ -672,6 +698,7 @@ func insertTestDoc(t *testing.T, id, kbID string, tokenNum, chunkNum int64) {
KbID: kbID,
ParserID: "naive",
ParserConfig: entity.JSONMap{},
+ CreatedBy: "user-1",
TokenNum: tokenNum,
ChunkNum: chunkNum,
Suffix: ".txt",
@@ -1144,9 +1171,12 @@ func TestUploadLocalDocuments_MirrorsPythonCoreFields(t *testing.T) {
t.Cleanup(func() { factory.SetStorage(origStorage) })
pipelineID := "pipe-1"
+ ensureTestTenantOwner(t, "user-1", "tenant-1")
+ valid := string(entity.StatusValid)
kb := &entity.Knowledgebase{
ID: "kb-upload",
TenantID: "tenant-1",
+ CreatedBy: "user-1",
Name: "kb-upload",
ParserID: "naive",
PipelineID: &pipelineID,
@@ -1154,6 +1184,7 @@ func TestUploadLocalDocuments_MirrorsPythonCoreFields(t *testing.T) {
"existing": "value",
},
DocNum: 1,
+ Status: &valid,
}
if err := dao.DB.Create(kb).Error; err != nil {
t.Fatalf("insert kb: %v", err)
@@ -1214,15 +1245,19 @@ func TestUploadEmptyDocument_CreatesVirtualDocumentAndFileLink(t *testing.T) {
pushServiceDB(t, db)
pipelineID := "pipe-2"
+ ensureTestTenantOwner(t, "user-1", "tenant-1")
+ valid := string(entity.StatusValid)
kb := &entity.Knowledgebase{
ID: "kb-empty",
TenantID: "tenant-1",
+ CreatedBy: "user-1",
Name: "kb-empty",
ParserID: "manual",
PipelineID: &pipelineID,
ParserConfig: entity.JSONMap{
"foo": "bar",
},
+ Status: &valid,
}
if err := dao.DB.Create(kb).Error; err != nil {
t.Fatalf("insert kb: %v", err)
@@ -1268,15 +1303,10 @@ func insertUserTenantForAccessCheck(t *testing.T, userID, tenantID string) {
t.Fatalf("insert test user: %v", err)
}
}
- // Insert tenant if not exists (llm_id, embd_id, asr_id are NOT NULL)
+ // Insert tenant if not exists.
var existingTenant entity.Tenant
if err := dao.DB.Where("id = ?", tenantID).First(&existingTenant).Error; err != nil {
- tn := &entity.Tenant{
- ID: tenantID,
- LLMID: "llm-default",
- EmbdID: "embd-default",
- ASRID: "asr-default",
- }
+ tn := &entity.Tenant{ID: tenantID}
if err = dao.DB.Create(tn).Error; err != nil {
t.Fatalf("insert test tenant: %v", err)
}
@@ -1294,6 +1324,11 @@ func insertUserTenantForAccessCheck(t *testing.T, userID, tenantID string) {
t.Fatalf("insert test user_tenant: %v", err)
}
}
+ if err := dao.DB.Model(&entity.UserTenant{}).
+ Where("user_id = ? AND tenant_id = ?", userID, tenantID).
+ Updates(map[string]interface{}{"llm_id": "llm-default", "embd_id": "embd-default", "asr_id": "asr-default"}).Error; err != nil {
+ t.Fatalf("set test owner model defaults: %v", err)
+ }
}
func TestDeleteDocuments_DeleteAll(t *testing.T) {
@@ -1310,7 +1345,7 @@ func TestDeleteDocuments_DeleteAll(t *testing.T) {
insertTestIngestionTask(t, "task-3", "user-1", "doc-3", "kb-1")
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
deleted, err := svc.DeleteDocuments(ctx, nil, true, "kb-1", "user-1")
if err != nil {
@@ -1341,7 +1376,7 @@ func TestDeleteDocuments_ByIDs(t *testing.T) {
insertTestIngestionTask(t, "task-3", "user-1", "doc-3", "kb-1")
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
deleted, err := svc.DeleteDocuments(ctx, []string{"doc-1", "doc-2"}, false, "kb-1", "user-1")
if err != nil {
t.Fatalf("DeleteDocuments failed: %v", err)
@@ -1421,7 +1456,7 @@ func TestDeleteDocuments_Deduplicate(t *testing.T) {
insertTestIngestionTask(t, "task-1", "user-1", "doc-1", "kb-1")
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
deleted, err := svc.DeleteDocuments(ctx, []string{"doc-1", "doc-1", "doc-1"}, false, "kb-1", "user-1")
if err != nil {
@@ -2132,7 +2167,7 @@ func TestGetDocumentPreview_AccessControl(t *testing.T) {
insertTestPreviewDoc(t, db, mockStorage, "doc-prev", "kb-prev", "preview body")
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
// Dataset owner reads the original file.
p, err := svc.GetDocumentPreview(ctx, "user-1", "doc-prev")
@@ -2146,9 +2181,9 @@ func TestGetDocumentPreview_AccessControl(t *testing.T) {
// A member of the dataset's tenant reads it too.
if err := db.Create(&entity.UserTenant{
ID: "ut-prev", UserID: "user-2", TenantID: "tenant-1",
- Role: "normal", InvitedBy: "tenant-1", Status: sptr("1"),
+ Role: "normal", InvitedBy: "user-1", Status: sptr(string(entity.StatusValid)),
}).Error; err != nil {
- t.Fatalf("insert user_tenant: %v", err)
+ t.Fatalf("insert Tenant member: %v", err)
}
if _, err = svc.GetDocumentPreview(ctx, "user-2", "doc-prev"); err != nil {
t.Fatalf("team member preview: %v", err)
@@ -2191,7 +2226,7 @@ func TestGetDocumentPreview_EmptyObject(t *testing.T) {
insertTestPreviewDoc(t, db, mockStorage, "doc-prev-empty", "kb-prev-empty", "")
svc := testDocumentService(t)
- _, err := svc.GetDocumentPreview(t.Context(), "user-1", "doc-prev-empty")
+ _, err := svc.GetDocumentPreview(documentTestContext(t.Context()), "user-1", "doc-prev-empty")
if !errors.Is(err, ErrPreviewFileEmpty) {
t.Fatalf("expected ErrPreviewFileEmpty, got %v", err)
}
@@ -2214,7 +2249,7 @@ func TestGetDocumentPreview_MissingObjectSurfacesStorageError(t *testing.T) {
}
svc := testDocumentService(t)
- _, err := svc.GetDocumentPreview(t.Context(), "user-1", "doc-prev-miss")
+ _, err := svc.GetDocumentPreview(documentTestContext(t.Context()), "user-1", "doc-prev-miss")
if err == nil {
t.Fatal("expected storage read error")
}
@@ -2276,7 +2311,7 @@ func TestUpdateDatasetDocumentRejectsNonOwner(t *testing.T) {
insertTestDoc(t, "doc-1", "kb-1", 0, 0)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-2", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{}, map[string]bool{})
if err == nil {
t.Fatal("expected ownership error")
@@ -2297,7 +2332,7 @@ func TestUpdateDatasetDocumentRejectsCounterMutation(t *testing.T) {
chunkCount := int64(6)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
ChunkCount: &chunkCount,
}, map[string]bool{"chunk_count": true})
@@ -2336,7 +2371,7 @@ func TestUpdateDatasetDocumentRejectsZeroImmutableFields(t *testing.T) {
t.Fatalf("prepare document: %v", err)
}
- _, code, err := testDocumentService(t).UpdateDatasetDocument(t.Context(), "user-1", "kb-1", "doc-1", &tt.request, tt.present)
+ _, code, err := testDocumentService(t).UpdateDatasetDocument(documentTestContext(t.Context()), "user-1", "kb-1", "doc-1", &tt.request, tt.present)
if err == nil {
t.Fatalf("expected %s mutation error", tt.name)
}
@@ -2455,7 +2490,7 @@ func TestUpdateDatasetDocumentRejectsUnsupportedParserIDForVisualDoc(t *testing.
parserID := "naive"
parseType := 1
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
ParserID: &parserID,
ParseType: &parseType,
@@ -2479,7 +2514,7 @@ func TestUpdateDatasetDocumentRejectedParserConfigPreservesNames(t *testing.T) {
insertTestFile(t, "file-1", "folder-1", "old.pdf", new("old.pdf"))
insertTestFile2Document(t, "f2d-1", "file-1", "doc-1")
- _, code, err := testDocumentService(t).UpdateDatasetDocument(t.Context(), "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
+ _, code, err := testDocumentService(t).UpdateDatasetDocument(documentTestContext(t.Context()), "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
Name: new("must_not_persist.pdf"),
ParserConfig: map[string]any{
"Parser:HipSignsRhyme": map[string]any{
@@ -2519,7 +2554,7 @@ func TestUpdateDatasetDocumentRenameUpdatesDocumentAndFile(t *testing.T) {
newName := "new.pdf"
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
resp, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
Name: &newName,
}, map[string]bool{"name": true})
@@ -2568,6 +2603,7 @@ func TestUpdateDatasetDocumentParserConfigPreservesParseResults(t *testing.T) {
t.Fatalf("prepare document: %v", err)
}
+ ctx := documentTestContext(t.Context())
request := tc.request
request.ParserConfig = map[string]any{
"Extractor:AutoExtractDefault": map[string]any{"keywords": map[string]any{"top_n": 5}},
@@ -2580,7 +2616,7 @@ func TestUpdateDatasetDocumentParserConfigPreservesParseResults(t *testing.T) {
engine := &rerunDeleteDocEngine{}
svc := testDocumentService(t)
svc.docEngine = engine
- resp, code, err := svc.UpdateDatasetDocument(t.Context(), "user-1", "kb-1", "doc-1", &request, present)
+ resp, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &request, present)
if err != nil || code != common.CodeSuccess {
t.Fatalf("UpdateDatasetDocument failed: code=%v err=%v", code, err)
}
@@ -2590,7 +2626,7 @@ func TestUpdateDatasetDocumentParserConfigPreservesParseResults(t *testing.T) {
if tc.wantPipeline != "" && (resp.PipelineID == nil || *resp.PipelineID != tc.wantPipeline) {
t.Fatalf("pipeline_id = %v, want %q", resp.PipelineID, tc.wantPipeline)
}
- doc, err := dao.NewDocumentDAO().GetByID(t.Context(), db, "doc-1")
+ doc, err := dao.NewDocumentDAO().GetByID(ctx, db, "doc-1")
if err != nil {
t.Fatalf("get document: %v", err)
}
@@ -2605,7 +2641,7 @@ func TestUpdateDatasetDocumentParserConfigPreservesParseResults(t *testing.T) {
if !ok || keywords["top_n"] != float64(5) {
t.Fatalf("parser config not saved: %#v", doc.ParserConfig)
}
- kb, err := dao.NewKnowledgebaseDAO().GetByID(t.Context(), db, "kb-1")
+ kb, err := dao.NewKnowledgebaseDAO().GetByID(ctx, db, "kb-1")
if err != nil {
t.Fatalf("get dataset: %v", err)
}
@@ -2615,7 +2651,7 @@ func TestUpdateDatasetDocumentParserConfigPreservesParseResults(t *testing.T) {
if engine.deleteCalls != 0 || engine.search != nil {
t.Fatalf("existing chunks accessed during settings update: deletes=%d search=%+v", engine.deleteCalls, engine.search)
}
- task, err := svc.ingestionTaskDAO.GetByDocumentID(t.Context(), db, "doc-1")
+ task, err := svc.ingestionTaskDAO.GetByDocumentID(ctx, db, "doc-1")
if err != nil || task == nil || task.ID != "task-1" || task.Status != common.COMPLETED {
t.Fatalf("existing ingestion task changed: task=%+v err=%v", task, err)
}
@@ -3000,7 +3036,7 @@ func TestIngest_RunningTask_SkippedWhenBatchStartingParse(t *testing.T) {
publisher := &recordingTaskPublisher{}
svc := testDocumentService(t)
svc.ingestionTaskSvc.SetTaskPublisher(publisher)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1", "doc-2", "doc-3"},
@@ -3043,7 +3079,7 @@ func TestIngest_AllActiveTasks_ReturnsSuccessIdempotent(t *testing.T) {
publisher := &recordingTaskPublisher{}
svc := testDocumentService(t)
svc.ingestionTaskSvc.SetTaskPublisher(publisher)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1", "doc-2"},
@@ -3076,7 +3112,7 @@ func TestIngest_CompletedTask_SkippedWhenDeleteIsFalse(t *testing.T) {
publisher := &recordingTaskPublisher{}
svc := testDocumentService(t)
svc.ingestionTaskSvc.SetTaskPublisher(publisher)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1", "doc-2"},
@@ -3118,7 +3154,7 @@ func TestIngest_FailedAndStoppedTasks_Restarted(t *testing.T) {
publisher := &recordingTaskPublisher{}
svc := testDocumentService(t)
svc.ingestionTaskSvc.SetTaskPublisher(publisher)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1", "doc-2"},
@@ -3148,7 +3184,7 @@ func TestUpdateDatasetDocumentPropagatesMetadataDeleteFailure(t *testing.T) {
svc := testDocumentService(t)
svc.docEngine = engine
svc.metadataSvc = service.NewMetadataServiceForTest(nil, nil)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
MetaFields: map[string]any{"new": "value"},
}, map[string]bool{"meta_fields": true})
@@ -3488,7 +3524,7 @@ func TestUpdateDatasetDocumentPipelineIDTakesPrecedenceOverParserID(t *testing.T
insertTestCanvas(t, pipelineID, "user-1")
parseType := 2
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
resp, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
PipelineID: &pipelineID,
ParseType: &parseType,
@@ -3523,7 +3559,7 @@ func TestUpdateDatasetDocumentParseTypeBuiltin(t *testing.T) {
parserID := "manual"
pipelineIDEmpty := ""
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
resp, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
ParseType: &parseType,
ParserID: &parserID,
@@ -3559,7 +3595,7 @@ func TestUpdateDatasetDocumentParseTypePipeline(t *testing.T) {
pipelineID := "1234567890abcdef1234567890abcdef"
insertTestCanvas(t, pipelineID, "user-1")
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
resp, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
ParseType: &parseType,
PipelineID: &pipelineID,
@@ -3589,7 +3625,7 @@ func TestUpdateDatasetDocumentParseTypePipelineRejectsParserID(t *testing.T) {
parserID := "manual"
pipelineID := "1234567890abcdef1234567890abcdef"
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
ParseType: &parseType,
ParserID: &parserID,
@@ -3622,7 +3658,7 @@ func TestUpdateDatasetDocumentParentChildConfigSurvivesDSLFailure(t *testing.T)
parseType := 2
pipelineID := "1234567890abcdef1234567890abcdef"
insertTestCanvas(t, pipelineID, "user-1")
- resp, code, err := testDocumentService(t).UpdateDatasetDocument(t.Context(), "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
+ resp, code, err := testDocumentService(t).UpdateDatasetDocument(documentTestContext(t.Context()), "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
ParseType: &parseType,
PipelineID: &pipelineID,
ParserConfig: map[string]any{
@@ -3658,7 +3694,7 @@ func TestUpdateDatasetDocumentRejectsInvalidPages(t *testing.T) {
parseType := 1
parserID := "manual"
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
ParseType: &parseType,
ParserID: &parserID,
@@ -3684,7 +3720,7 @@ func TestUpdateDatasetDocumentParentChildConfigReachesGeneralChunker(t *testing.
insertTestKB(t, "kb-1", "tenant-1", 1, 10, 5)
insertNamedTestDoc(t, "doc-1", "kb-1", "doc.txt", 10, 5)
- resp, code, err := testDocumentService(t).UpdateDatasetDocument(t.Context(), "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
+ resp, code, err := testDocumentService(t).UpdateDatasetDocument(documentTestContext(t.Context()), "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
ParserConfig: map[string]any{
"GeneralChunker:SixApplesFall": map[string]any{
"parent_child": map[string]any{
@@ -3721,7 +3757,7 @@ func TestUpdateDatasetDocumentEnabledUpdatesStatus(t *testing.T) {
enabled := 0
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
resp, code, err := svc.UpdateDatasetDocument(ctx, "user-1", "kb-1", "doc-1", &UpdateDatasetDocumentRequest{
Enabled: &enabled,
}, map[string]bool{"enabled": true})
@@ -3746,7 +3782,7 @@ func insertNamedTestDoc(t *testing.T, id, kbID, name string, tokenNum, chunkNum
Name: sptr(name),
Type: "doc",
SourceType: "local",
- CreatedBy: "tenant-1",
+ CreatedBy: "user-1",
Suffix: filepath.Ext(name),
Status: sptr("1"),
}
@@ -3860,11 +3896,14 @@ func TestGetDocumentArtifact_AuthGate(t *testing.T) {
orig := dao.DB
dao.DB = db
t.Cleanup(func() { dao.DB = orig })
+ ensureTestTenantOwner(t, "user-1", "tenant-1")
// Seed a canvas owned by user-1.
+ tenantID := "tenant-1"
if err := db.Create(&entity.UserCanvas{
ID: "agent-1",
UserID: "user-1",
+ TenantID: &tenantID,
Title: sptr("Agent"),
CanvasCategory: "agent_canvas",
}).Error; err != nil {
@@ -3881,7 +3920,7 @@ func TestGetDocumentArtifact_AuthGate(t *testing.T) {
}
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
mockStorage := useFakeStorage(t)
data := []byte("artifact content")
@@ -3913,6 +3952,7 @@ func TestGetDocumentArtifact_AuthGate(t *testing.T) {
if err := db.Create(&entity.UserCanvas{
ID: "agent-2",
UserID: "user-2",
+ TenantID: &tenantID,
Title: sptr("Other Agent"),
CanvasCategory: "agent_canvas",
}).Error; err != nil {
@@ -3995,7 +4035,7 @@ func TestGetThumbnails_AlignsWithPythonFormatting(t *testing.T) {
}
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
got, err := svc.GetThumbnails(ctx, "user-1", []string{"doc-file", "doc-base64", "doc-other", "missing-doc"})
if err != nil {
t.Fatalf("GetThumbnails failed: %v", err)
@@ -4044,7 +4084,7 @@ func TestGetDocumentImageRejectsUnindexedObjectBeforeStorage(t *testing.T) {
}
func TestGetDocumentImageForDocumentAllowsIndexedSharedBucketImage(t *testing.T) {
- ctx := t.Context()
+ ctx := documentTestContextFor(t.Context(), "user-1")
db := setupServiceTestDB(t)
originalDB := dao.DB
dao.DB = db
@@ -4082,7 +4122,7 @@ func TestGetDocumentImageForDocumentAllowsIndexedSharedBucketImage(t *testing.T)
}
func TestGetDocumentThumbnailAuthorizesBeforeStorage(t *testing.T) {
- ctx := t.Context()
+ ctx := documentTestContextFor(t.Context(), "owner-1")
db := setupServiceTestDB(t)
pushServiceDB(t, db)
insertTestKB(t, "kb-thumb", "owner-1", 0, 0, 0)
@@ -4163,7 +4203,7 @@ func TestIngest_CancelDoesNotDeleteIngestionTask(t *testing.T) {
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", common.RUNNING)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
_, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1"},
Run: string(entity.TaskStatusCancel),
@@ -4192,7 +4232,7 @@ func TestIngest_CancelUnstartedDocument(t *testing.T) {
insertTestDoc(t, "doc-1", "kb-1", 10, 5)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1"},
Run: string(entity.TaskStatusCancel),
@@ -4220,7 +4260,7 @@ func TestIngest_CancelCompletedDocument(t *testing.T) {
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", common.COMPLETED)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1"},
Run: string(entity.TaskStatusCancel),
@@ -4248,7 +4288,7 @@ func TestIngest_CancelUnstartedWithInFlightTask(t *testing.T) {
insertTestIngestionTask(t, "task-1", "user-1", "doc-1", "kb-1")
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1"},
Run: string(entity.TaskStatusCancel),
@@ -4280,7 +4320,7 @@ func TestIngest_CancelAgainWhenAlreadyStopped(t *testing.T) {
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", common.STOPPED)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1"},
Run: string(entity.TaskStatusCancel),
@@ -4305,7 +4345,7 @@ func TestIngest_CancelScheduledTask_TransitionsToStopped(t *testing.T) {
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", common.SCHEDULED)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1"},
Run: string(entity.TaskStatusCancel),
@@ -4362,7 +4402,7 @@ func TestIngest_CancelRunningTask_LifecycleToStopped(t *testing.T) {
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", common.RUNNING)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
// 1. First cancel call: transitions RUNNING -> STOPPING
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
@@ -4443,7 +4483,7 @@ func TestIngest_DeleteOnlyCleansTasks(t *testing.T) {
insertTestIngestionTaskWithStatus(t, "task-1", "user-1", "doc-1", "kb-1", common.COMPLETED)
svc := testDocumentService(t)
- ctx := t.Context()
+ ctx := documentTestContext(t.Context())
code, err := svc.Ingest(ctx, "user-1", &IngestDocumentRequest{
DocIDs: []string{"doc-1"},
Run: "0",
@@ -4528,7 +4568,7 @@ func TestDocumentResponseEmbedsLatestEventForCurrentRun(t *testing.T) {
func TestFileDeleteRemovesLinkedDocument(t *testing.T) {
db := setupServiceTestDB(t)
pushServiceDB(t, db)
- ctx := t.Context()
+ ctx := documentTestActorContext(t.Context(), "user-1", "tenant-1")
insertTestKB(t, "kb-1", "tenant-1", 1, 30, 10)
insertTestDoc(t, "doc-1", "kb-1", 30, 10)
diff --git a/internal/service/document/document_upload.go b/internal/service/document/document_upload.go
index fd89e32ba1..c4d87c8fe5 100644
--- a/internal/service/document/document_upload.go
+++ b/internal/service/document/document_upload.go
@@ -91,7 +91,7 @@ func (s *DocumentService) UploadLocalDocuments(ctx context.Context, kb *entity.K
selection, parserConfig := resolveDocumentParser(ctx, kb, filename, filetype, merged)
doc := s.newDatasetDocument(kb, tenantID, filename, location, string(filetype), selection, parserConfig, "local", int64(len(blob)), blob)
- if err = s.InsertDocument(doc); err != nil {
+ if err = s.InsertDocument(ctx, doc); err != nil {
// Roll back the orphaned blob so a failed insert doesn't leak storage.
rmErr := removeObjectBestEffort(ctx, storageImpl, kb.ID, location)
if rmErr != nil {
@@ -135,7 +135,7 @@ func (s *DocumentService) UploadEmptyDocument(ctx context.Context, kb *entity.Kn
// Virtual documents have no file type to route on, so they keep the
// dataset parser (mirrors Python's _upload_empty_document).
doc := s.newDatasetDocument(kb, tenantID, name, "", "virtual", service.CurrentSelection(kb.ParserID, kb.PipelineID), kb.ParserConfig, "local", 0, nil)
- if err = s.InsertDocument(doc); err != nil {
+ if err = s.InsertDocument(ctx, doc); err != nil {
return nil, common.CodeServerError, err
}
if err = s.addFileFromKB(ctx, doc, kbFolder.ID, kb.TenantID); err != nil {
@@ -274,7 +274,7 @@ func (s *DocumentService) UploadWebDocument(ctx context.Context, kb *entity.Know
selection, parserConfig := resolveDocumentParser(ctx, kb, filename, filetype, kb.ParserConfig)
doc := s.newDatasetDocument(kb, tenantID, filename, location, string(filetype), selection, parserConfig, "web", int64(len(blob)), blob)
- if err = s.InsertDocument(doc); err != nil {
+ if err = s.InsertDocument(ctx, doc); err != nil {
rmErr := removeObjectBestEffort(ctx, storageImpl, kb.ID, location)
if rmErr != nil {
common.Warn(fmt.Sprintf("UploadWebDocument: failed to insert document, remove blob %s/%s: %v", kb.ID, location, rmErr))
diff --git a/internal/service/document/file2document.go b/internal/service/document/file2document.go
index 8133c0f532..0c8e6cc323 100644
--- a/internal/service/document/file2document.go
+++ b/internal/service/document/file2document.go
@@ -262,7 +262,7 @@ func (s *File2DocumentService) convertFiles(ctx context.Context, fileIDs, kbIDs
// InsertDocument creates the row and increments KB doc_num in one
// transaction, so a failed insert never leaves a stale counter.
- if err = s.documentSvc.InsertDocument(doc); err != nil {
+ if err = s.documentSvc.InsertDocument(ctx, doc); err != nil {
common.Warn("convertFiles: InsertDocument failed",
zap.String("kbID", kbID), zap.String("fileID", fileID), zap.Error(err))
continue
diff --git a/internal/service/document/sync_document.go b/internal/service/document/sync_document.go
index 12604745fd..d382e51b84 100644
--- a/internal/service/document/sync_document.go
+++ b/internal/service/document/sync_document.go
@@ -141,7 +141,7 @@ func (s *DocumentService) insertSyncDocument(ctx context.Context, input service.
doc.ContentHash = nil
// put 'file' in mysql `document`
- if err = s.InsertDocument(doc); err != nil {
+ if err = s.InsertDocument(ctx, doc); err != nil {
return service.DocumentUpsertResult{}, err
}
if err = s.publishSyncDocument(ctx, doc, location); err != nil {
diff --git a/internal/service/document_permission.go b/internal/service/document_permission.go
new file mode 100644
index 0000000000..d2896c6bfe
--- /dev/null
+++ b/internal/service/document_permission.go
@@ -0,0 +1,29 @@
+package service
+
+import (
+ "context"
+ "errors"
+
+ "ragflow/internal/dao"
+ "ragflow/internal/permission"
+)
+
+// CheckDocumentAccess keeps dataset grants effective for every document while
+// allowing a direct document grant to expose that document independently.
+func CheckDocumentAccess(ctx context.Context, subject permission.Subject, documentID, datasetID string, operation permission.Operation) error {
+ checker := permission.NewDatabaseChecker(dao.DB)
+ datasetErr := checker.CheckResource(ctx, subject, permission.ResourceRef{
+ Kind: permission.ResourceKindDataset,
+ ID: datasetID,
+ }, operation)
+ if datasetErr == nil {
+ return nil
+ }
+ if !errors.Is(datasetErr, permission.ErrPermissionDenied) && !errors.Is(datasetErr, permission.ErrMembershipNotFound) {
+ return datasetErr
+ }
+ return checker.CheckResource(ctx, subject, permission.ResourceRef{
+ Kind: permission.ResourceKindDocument,
+ ID: documentID,
+ }, operation)
+}
diff --git a/internal/service/file/access.go b/internal/service/file/access.go
index 602031dd43..f6e87a224e 100644
--- a/internal/service/file/access.go
+++ b/internal/service/file/access.go
@@ -22,22 +22,65 @@ func checkFileAccess(ctx context.Context, userID string, file *entity.File, oper
}, operation)
}
-func (s *FileService) checkFileTreeAccess(ctx context.Context, userID string, file *entity.File, operation permission.Operation) error {
- if err := checkFileAccess(ctx, userID, file, operation); err != nil {
- return err
+func fileRequestSubject(ctx context.Context, identity string) (string, string, error) {
+ subject, ok := permission.SubjectFromContext(ctx)
+ if !ok {
+ return identity, identity, nil
+ }
+ if subject.UserID == "" || subject.UserID != identity {
+ return "", "", permission.ErrInvalidSubject
}
- if file.Type != FileTypeFolder {
- return nil
+ tenantID := subject.TenantID
+ if tenantID == "" {
+ tenantID = identity
}
+ return subject.UserID, tenantID, nil
+}
- children, err := s.fileDAO.ListByParentID(ctx, dao.DB, file.ID)
- if err != nil {
- return err
+func tenantFileContext(ctx context.Context, userID, tenantID string) (context.Context, error) {
+ if subject, ok := permission.SubjectFromContext(ctx); ok {
+ if subject.UserID != "" && subject.UserID != userID || subject.TenantID != "" && subject.TenantID != tenantID {
+ return nil, permission.ErrInvalidSubject
+ }
+ }
+ return permission.WithSubject(ctx, permission.Subject{UserID: userID, TenantID: tenantID}), nil
+}
+
+func (s *FileService) checkFileTreeAccess(ctx context.Context, userID string, file *entity.File, operation permission.Operation) error {
+ if file == nil {
+ return permission.ErrResourceNotFound
}
- for _, child := range children {
- if err := s.checkFileTreeAccess(ctx, userID, child, operation); err != nil {
+ entries := []entity.File{*file}
+ if file.Type == FileTypeFolder {
+ descendants, err := s.fileDAO.ListDescendants(ctx, dao.DB, file.ID)
+ if err != nil {
return err
}
+ entries = append(entries, descendants...)
+ }
+
+ const permissionBatchSize = 500
+ checker := permission.NewDatabaseChecker(dao.DB)
+ for start := 0; start < len(entries); start += permissionBatchSize {
+ end := start + permissionBatchSize
+ if end > len(entries) {
+ end = len(entries)
+ }
+ refs := make([]permission.ResourceRef, 0, end-start)
+ for _, entry := range entries[start:end] {
+ kind := permission.ResourceKindFile
+ if entry.Type == FileTypeFolder {
+ kind = permission.ResourceKindFolder
+ }
+ refs = append(refs, permission.ResourceRef{Kind: kind, ID: entry.ID})
+ }
+ accessible, err := checker.FilterResources(ctx, permission.Subject{UserID: userID}, refs, operation)
+ if err != nil {
+ return err
+ }
+ if len(accessible) != len(refs) {
+ return permission.ErrPermissionDenied
+ }
}
return nil
}
diff --git a/internal/service/file/file_browse_permission_test.go b/internal/service/file/file_browse_permission_test.go
index 3f8eca2da8..8628959e81 100644
--- a/internal/service/file/file_browse_permission_test.go
+++ b/internal/service/file/file_browse_permission_test.go
@@ -22,7 +22,8 @@ func seedFileBrowsing(t *testing.T) {
}
for _, entry := range []entity.File{
{ID: "root", ParentID: "root", TenantID: "owner", CreatedBy: "owner", Name: "/", Type: FileTypeFolder},
- {ID: "tags", ParentID: "root", TenantID: "owner", CreatedBy: "owner", Name: "tags.txt", Type: "doc"},
+ {ID: "tags", ParentID: "root", TenantID: "owner", CreatedBy: "reader", Name: "tags.txt", Type: "doc"},
+ {ID: "private", ParentID: "root", TenantID: "owner", CreatedBy: "owner", Name: "private.txt", Type: "doc"},
{ID: "foreign-root", ParentID: "foreign-root", TenantID: "foreign", Name: "/", Type: FileTypeFolder},
{ID: "foreign-tags", ParentID: "foreign-root", TenantID: "foreign", Name: "tags.txt", Type: "doc"},
} {
@@ -32,16 +33,22 @@ func seedFileBrowsing(t *testing.T) {
}
}
-func TestTenantMemberCanBrowseTagFiles(t *testing.T) {
+func TestTenantMemberSeesOnlyReadableFilesAndPaths(t *testing.T) {
seedFileBrowsing(t)
svc := testFileService()
ctx := t.Context()
- list, err := svc.ListFilesForTenant(ctx, "reader", "owner", "", 1, 100, nil, "")
+ list, err := svc.ListFilesForTenant(ctx, "reader", "owner", "", 1, 1, nil, "")
if err != nil {
t.Fatalf("list shared tenant files: %v", err)
}
if list.Total != 1 {
- t.Fatalf("file count = %d, want 1", list.Total)
+ t.Fatalf("file count = %d, want only the readable file", list.Total)
+ }
+ if len(list.Files) != 1 || list.Files[0]["id"] != "tags" {
+ t.Fatalf("listed files = %#v, want only readable file tags", list.Files)
+ }
+ if list.Files[0]["operator_permission"] != permission.ResourcePermissionOwner {
+ t.Fatalf("owner file permission mask = %v, want %d", list.Files[0]["operator_permission"], permission.ResourcePermissionOwner)
}
ancestors, err := svc.GetAllParentFoldersForTenant(ctx, "reader", "owner", "tags")
if err != nil {
@@ -50,11 +57,14 @@ func TestTenantMemberCanBrowseTagFiles(t *testing.T) {
if len(ancestors) != 2 {
t.Fatalf("ancestor count = %d, want 2", len(ancestors))
}
- if _, err := svc.GetFileContent(ctx, "reader", "tags"); !errors.Is(err, permission.ErrPermissionDenied) {
- t.Fatalf("read file contents error = %v, want permission denied", err)
+ if _, err := svc.GetAllParentFoldersForTenant(ctx, "reader", "owner", "private"); !errors.Is(err, permission.ErrPermissionDenied) {
+ t.Fatalf("resolve private file path error = %v, want permission denied", err)
+ }
+ if _, err := svc.GetFileContent(ctx, "reader", "private"); !errors.Is(err, permission.ErrPermissionDenied) {
+ t.Fatalf("read private file error = %v, want permission denied", err)
}
- if err := svc.MoveFiles(ctx, "reader", []string{"tags"}, "", "new-tags.txt"); !errors.Is(err, permission.ErrPermissionDenied) {
- t.Fatalf("rename file error = %v, want permission denied", err)
+ if err := svc.MoveFiles(ctx, "reader", []string{"private"}, "", "new-private.txt"); !errors.Is(err, permission.ErrPermissionDenied) {
+ t.Fatalf("rename private file error = %v, want permission denied", err)
}
}
diff --git a/internal/service/file/file_delete_test.go b/internal/service/file/file_delete_test.go
index 7e00722f98..ed55cb99ba 100644
--- a/internal/service/file/file_delete_test.go
+++ b/internal/service/file/file_delete_test.go
@@ -19,6 +19,7 @@ package file
import (
"context"
"errors"
+ "fmt"
"testing"
"ragflow/internal/common"
@@ -40,7 +41,7 @@ func (f failingObjectCheckStorage) ObjectExists(context.Context, string, string)
func TestDeleteFolderLeavesNonemptyBucket(t *testing.T) {
db := setupFolderTestDB(t)
- folder, err := testFileService().fileDAO.CreateFolder(t.Context(), db, "root", "tenant-1", "folder", FileTypeFolder)
+ folder, err := testFileService().fileDAO.CreateFolder(t.Context(), db, "root", "tenant-1", "tenant-1", "folder", FileTypeFolder)
if err != nil {
t.Fatal(err)
}
@@ -84,7 +85,7 @@ func TestDeleteFolderLeavesNonemptyBucket(t *testing.T) {
func TestDeleteFolderStopsOnStorageCheckError(t *testing.T) {
db := setupFolderTestDB(t)
- folder, err := testFileService().fileDAO.CreateFolder(t.Context(), db, "root", "tenant-1", "folder", FileTypeFolder)
+ folder, err := testFileService().fileDAO.CreateFolder(t.Context(), db, "root", "tenant-1", "tenant-1", "folder", FileTypeFolder)
if err != nil {
t.Fatal(err)
}
@@ -104,7 +105,7 @@ func TestDeleteFolderStopsOnStorageCheckError(t *testing.T) {
func TestDeleteFolderContinuesWhenStorageIsMissing(t *testing.T) {
db := setupFolderTestDB(t)
service := testFileService()
- folder, err := service.fileDAO.CreateFolder(t.Context(), db, "root", "tenant-1", "folder", FileTypeFolder)
+ folder, err := service.fileDAO.CreateFolder(t.Context(), db, "root", "tenant-1", "tenant-1", "folder", FileTypeFolder)
if err != nil {
t.Fatal(err)
}
@@ -125,7 +126,8 @@ func TestDeleteFilesAuthorizesEveryDescendantBeforeDeleting(t *testing.T) {
db := setupFolderTestDB(t)
for _, file := range []*entity.File{
{ID: "folder", ParentID: "root", TenantID: "user-1", Name: "folder", Type: FileTypeFolder},
- {ID: "foreign-child", ParentID: "folder", TenantID: "user-2", Name: "private.pdf", Type: "pdf"},
+ {ID: "child-folder", ParentID: "folder", TenantID: "user-1", CreatedBy: "user-1", Name: "child", Type: FileTypeFolder},
+ {ID: "foreign-child", ParentID: "child-folder", TenantID: "user-2", Name: "private.pdf", Type: "pdf"},
} {
if err := db.Create(file).Error; err != nil {
t.Fatalf("seed %s: %v", file.ID, err)
@@ -136,9 +138,30 @@ func TestDeleteFilesAuthorizesEveryDescendantBeforeDeleting(t *testing.T) {
if !errors.Is(err, permission.ErrPermissionDenied) {
t.Fatalf("DeleteFiles error = %v, want permission denied", err)
}
- for _, id := range []string{"folder", "foreign-child"} {
+ for _, id := range []string{"folder", "child-folder", "foreign-child"} {
if _, err := dao.NewFileDAO().GetByID(t.Context(), db, id); err != nil {
t.Fatalf("file %q was removed before authorization completed: %v", id, err)
}
}
}
+
+func TestFileService_CheckFileTreeAccessBatchesWideSubtrees(t *testing.T) {
+ db := setupFolderTestDB(t)
+ entries := make([]entity.File, 0, 1+2*510)
+ entries = append(entries, entity.File{ID: "tree-root", ParentID: "tree-root", TenantID: "tenant-1", CreatedBy: "owner", Name: "/", Type: FileTypeFolder})
+ for i := 0; i < 510; i++ {
+ folderID := fmt.Sprintf("folder-%04d", i)
+ entries = append(entries,
+ entity.File{ID: folderID, ParentID: "tree-root", TenantID: "tenant-1", CreatedBy: "owner", Name: folderID, Type: FileTypeFolder},
+ entity.File{ID: fmt.Sprintf("file-%04d", i), ParentID: folderID, TenantID: "tenant-1", CreatedBy: "owner", Name: "child.txt", Type: "doc"},
+ )
+ }
+ if err := db.CreateInBatches(&entries, 100).Error; err != nil {
+ t.Fatalf("seed wide file tree: %v", err)
+ }
+
+ root := &entity.File{ID: "tree-root", ParentID: "tree-root", TenantID: "tenant-1", CreatedBy: "owner", Name: "/", Type: FileTypeFolder}
+ if err := testFileService().checkFileTreeAccess(t.Context(), "owner", root, permission.OperationDelete); err != nil {
+ t.Fatalf("check permissions for wide subtree: %v", err)
+ }
+}
diff --git a/internal/service/file/file_folder.go b/internal/service/file/file_folder.go
index 87e71307ce..61800e170a 100644
--- a/internal/service/file/file_folder.go
+++ b/internal/service/file/file_folder.go
@@ -40,21 +40,25 @@ func lookupError(err error, message string) error {
// ListFiles lists files by parent folder ID (matching Python /files endpoint)
// This method includes init_dataset_docs initialization when parent_id is empty
func (s *FileService) ListFiles(ctx context.Context, tenantID, pfID string, page, pageSize int, terms []dao.OrderTerm, keywords string) (*ListFilesResponse, error) {
- return s.listFiles(ctx, tenantID, tenantID, pfID, page, pageSize, terms, keywords, true)
+ return s.listFiles(ctx, tenantID, tenantID, pfID, page, pageSize, terms, keywords)
}
// ListFilesForTenant allows active tenant members to browse the tenant's files.
func (s *FileService) ListFilesForTenant(ctx context.Context, userID, tenantID, pfID string, page, pageSize int, terms []dao.OrderTerm, keywords string) (*ListFilesResponse, error) {
- checkFilePermissions := userID == tenantID
- if !checkFilePermissions {
- if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, permission.TenantMember); err != nil {
+ if userID != tenantID {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, tenantID, permission.TenantMember); err != nil {
return nil, err
}
}
- return s.listFiles(ctx, userID, tenantID, pfID, page, pageSize, terms, keywords, checkFilePermissions)
+ var err error
+ ctx, err = tenantFileContext(ctx, userID, tenantID)
+ if err != nil {
+ return nil, err
+ }
+ return s.listFiles(ctx, userID, tenantID, pfID, page, pageSize, terms, keywords)
}
-func (s *FileService) listFiles(ctx context.Context, userID, tenantID, pfID string, page, pageSize int, terms []dao.OrderTerm, keywords string, checkFilePermissions bool) (*ListFilesResponse, error) {
+func (s *FileService) listFiles(ctx context.Context, userID, tenantID, pfID string, page, pageSize int, terms []dao.OrderTerm, keywords string) (*ListFilesResponse, error) {
if tenantID == "" {
return nil, permission.ErrInvalidSubject
}
@@ -64,10 +68,8 @@ func (s *FileService) listFiles(ctx context.Context, userID, tenantID, pfID stri
if err != nil {
return nil, fmt.Errorf("failed to get root folder: %w", err)
}
- if checkFilePermissions {
- if err := checkFileAccess(ctx, userID, rootFolder, permission.OperationRead); err != nil {
- return nil, err
- }
+ if err := checkFileAccess(ctx, userID, rootFolder, permission.OperationRead); err != nil {
+ return nil, err
}
pfID = rootFolder.ID
@@ -94,21 +96,53 @@ func (s *FileService) listFiles(ctx context.Context, userID, tenantID, pfID stri
if folder.Type != FileTypeFolder {
return nil, permission.ErrResourceNotFound
}
- if checkFilePermissions {
- if err := checkFileAccess(ctx, userID, folder, permission.OperationRead); err != nil {
- return nil, err
- }
- }
if folder.TenantID != tenantID {
return nil, permission.ErrResourceNotFound
}
+ if err := s.checkFilePathAccess(ctx, userID, tenantID, folder.ID); err != nil {
+ return nil, err
+ }
- // Get files by parent folder ID
+ // Apply file visibility in SQL before count and pagination. Community
+ // permission policy compiles this to correlated EXISTS predicates so large
+ // folders do not need to materialize every candidate ID.
excludeSkills := folder.ID == folder.ParentID
- files, total, err := s.fileDAO.GetByPfID(ctx, dao.DB, tenantID, pfID, page, pageSize, terms, keywords, excludeSkills)
+ checker := permission.NewDatabaseChecker(dao.DB)
+ visibilityScope, err := checker.QueryScope(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindFile,
+ Parent: permission.ResourceRef{Kind: permission.ResourceKindFolder, ID: folder.ID},
+ Operation: permission.OperationRead,
+ })
+ if err != nil {
+ return nil, err
+ }
+ files, total, err := s.fileDAO.GetByPfID(ctx, dao.DB, tenantID, pfID, page, pageSize, terms, keywords, excludeSkills, visibilityScope.Apply)
if err != nil {
return nil, err
}
+ refs := make([]permission.ResourceRef, 0, len(files))
+ refsByFileID := make(map[string]permission.ResourceRef, len(files))
+ for _, file := range files {
+ kind := permission.ResourceKindFile
+ if file.Type == FileTypeFolder {
+ kind = permission.ResourceKindFolder
+ }
+ ref := permission.ResourceRef{Kind: kind, ID: file.ID}
+ if _, exists := refsByFileID[file.ID]; exists {
+ continue
+ }
+ refsByFileID[file.ID] = ref
+ refs = append(refs, ref)
+ }
+ accesses, err := checker.FilterAccesses(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, refs, permission.OperationRead)
+ if err != nil {
+ return nil, err
+ }
+ if len(accesses) != len(refs) {
+ // The SQL visibility predicate and the resolved permissions must agree.
+ // Fail closed if authorization changed while this page was being read.
+ return nil, permission.ErrPermissionDenied
+ }
// Get parent folder
parentFolder, err := s.fileDAO.GetParentFolder(ctx, dao.DB, pfID)
@@ -150,7 +184,9 @@ func (s *FileService) listFiles(ctx context.Context, userID, tenantID, pfID stri
fileInfo.KbsInfo = kbsInfo
}
- fileResponses = append(fileResponses, s.fileInfoToResponse(fileInfo))
+ fileResponse := s.fileInfoToResponse(fileInfo)
+ fileResponse["operator_permission"] = accesses[refsByFileID[file.ID]].PermissionMask
+ fileResponses = append(fileResponses, fileResponse)
}
return &ListFilesResponse{
@@ -295,7 +331,7 @@ func (s *FileService) GetParentFolder(ctx context.Context, userID, fileID string
// GetAllParentFolders gets all parent folders in path with permission check
func (s *FileService) GetAllParentFolders(ctx context.Context, userID, fileID string) ([]map[string]interface{}, error) {
- return s.getAllParentFolders(ctx, userID, "", fileID, true)
+ return s.getAllParentFolders(ctx, userID, "", fileID)
}
// GetAllParentFoldersForTenant allows active tenant members to resolve file paths.
@@ -304,16 +340,20 @@ func (s *FileService) GetAllParentFoldersForTenant(ctx context.Context, userID,
if tenantID == "" {
return nil, permission.ErrInvalidSubject
}
- checkFilePermissions := userID == tenantID
- if !checkFilePermissions {
- if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, permission.TenantMember); err != nil {
+ if userID != tenantID {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, tenantID, permission.TenantMember); err != nil {
return nil, err
}
}
- return s.getAllParentFolders(ctx, userID, tenantID, fileID, checkFilePermissions)
+ var err error
+ ctx, err = tenantFileContext(ctx, userID, tenantID)
+ if err != nil {
+ return nil, err
+ }
+ return s.getAllParentFolders(ctx, userID, tenantID, fileID)
}
-func (s *FileService) getAllParentFolders(ctx context.Context, userID, tenantID, fileID string, checkFilePermissions bool) ([]map[string]interface{}, error) {
+func (s *FileService) getAllParentFolders(ctx context.Context, userID, tenantID, fileID string) ([]map[string]interface{}, error) {
// Get file
file, err := s.fileDAO.GetByID(ctx, dao.DB, fileID)
if err != nil {
@@ -324,10 +364,8 @@ func (s *FileService) getAllParentFolders(ctx context.Context, userID, tenantID,
}
// Permission check
- if checkFilePermissions {
- if err := checkFileAccess(ctx, userID, file, permission.OperationRead); err != nil {
- return nil, err
- }
+ if err := checkFileAccess(ctx, userID, file, permission.OperationRead); err != nil {
+ return nil, err
}
// Get all parent folders
@@ -339,10 +377,8 @@ func (s *FileService) getAllParentFolders(ctx context.Context, userID, tenantID,
if tenantID != "" && folder.TenantID != tenantID {
return nil, permission.ErrResourceNotFound
}
- if checkFilePermissions {
- if err := checkFileAccess(ctx, userID, folder, permission.OperationRead); err != nil {
- return nil, err
- }
+ if err := checkFileAccess(ctx, userID, folder, permission.OperationRead); err != nil {
+ return nil, err
}
}
@@ -355,23 +391,47 @@ func (s *FileService) getAllParentFolders(ctx context.Context, userID, tenantID,
return result, nil
}
+func (s *FileService) checkFilePathAccess(ctx context.Context, userID, tenantID, fileID string) error {
+ folders, err := s.fileDAO.GetAllParentFolders(ctx, dao.DB, fileID)
+ if err != nil {
+ return err
+ }
+ for _, folder := range folders {
+ if folder.TenantID != tenantID {
+ return permission.ErrResourceNotFound
+ }
+ if err := checkFileAccess(ctx, userID, folder, permission.OperationRead); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
// GetDocCount gets document count for a tenant
func (s *FileService) GetDocCount(ctx context.Context, tenantID string) (int64, error) {
documentDAO := dao.NewDocumentDAO()
return documentDAO.CountByTenantID(ctx, dao.DB, tenantID)
}
-func (s *FileService) createFolderRecursive(ctx context.Context, parentFolder *entity.File, names []string, count int, tenantID string) (*entity.File, error) {
+func (s *FileService) createFolderRecursive(ctx context.Context, parentFolder *entity.File, names []string, count int, tenantID, userID string) (*entity.File, error) {
if count > len(names)-2 {
return parentFolder, nil
}
- newFolder, err := s.fileDAO.CreateFolder(ctx, dao.DB, parentFolder.ID, tenantID, names[count], FileTypeFolder)
+ var newFolder *entity.File
+ err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var createErr error
+ newFolder, createErr = s.fileDAO.CreateFolder(ctx, tx, parentFolder.ID, tenantID, userID, names[count], FileTypeFolder)
+ if createErr != nil {
+ return createErr
+ }
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindFolder, ID: newFolder.ID})
+ })
if err != nil {
return nil, err
}
- return s.createFolderRecursive(ctx, newFolder, names, count+1, tenantID)
+ return s.createFolderRecursive(ctx, newFolder, names, count+1, tenantID, userID)
}
// getUniqueFilename returns a non-colliding file name within the folder,
@@ -383,7 +443,14 @@ func (s *FileService) getUniqueFilename(ctx context.Context, name, parentID, ten
}
// CreateFolder creates a new folder or virtual file
-func (s *FileService) CreateFolder(ctx context.Context, tenantID, name, parentID, fileType string) (map[string]interface{}, error) {
+func (s *FileService) CreateFolder(ctx context.Context, userID, name, parentID, fileType string) (map[string]interface{}, error) {
+ userID, tenantID, err := fileRequestSubject(ctx, userID)
+ if err != nil {
+ return nil, err
+ }
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "file", permission.ActionWrite); err != nil {
+ return nil, err
+ }
// "/" is the root folder name and the path separator used by recursive
// folder creation, so names containing it collide with the root folder
// and break path-based lookups.
@@ -403,7 +470,10 @@ func (s *FileService) CreateFolder(ctx context.Context, tenantID, name, parentID
if err != nil || parentFolder == nil || parentFolder.Type != FileTypeFolder {
return nil, fmt.Errorf("parent folder not found")
}
- if err := checkFileAccess(ctx, tenantID, parentFolder, permission.OperationCreate); err != nil {
+ if parentFolder.TenantID != tenantID {
+ return nil, permission.ErrResourceNotFound
+ }
+ if err := checkFileAccess(ctx, userID, parentFolder, permission.OperationCreate); err != nil {
return nil, err
}
@@ -429,7 +499,19 @@ func (s *FileService) CreateFolder(ctx context.Context, tenantID, name, parentID
}
name = uniqueName
- folder, err := s.fileDAO.CreateFolder(ctx, dao.DB, parentID, tenantID, name, fileType)
+ var folder *entity.File
+ err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var createErr error
+ folder, createErr = s.fileDAO.CreateFolder(ctx, tx, parentID, tenantID, userID, name, fileType)
+ if createErr != nil {
+ return createErr
+ }
+ kind := permission.ResourceKindFile
+ if fileType == FileTypeFolder {
+ kind = permission.ResourceKindFolder
+ }
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: kind, ID: folder.ID})
+ })
if err != nil {
return nil, fmt.Errorf("failed to create folder: %w", err)
}
@@ -658,7 +740,7 @@ func (s *FileService) moveEntryRecursive(ctx context.Context, userID string, sou
} else {
// Create new folder
var err error
- newFolder, err = s.fileDAO.CreateFolder(ctx, dao.DB, destFolder.ID, sourceFile.TenantID, effectiveName, FileTypeFolder)
+ newFolder, err = s.fileDAO.CreateFolder(ctx, dao.DB, destFolder.ID, sourceFile.TenantID, userID, effectiveName, FileTypeFolder)
if err != nil {
return fmt.Errorf("failed to create destination folder: %w", err)
}
diff --git a/internal/service/file/file_folder_test.go b/internal/service/file/file_folder_test.go
index f0715a970e..572956d486 100644
--- a/internal/service/file/file_folder_test.go
+++ b/internal/service/file/file_folder_test.go
@@ -75,6 +75,36 @@ func TestFileService_CreateFolderDedupesDuplicateName(t *testing.T) {
}
}
+func TestFileService_CreateFolderRecordsRequesterAsOwner(t *testing.T) {
+ db := setupFolderTestDB(t)
+ valid := string(entity.StatusValid)
+ for _, membership := range []entity.UserTenant{
+ {ID: "owner-membership", UserID: "owner", TenantID: "owner", Role: string(permission.RoleOwner), Status: &valid},
+ {ID: "member-membership", UserID: "member", TenantID: "owner", Role: string(permission.RoleNormal), Status: &valid},
+ } {
+ if err := db.Create(&membership).Error; err != nil {
+ t.Fatalf("create membership: %v", err)
+ }
+ }
+ if err := db.Create(&entity.File{ID: "root", ParentID: "root", TenantID: "owner", CreatedBy: "owner", Name: "/", Type: FileTypeFolder}).Error; err != nil {
+ t.Fatalf("create root folder: %v", err)
+ }
+
+ ctx := permission.WithSubject(t.Context(), permission.Subject{UserID: "member", TenantID: "owner"})
+ created, err := testFileService().CreateFolder(ctx, "member", "notes", "root", FileTypeFolder)
+ if err != nil {
+ t.Fatalf("create folder: %v", err)
+ }
+
+ var folder entity.File
+ if err := db.Where("id = ?", created["id"]).First(&folder).Error; err != nil {
+ t.Fatalf("load created folder: %v", err)
+ }
+ if folder.TenantID != "owner" || folder.CreatedBy != "member" {
+ t.Fatalf("created folder owner = user %q tenant %q, want requester member in tenant owner", folder.CreatedBy, folder.TenantID)
+ }
+}
+
// firstCreatedFolderName creates one entry and returns its resulting name.
func firstCreatedFolderName(t *testing.T, svc *FileService, name, fileType string) string {
t.Helper()
@@ -305,8 +335,8 @@ func TestFileService_ListFilesRejectsInaccessibleParent(t *testing.T) {
}
_, err := testFileService().ListFiles(t.Context(), "user-1", foreignFolder.ID, 1, 15, nil, "")
- if !errors.Is(err, permission.ErrPermissionDenied) {
- t.Fatalf("ListFiles error = %v, want permission denied", err)
+ if !errors.Is(err, permission.ErrResourceNotFound) {
+ t.Fatalf("ListFiles error = %v, want resource not found", err)
}
}
@@ -318,8 +348,8 @@ func TestFileService_CreateFolderRejectsInaccessibleParent(t *testing.T) {
}
_, err := testFileService().CreateFolder(t.Context(), "user-1", "child", foreignFolder.ID, FileTypeFolder)
- if !errors.Is(err, permission.ErrPermissionDenied) {
- t.Fatalf("CreateFolder error = %v, want permission denied", err)
+ if !errors.Is(err, permission.ErrResourceNotFound) {
+ t.Fatalf("CreateFolder error = %v, want resource not found", err)
}
children, err := dao.NewFileDAO().ListByParentID(t.Context(), dao.DB, foreignFolder.ID)
if err != nil {
@@ -379,8 +409,8 @@ func TestFileService_UploadRejectsInaccessibleParent(t *testing.T) {
}
_, err := testFileService().UploadFile(t.Context(), "user-1", foreignFolder.ID, nil, 1024)
- if !errors.Is(err, permission.ErrPermissionDenied) {
- t.Fatalf("UploadFile error = %v, want permission denied", err)
+ if !errors.Is(err, permission.ErrResourceNotFound) {
+ t.Fatalf("UploadFile error = %v, want resource not found", err)
}
}
diff --git a/internal/service/file/file_upload.go b/internal/service/file/file_upload.go
index 18b3903c32..3f7a037717 100644
--- a/internal/service/file/file_upload.go
+++ b/internal/service/file/file_upload.go
@@ -3,6 +3,7 @@ package file
import (
"context"
"fmt"
+ "gorm.io/gorm"
"io"
"mime/multipart"
"net/http"
@@ -33,6 +34,14 @@ func DeploymentUploadMaxBytes() int64 {
// UploadFile uploads files to a folder
func (s *FileService) UploadFile(ctx context.Context, tenantID, parentID string, files []*multipart.FileHeader, maxBytes int64) ([]map[string]interface{}, error) {
+ userID, currentTenantID, err := fileRequestSubject(ctx, tenantID)
+ if err != nil {
+ return nil, err
+ }
+ tenantID = currentTenantID
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "file", permission.ActionWrite); err != nil {
+ return nil, err
+ }
if parentID == "" {
rootFolder, err := s.fileDAO.GetRootFolder(ctx, dao.DB, tenantID)
if err != nil {
@@ -45,7 +54,10 @@ func (s *FileService) UploadFile(ctx context.Context, tenantID, parentID string,
if err != nil || parentFolder == nil || parentFolder.Type != FileTypeFolder {
return nil, fmt.Errorf("can't find this folder")
}
- if err := checkFileAccess(ctx, tenantID, parentFolder, permission.OperationCreate); err != nil {
+ if parentFolder.TenantID != tenantID {
+ return nil, permission.ErrResourceNotFound
+ }
+ if err := checkFileAccess(ctx, userID, parentFolder, permission.OperationCreate); err != nil {
return nil, err
}
@@ -99,7 +111,7 @@ func (s *FileService) UploadFile(ctx context.Context, tenantID, parentID string,
return nil, fmt.Errorf("folder not found")
}
var createdFolder *entity.File
- createdFolder, err = s.createFolderRecursive(ctx, lastFolder, fileObjNames, len(idList), tenantID)
+ createdFolder, err = s.createFolderRecursive(ctx, lastFolder, fileObjNames, len(idList), tenantID, userID)
if err != nil {
return nil, fmt.Errorf("failed to create folder: %w", err)
}
@@ -144,7 +156,7 @@ func (s *FileService) UploadFile(ctx context.Context, tenantID, parentID string,
ID: common.GenerateToken(),
ParentID: lastFolder.ID,
TenantID: tenantID,
- CreatedBy: tenantID,
+ CreatedBy: userID,
Name: uniqueName,
Location: &location,
Size: int64(len(data)),
@@ -152,7 +164,13 @@ func (s *FileService) UploadFile(ctx context.Context, tenantID, parentID string,
SourceType: "",
}
- if err = s.fileDAO.Insert(ctx, dao.DB, fileRecord); err != nil {
+ if err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.fileDAO.Insert(ctx, tx, fileRecord); err != nil {
+ return err
+ }
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindFile, ID: fileRecord.ID})
+ }); err != nil {
+ _ = storageImpl.Remove(ctx, lastFolder.ID, location)
return nil, fmt.Errorf("failed to insert file record: %w", err)
}
diff --git a/internal/service/mcp.go b/internal/service/mcp.go
index 4fd8bcab41..cd0d4d974a 100644
--- a/internal/service/mcp.go
+++ b/internal/service/mcp.go
@@ -27,6 +27,7 @@ import (
"strings"
"time"
+ "gorm.io/gorm"
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
@@ -86,14 +87,15 @@ type UpdateMCPServerRequest map[string]json.RawMessage
// MCPServerListItem is an MCP server item in the list response.
type MCPServerListItem struct {
- ID string `json:"id"`
- Name string `json:"name"`
- ServerType string `json:"server_type"`
- URL string `json:"url"`
- Description *string `json:"description"`
- Variables entity.JSONMap `json:"variables"`
- CreateDate *string `json:"create_date"`
- UpdateDate *string `json:"update_date"`
+ ID string `json:"id"`
+ Name string `json:"name"`
+ ServerType string `json:"server_type"`
+ URL string `json:"url"`
+ Description *string `json:"description"`
+ Variables entity.JSONMap `json:"variables"`
+ CreateDate *string `json:"create_date"`
+ UpdateDate *string `json:"update_date"`
+ OperatorPermission int32 `json:"operator_permission,omitempty"`
}
// ListMCPServersResponse is the response payload for listing MCP servers.
@@ -120,11 +122,15 @@ func (s *MCPService) CreateMCPServer(ctx context.Context, userID string, req Cre
return nil, common.CodeDataError, errors.New("invalid url")
}
- tenantID, err := requireOwnedTenantID(ctx, userID)
+ tenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
code, normalized := permissionresponse.Normalize(err)
return nil, code, normalized
}
+ if err := checkFeatureAction(ctx, userID, "mcp", permission.ActionWrite); err != nil {
+ code, normalized := permissionresponse.Normalize(err)
+ return nil, code, normalized
+ }
name, err := common.UniqueName(req.Name, mcpServerNameLimit, func(candidate string) (bool, error) {
return s.mcpServerDAO.ExistsByNameAndTenant(ctx, dao.DB, candidate, tenantID)
@@ -155,7 +161,12 @@ func (s *MCPService) CreateMCPServer(ctx context.Context, userID string, req Cre
Headers: headers,
}
- if err = s.mcpServerDAO.CreateMCPServer(ctx, dao.DB, server); err != nil {
+ if err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.mcpServerDAO.CreateMCPServer(ctx, tx, server); err != nil {
+ return err
+ }
+ return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindMCPServer, server.ID)
+ }); err != nil {
return nil, common.CodeDataError, errors.New("failed to create MCP server")
}
@@ -533,7 +544,7 @@ func (s *MCPService) ListMCPServers(ctx context.Context, userID, requestedTenant
tenantID := strings.TrimSpace(requestedTenantID)
if tenantID == "" {
var err error
- tenantID, err = requireOwnedTenantID(ctx, userID)
+ tenantID, err = requireCurrentTenantID(ctx, userID)
if errors.Is(err, permission.ErrMembershipNotFound) {
return &ListMCPServersResponse{MCPServers: []*MCPServerListItem{}}, common.CodeSuccess, nil
}
@@ -560,20 +571,30 @@ func (s *MCPService) ListMCPServers(ctx context.Context, userID, requestedTenant
servers = paginateMCPServers(servers, page, pageSize)
items := make([]*MCPServerListItem, 0, len(servers))
+ checker := permission.NewDatabaseChecker(dao.DB)
for _, server := range servers {
+ access, err := checker.ResolveAccess(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{
+ Kind: permission.ResourceKindMCPServer,
+ ID: server.ID,
+ })
+ if err != nil {
+ code, normalized := normalizeMCPServerPermissionError(err)
+ return nil, code, normalized
+ }
variables := server.Variables
if variables == nil {
variables = entity.JSONMap{}
}
items = append(items, &MCPServerListItem{
- ID: server.ID,
- Name: server.Name,
- ServerType: server.ServerType,
- URL: server.URL,
- Description: server.Description,
- Variables: MCPVariablesForResponse(variables),
- CreateDate: formatMCPServerDate(server.CreateDate),
- UpdateDate: formatMCPServerDate(server.UpdateDate),
+ ID: server.ID,
+ Name: server.Name,
+ ServerType: server.ServerType,
+ URL: server.URL,
+ Description: server.Description,
+ Variables: MCPVariablesForResponse(variables),
+ CreateDate: formatMCPServerDate(server.CreateDate),
+ UpdateDate: formatMCPServerDate(server.UpdateDate),
+ OperatorPermission: access.PermissionMask,
})
}
@@ -684,11 +705,15 @@ type ImportResult struct {
// ImportServers bulk-imports MCP servers from a {"mcpServers": {name: config}} map.
func (s *MCPService) ImportServers(ctx context.Context, userID string, servers map[string]map[string]interface{}, timeoutSeconds float64) ([]ImportResult, error) {
- tenantID, err := requireOwnedTenantID(ctx, userID)
+ tenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
_, normalized := permissionresponse.Normalize(err)
return nil, normalized
}
+ if err := checkFeatureAction(ctx, userID, "mcp", permission.ActionWrite); err != nil {
+ _, normalized := permissionresponse.Normalize(err)
+ return nil, normalized
+ }
if timeoutSeconds <= 0 {
timeoutSeconds = defaultMCPFetchTimeoutSec
}
@@ -786,7 +811,12 @@ func (s *MCPService) ImportServers(ctx context.Context, userID string, servers m
Variables: entity.JSONMap(variables),
Headers: entity.JSONMap(headerVals),
}
- if err = s.mcpServerDAO.CreateMCPServer(ctx, dao.DB, server); err != nil {
+ if err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.mcpServerDAO.CreateMCPServer(ctx, tx, server); err != nil {
+ return err
+ }
+ return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindMCPServer, server.ID)
+ }); err != nil {
results = append(results, ImportResult{Server: serverName, Success: false, Message: "Failed to create MCP server."})
continue
}
diff --git a/internal/service/mcp_test.go b/internal/service/mcp_test.go
index c00f203380..a6727b96e9 100644
--- a/internal/service/mcp_test.go
+++ b/internal/service/mcp_test.go
@@ -325,6 +325,7 @@ func TestMCPServerPermissionsUsePolicyAcrossServiceOperations(t *testing.T) {
}).Error; err != nil {
t.Fatalf("create MCP member membership: %v", err)
}
+ addMCPOwnerMembership(t, db, "member", "member")
if err := db.Create(&entity.MCPServer{
ID: "team-server", Name: "shared", TenantID: "team", URL: "https://example.com/mcp",
ServerType: mcpServerTypeStreamableHTTP,
@@ -358,13 +359,14 @@ func TestMCPServerPermissionsUsePolicyAcrossServiceOperations(t *testing.T) {
}); err == nil || !errors.Is(err, permission.ErrPermissionDenied) {
t.Fatalf("member connection test should require update permission: %v", err)
}
- if _, code, err := service.CreateMCPServer(ctx, "member", CreateMCPServerRequest{
+ created, code, err := service.CreateMCPServer(ctx, "member", CreateMCPServerRequest{
Name: "new", URL: server.URL, ServerType: mcpServerTypeStreamableHTTP,
- }); err == nil || code != common.CodeForbidden {
- t.Fatalf("member create should require an owned tenant: code=%d err=%v", code, err)
+ })
+ if err != nil || code != common.CodeSuccess || created.TenantID != "member" {
+ t.Fatalf("member should create in their personal tenant without switching: result=%+v code=%d err=%v", created, code, err)
}
- if len(captured()) != 0 {
- t.Fatalf("denied connection/config operations made outbound requests: %d", len(captured()))
+ if len(captured()) == 0 {
+ t.Fatal("MCP creation did not discover tools from the configured server")
}
}
diff --git a/internal/service/memory.go b/internal/service/memory.go
index 92f6792003..e7f8c5e33a 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -490,25 +490,32 @@ func filterOptionsInOrder(counts map[string]int64, canonicalOrder []string) []Me
// req := &CreateMemoryRequest{Name: "MyMemory", MemoryType: []string{"semantic"}, EmbdID: "embd1", LLMID: "llm1"}
// resp, err := service.CreateMemory("tenant123", req)
func (s *MemoryService) CreateMemory(ctx context.Context, userID string, req *CreateMemoryRequest) (*CreateMemoryResponse, error) {
+ tenantID, err := requireCurrentTenantID(ctx, userID)
+ if err != nil {
+ return nil, err
+ }
+ if err := checkFeatureAction(ctx, userID, "memory", permission.ActionWrite); err != nil {
+ return nil, err
+ }
// Resolve tenant model IDs, mirroring Python's ensure_tenant_model_ids_for_params.
// Resolution failure is non-fatal (e.g. Builtin models that have no
// tenant_model row) — we leave the tenant_*_id fields nil and proceed.
modelFactory := NewModelFactory()
if req.LLMID != "" && req.TenantLLMID == nil {
- info, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: userID}, entity.ModelTypeChat, req.LLMID)
+ info, err := modelFactory.ResolveInfo(ctx, ModelAccess{UserID: userID, TenantID: tenantID}, entity.ModelTypeChat, req.LLMID)
if err != nil {
common.Warn("CreateMemory: failed to resolve tenant LLM id",
- zap.String("tenant_id", userID), zap.String("llm_id", req.LLMID), zap.Error(err))
+ zap.String("tenant_id", tenantID), zap.String("llm_id", req.LLMID), zap.Error(err))
} else if info != nil && info.ID != "" {
tenantLLMID := info.ID
req.TenantLLMID = &tenantLLMID
}
}
if req.EmbdID != "" && req.TenantEmbdID == nil {
- info, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: userID}, entity.ModelTypeEmbedding, req.EmbdID)
+ info, err := modelFactory.ResolveInfo(ctx, ModelAccess{UserID: userID, TenantID: tenantID}, entity.ModelTypeEmbedding, req.EmbdID)
if err != nil {
common.Warn("CreateMemory: failed to resolve tenant embedding id",
- zap.String("tenant_id", userID), zap.String("embd_id", req.EmbdID), zap.Error(err))
+ zap.String("tenant_id", tenantID), zap.String("embd_id", req.EmbdID), zap.Error(err))
} else if info != nil && info.ID != "" {
tenantEmbdID := info.ID
req.TenantEmbdID = &tenantEmbdID
@@ -538,8 +545,8 @@ func (s *MemoryService) CreateMemory(ctx context.Context, userID string, req *Cr
uniqueMemoryTypes = append(uniqueMemoryTypes, mt)
}
- memoryName, err := common.UniqueName(memoryName, MemoryNameLimit, func(candidate string) (bool, error) {
- existing, err := s.memoryDAO.GetByNameAndTenant(ctx, s.db, candidate, userID)
+ memoryName, err = common.UniqueName(memoryName, MemoryNameLimit, func(candidate string) (bool, error) {
+ existing, err := s.memoryDAO.GetByNameAndTenant(ctx, s.db, candidate, tenantID)
if err != nil {
return false, err
}
@@ -557,7 +564,7 @@ func (s *MemoryService) CreateMemory(ctx context.Context, userID string, req *Cr
memory := &entity.Memory{
ID: newID,
Name: memoryName,
- TenantID: userID,
+ TenantID: tenantID,
MemoryType: memoryTypeInt,
StorageType: "table",
EmbdID: req.EmbdID,
@@ -576,7 +583,12 @@ func (s *MemoryService) CreateMemory(ctx context.Context, userID string, req *Cr
if req.TenantLLMID != nil {
memory.TenantLLMID = req.TenantLLMID
}
- if err = s.memoryDAO.Create(ctx, s.db, memory); err != nil {
+ if err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.memoryDAO.Create(ctx, tx, memory); err != nil {
+ return err
+ }
+ return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindMemory, memory.ID)
+ }); err != nil {
return nil, errors.New("could not create new memory")
}
@@ -1665,26 +1677,35 @@ func (s *MemoryService) ListMemories(ctx context.Context, userID string, tenantI
memoryList := make([]map[string]interface{}, 0, len(memories))
modelNameCache := make(map[string]string)
+ checker := permission.NewDatabaseChecker(s.db)
for _, m := range memories {
+ access, err := checker.ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
+ Kind: permission.ResourceKindMemory,
+ ID: m.ID,
+ })
+ if err != nil {
+ return nil, err
+ }
resp := formatRetDataFromMemoryListItem(m)
var createDateStr *string
if resp.CreateTime != nil {
createDateStr = formatDateToString(*resp.CreateTime)
}
memoryMap := map[string]interface{}{
- "id": resp.ID,
- "llm_id": ResolveTenantModelDisplayName(ctx, s.db, ptrStringValue(resp.TenantLLMID), resp.LLMID, modelNameCache),
- "embd_id": ResolveTenantModelDisplayName(ctx, s.db, ptrStringValue(resp.TenantEmbdID), resp.EmbdID, modelNameCache),
- "name": resp.Name,
- "avatar": resp.Avatar,
- "tenant_id": resp.TenantID,
- "owner_name": resp.OwnerName,
- "memory_type": resp.MemoryType,
- "storage_type": resp.StorageType,
- "permissions": resp.Permissions,
- "description": resp.Description,
- "create_time": resp.CreateTime,
- "create_date": createDateStr,
+ "id": resp.ID,
+ "llm_id": ResolveTenantModelDisplayName(ctx, s.db, ptrStringValue(resp.TenantLLMID), resp.LLMID, modelNameCache),
+ "embd_id": ResolveTenantModelDisplayName(ctx, s.db, ptrStringValue(resp.TenantEmbdID), resp.EmbdID, modelNameCache),
+ "name": resp.Name,
+ "avatar": resp.Avatar,
+ "tenant_id": resp.TenantID,
+ "owner_name": resp.OwnerName,
+ "memory_type": resp.MemoryType,
+ "storage_type": resp.StorageType,
+ "permissions": resp.Permissions,
+ "operator_permission": access.PermissionMask,
+ "description": resp.Description,
+ "create_time": resp.CreateTime,
+ "create_date": createDateStr,
}
memoryList = append(memoryList, memoryMap)
}
@@ -1749,7 +1770,19 @@ func (s *MemoryService) GetMemoryConfig(ctx context.Context, userID, memoryID st
if _, err := s.memoryWithAccess(ctx, userID, memoryID, permission.OperationRead); err != nil {
return nil, err
}
- return s.getMemoryConfig(ctx, memoryID)
+ response, err := s.getMemoryConfig(ctx, memoryID)
+ if err != nil {
+ return nil, err
+ }
+ access, err := permission.NewDatabaseChecker(s.db).ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
+ Kind: permission.ResourceKindMemory,
+ ID: memoryID,
+ })
+ if err != nil {
+ return nil, err
+ }
+ response.OperatorPermission = access.PermissionMask
+ return response, nil
}
// getMemoryConfig retrieves the full configuration of a memory without access
diff --git a/internal/service/model_call.go b/internal/service/model_call.go
index 3c707b6c17..fb38ecc4ba 100644
--- a/internal/service/model_call.go
+++ b/internal/service/model_call.go
@@ -378,7 +378,7 @@ func populateModelUsage(usage *common.ModelUsage, info *modelModule.ModelInfo, a
}
func (s *ModelCallService) ownerTenantID(ctx context.Context, userID string) (string, error) {
- return requireOwnedTenantID(ctx, userID)
+ return requireCurrentTenantID(ctx, userID)
}
func (s *ModelCallService) resolveModelInfo(ctx context.Context, modelRef, userID string) (*ModelInstanceAndProviderInfo, error) {
diff --git a/internal/service/model_factory.go b/internal/service/model_factory.go
index 4f9cd26cb7..2a96c105a7 100644
--- a/internal/service/model_factory.go
+++ b/internal/service/model_factory.go
@@ -495,11 +495,25 @@ func (f *ModelFactory) resolveDefaultConfig(ctx context.Context, access ModelAcc
return nil, fmt.Errorf("%w: tenant DAO is not initialized", errModelConfigUnavailable)
}
- tenant, err := f.tenantDAO.GetByID(ctx, dao.DB, access.TenantID)
- if err != nil {
+ if _, err := f.tenantDAO.GetByID(ctx, dao.DB, access.TenantID); err != nil {
return nil, fmt.Errorf("failed to get tenant: %s type %s: %w", access.TenantID, modelType, err)
}
- modelName, modelID := defaultModelRefs(tenant, modelType)
+ membershipDAO := dao.NewUserTenantDAO()
+ var membership *entity.UserTenant
+ var err error
+ if access.UserID != "" {
+ membership, err = membershipDAO.FilterByUserIDAndTenantID(ctx, dao.DB, access.UserID, access.TenantID)
+ if err != nil && (access.UserID != access.TenantID || !errors.Is(err, gorm.ErrRecordNotFound)) {
+ return nil, fmt.Errorf("failed to get user tenant model settings: %s type %s: %w", access.TenantID, modelType, err)
+ }
+ }
+ if membership == nil {
+ membership, err = membershipDAO.GetOwnerByTenantID(ctx, dao.DB, access.TenantID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get tenant owner model settings: %s type %s: %w", access.TenantID, modelType, err)
+ }
+ }
+ modelName, modelID := defaultModelRefs(membership, modelType)
if modelID != "" {
return f.resolveConfigAuthorized(ctx, access, modelType, modelID)
}
@@ -509,27 +523,27 @@ func (f *ModelFactory) resolveDefaultConfig(ctx context.Context, access ModelAcc
return f.resolveConfigAuthorized(ctx, access, modelType, modelName)
}
-func defaultModelRefs(tenant *entity.Tenant, modelType entity.ModelType) (string, string) {
- if tenant == nil {
+func defaultModelRefs(membership *entity.UserTenant, modelType entity.ModelType) (string, string) {
+ if membership == nil {
return "", ""
}
switch modelType {
case entity.ModelTypeChat:
- return tenant.LLMID, ptrStringValue(tenant.TenantLLMID)
+ return membership.LLMID, ptrStringValue(membership.TenantLLMID)
case entity.ModelTypeEmbedding:
- return tenant.EmbdID, ptrStringValue(tenant.TenantEmbdID)
+ return membership.EmbdID, ptrStringValue(membership.TenantEmbdID)
case entity.ModelTypeRerank:
- return tenant.RerankID, ptrStringValue(tenant.TenantRerankID)
+ return membership.RerankID, ptrStringValue(membership.TenantRerankID)
case entity.ModelTypeSpeech2Text:
- return tenant.ASRID, ptrStringValue(tenant.TenantASRID)
+ return membership.ASRID, ptrStringValue(membership.TenantASRID)
case entity.ModelTypeImage2Text:
- return tenant.Img2TxtID, ptrStringValue(tenant.TenantImg2TxtID)
+ return membership.Img2TxtID, ptrStringValue(membership.TenantImg2TxtID)
case entity.ModelTypeTTS:
- return ptrStringValue(tenant.TTSID), ptrStringValue(tenant.TenantTTSID)
+ return ptrStringValue(membership.TTSID), ptrStringValue(membership.TenantTTSID)
case entity.ModelTypeOCR:
- return ptrStringValue(tenant.OCRID), ptrStringValue(tenant.TenantOCRID)
+ return ptrStringValue(membership.OCRID), ptrStringValue(membership.TenantOCRID)
case entity.ModelTypeDecision:
- return ptrStringValue(tenant.DecisionID), ptrStringValue(tenant.TenantDecisionID)
+ return ptrStringValue(membership.DecisionID), ptrStringValue(membership.TenantDecisionID)
default:
return "", ""
}
diff --git a/internal/service/model_factory_decision_test.go b/internal/service/model_factory_decision_test.go
index 39f10fcb28..57a2d0f166 100644
--- a/internal/service/model_factory_decision_test.go
+++ b/internal/service/model_factory_decision_test.go
@@ -51,9 +51,9 @@ func TestModelTypesFromBitmaskIncludesDecision(t *testing.T) {
func TestDefaultModelRefsIncludesDecision(t *testing.T) {
name := "minimax-m3@cbn@OpenAI-API-Compatible"
rowID := "d806c1155725406b840821e9e2897f01"
- tenant := &entity.Tenant{DecisionID: &name, TenantDecisionID: &rowID}
+ membership := &entity.UserTenant{DecisionID: &name, TenantDecisionID: &rowID}
- gotName, gotID := defaultModelRefs(tenant, entity.ModelTypeDecision)
+ gotName, gotID := defaultModelRefs(membership, entity.ModelTypeDecision)
if gotName != name {
t.Errorf("name = %q, want %q", gotName, name)
}
@@ -62,6 +62,6 @@ func TestDefaultModelRefsIncludesDecision(t *testing.T) {
}
if n, id := defaultModelRefs(nil, entity.ModelTypeDecision); n != "" || id != "" {
- t.Errorf("nil tenant = (%q, %q), want empty", n, id)
+ t.Errorf("nil membership = (%q, %q), want empty", n, id)
}
}
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index 1077e84246..e9786f54f4 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -17,6 +17,7 @@
package service
import (
+ "bytes"
"context"
"encoding/binary"
"encoding/json"
@@ -29,6 +30,7 @@ import (
modelModule "ragflow/internal/entity/models"
"ragflow/internal/permission"
permissionresponse "ragflow/internal/permission/response"
+ "regexp"
"sort"
"strings"
@@ -99,7 +101,11 @@ type CheckConnectionRequest struct {
func (m *ModelProviderService) AddModelProvider(ctx context.Context, providerName, userID string) (common.ErrorCode, error) {
providerName = strings.TrimSpace(providerName)
- tenantID, err := requireOwnedTenantID(ctx, userID)
+ if err := checkFeatureAction(ctx, userID, "model_provider", permission.ActionEnable); err != nil {
+ code, normalizedErr := normalizeModelPermissionError(err)
+ return code, normalizedErr
+ }
+ tenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
code, normalizedErr := normalizeModelPermissionError(err)
return code, normalizedErr
@@ -129,7 +135,7 @@ func (m *ModelProviderService) AddModelProvider(ctx context.Context, providerNam
}
func (m *ModelProviderService) ListProvidersOfTenant(ctx context.Context, userID string) ([]map[string]interface{}, common.ErrorCode, error) {
- ownedTenantID, err := requireOwnedTenantID(ctx, userID)
+ ownedTenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
if errors.Is(err, permission.ErrMembershipNotFound) {
return []map[string]interface{}{}, common.CodeSuccess, nil
@@ -278,7 +284,7 @@ func (m *ModelProviderService) DeleteModelProvider(ctx context.Context, userID,
func (m *ModelProviderService) ListSupportedModels(ctx context.Context, providerName, instanceName, userID string) ([]map[string]interface{}, error) {
providerName = strings.TrimSpace(providerName)
- ownedTenantID, err := requireOwnedTenantID(ctx, userID)
+ ownedTenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
if permissionresponse.IsPermissionError(err) {
_, normalizedErr := normalizeModelPermissionError(err)
@@ -362,6 +368,67 @@ type CreateInstanceModelInfo struct {
Extra map[string]interface{} `json:"extra"`
}
+var providerInstanceNamePattern = regexp.MustCompile(`^[0-9A-Za-z_-]+$`)
+
+// ValidateProviderInstanceName checks the name accepted by provider APIs.
+func ValidateProviderInstanceName(instanceName string) error {
+ if strings.TrimSpace(instanceName) == "" {
+ return errors.New("instance name is required")
+ }
+ if !providerInstanceNamePattern.MatchString(instanceName) {
+ return errors.New("instance name may only contain digits, underscores, hyphens, and letters")
+ }
+ return nil
+}
+
+type CreateProviderInstanceRequest struct {
+ InstanceName string `json:"instance_name" binding:"required"`
+ APIKey json.RawMessage `json:"api_key"`
+ BaseURL string `json:"base_url"`
+ Region string `json:"region"`
+ ModelInfo []CreateInstanceModelInfo `json:"model_info"`
+}
+
+type AlterProviderInstanceRequest struct {
+ InstanceName string `json:"instance_name"`
+ APIKey json.RawMessage `json:"api_key"`
+ BaseURL string `json:"base_url"`
+ Region string `json:"region"`
+ ModelInfo *[]CreateInstanceModelInfo `json:"model_info" binding:"required"`
+}
+
+type DropProviderInstanceRequest struct {
+ Instances []string `json:"instances" binding:"required,min=1,dive,required"`
+}
+
+type AlterModelRequest struct {
+ ModelID string `json:"model_id"`
+ Status string `json:"status"`
+ MaxTokens int `json:"max_tokens"`
+ ModelType interface{} `json:"model_type"`
+ Extra interface{} `json:"extra"`
+}
+
+type DropInstanceModelRequest struct {
+ ModelNames []string `json:"model_name"`
+}
+
+func NormalizeAPIKey(raw json.RawMessage) string {
+ trimmed := strings.TrimSpace(string(raw))
+ if trimmed == "" || trimmed == "null" {
+ return ""
+ }
+ var value string
+ if err := json.Unmarshal(raw, &value); err == nil {
+ return value
+ }
+ var compact bytes.Buffer
+ if err := json.Compact(&compact, raw); err != nil {
+ return trimmed
+ }
+ return compact.String()
+}
+
func (m *ModelProviderService) getProviderByIDOrName(ctx context.Context, userID, providerIDOrName string, operation permission.Operation) (*entity.TenantModelProvider, error) {
providerIDOrName = strings.TrimSpace(providerIDOrName)
if providerIDOrName == "" {
@@ -450,7 +517,14 @@ func (m *ModelProviderService) CreateProviderInstance(ctx context.Context, provi
Status: "active",
Extra: extraStr,
}
- err = m.modelInstanceDAO.Create(ctx, dao.DB, tenantModelInstance)
+ err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := m.modelInstanceDAO.Create(ctx, tx, tenantModelInstance); err != nil {
+ return err
+ }
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{
+ Kind: permission.ResourceKindModelInstance, ID: tenantModelInstance.ID,
+ })
+ })
if err != nil {
return common.CodeServerError, fmt.Errorf("fail to create model instance: %w", err)
}
@@ -551,7 +625,14 @@ func (m *ModelProviderService) CreateNameOnlyProviderInstance(ctx context.Contex
Status: "active",
Extra: "{}",
}
- err = m.modelInstanceDAO.Create(ctx, dao.DB, tenantModelInstance)
+ err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := m.modelInstanceDAO.Create(ctx, tx, tenantModelInstance); err != nil {
+ return err
+ }
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: provider.TenantID}, permission.ResourceRef{
+ Kind: permission.ResourceKindModelInstance, ID: tenantModelInstance.ID,
+ })
+ })
if err != nil {
return common.CodeServerError, fmt.Errorf("fail to create model instance: %w", err)
}
@@ -623,7 +704,7 @@ func (m *ModelProviderService) createModelRecord(ctx context.Context, db *gorm.D
func (m *ModelProviderService) ListProviderInstances(ctx context.Context, providerIDOrName, userID string) ([]map[string]interface{}, common.ErrorCode, error) {
providerIDOrName = strings.TrimSpace(providerIDOrName)
- ownedTenantID, err := requireOwnedTenantID(ctx, userID)
+ ownedTenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
if errors.Is(err, permission.ErrMembershipNotFound) {
return []map[string]interface{}{}, common.CodeSuccess, nil
@@ -665,10 +746,19 @@ func (m *ModelProviderService) ListProviderInstances(ctx context.Context, provid
// web/src/pages/user-setting/setting-model/...) and would otherwise
// crash on a freshly created tenant.
result := make([]map[string]interface{}, 0, len(instances))
+ checker := permission.NewDatabaseChecker(dao.DB)
for _, instance := range instances {
if _, ok := accessibleInstances[instance.ID]; !ok {
continue
}
+ access, accessErr := checker.ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
+ Kind: permission.ResourceKindModelInstance,
+ ID: instance.ID,
+ })
+ if accessErr != nil {
+ code, normalizedErr := normalizeModelPermissionError(accessErr)
+ return nil, code, normalizedErr
+ }
// Parse extra to extract region
var extraFields map[string]string
if instance.Extra != "" {
@@ -684,11 +774,12 @@ func (m *ModelProviderService) ListProviderInstances(ctx context.Context, provid
// list_provider_instances response shape
// (provider_api_service.py:563).
result = append(result, map[string]interface{}{
- "id": instance.ID,
- "instance_name": instance.InstanceName,
- "provider_id": instance.ProviderID,
- "region": extraFields["region"],
- "status": instance.Status,
+ "id": instance.ID,
+ "instance_name": instance.InstanceName,
+ "provider_id": instance.ProviderID,
+ "region": extraFields["region"],
+ "status": instance.Status,
+ "operator_permission": access.PermissionMask,
})
}
@@ -698,7 +789,7 @@ func (m *ModelProviderService) ListProviderInstances(ctx context.Context, provid
func (m *ModelProviderService) ShowProviderInstance(ctx context.Context, providerName, instanceIDOrName, userID string) (map[string]interface{}, common.ErrorCode, error) {
providerName = strings.TrimSpace(providerName)
- ownedTenantID, err := requireOwnedTenantID(ctx, userID)
+ ownedTenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
@@ -709,7 +800,8 @@ func (m *ModelProviderService) ShowProviderInstance(ctx context.Context, provide
provider, err := m.findProviderByIDOrNameInTenant(ctx, ownedTenantID, providerName)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, common.CodeDataError, fmt.Errorf("no provider found for provider '%s'", providerName)
+ code, normalizedErr := normalizeModelPermissionError(permission.ErrResourceNotFound)
+ return nil, code, normalizedErr
}
return nil, common.CodeServerError, err
}
@@ -727,7 +819,14 @@ func (m *ModelProviderService) ShowProviderInstance(ctx context.Context, provide
if err != nil {
return nil, common.CodeDataError, fmt.Errorf("no instance found for provider '%s' and instance '%s'", providerName, instanceIDOrName)
}
- if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationRead); err != nil {
+ access, err := permission.NewDatabaseChecker(dao.DB).ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
+ Kind: permission.ResourceKindModelInstance,
+ ID: instance.ID,
+ })
+ if err != nil || !access.Allows(permission.OperationRead) {
+ if err == nil {
+ err = permission.ErrPermissionDenied
+ }
code, normalizedErr := normalizeModelPermissionError(err)
return nil, code, normalizedErr
}
@@ -750,9 +849,11 @@ func (m *ModelProviderService) ShowProviderInstance(ctx context.Context, provide
"provider_id": provider.ID,
"region": extraFields["region"],
"base_url": extraFields["base_url"],
- "api_key": instance.APIKey,
"status": instance.Status,
}
+ if access.Source == permission.AccessSourceOwner {
+ result["api_key"] = instance.APIKey
+ }
return result, common.CodeSuccess, nil
}
@@ -1629,7 +1730,7 @@ func (m *ModelProviderService) resolveModelListTenant(ctx context.Context, userI
tenantID := requestedTenantID
if tenantID == "" {
var err error
- tenantID, err = requireOwnedTenantID(ctx, userID)
+ tenantID, err = requireCurrentTenantID(ctx, userID)
if err != nil {
if errors.Is(err, permission.ErrMembershipNotFound) {
return nil, common.CodeSuccess, nil
@@ -2188,7 +2289,7 @@ func (m *ModelProviderService) DropInstanceModels(ctx context.Context, providerI
}
func (m *ModelProviderService) ListInstanceModels(ctx context.Context, providerName, instanceName, userID string) ([]map[string]interface{}, error) {
- ownedTenantID, err := requireOwnedTenantID(ctx, userID)
+ ownedTenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
if permissionresponse.IsPermissionError(err) {
_, normalizedErr := normalizeModelPermissionError(err)
diff --git a/internal/service/model_service_test.go b/internal/service/model_service_test.go
index 67c67f0a57..a60f6145cb 100644
--- a/internal/service/model_service_test.go
+++ b/internal/service/model_service_test.go
@@ -319,8 +319,8 @@ func seedModelProviderServiceScope(t *testing.T, db *gorm.DB) {
t.Helper()
activeStatus := "1"
rows := []interface{}{
- &entity.UserTenant{ID: "user-tenant-1", UserID: "user-1", TenantID: "tenant-1", Role: "owner", InvitedBy: "user-1", Status: &activeStatus},
- &entity.TenantModelProvider{ID: "provider-1", UserID: "user-1", TenantID: "tenant-1", ProviderName: "OpenAI"},
+ &entity.UserTenant{ID: "user-tenant-1", UserID: "user-1", TenantID: "user-1", Role: "owner", InvitedBy: "user-1", Status: &activeStatus},
+ &entity.TenantModelProvider{ID: "provider-1", UserID: "user-1", TenantID: "user-1", ProviderName: "OpenAI"},
&entity.TenantModelInstance{ID: "instance-1", ProviderID: "provider-1", InstanceName: "default", APIKey: "sk-test", Status: "active", Extra: "{}"},
&entity.TenantModel{ID: "model-1", ProviderID: "provider-1", InstanceID: "instance-1", ModelName: "gpt-test", ModelType: int(entity.ModelTypeChat), Status: "active"},
}
@@ -485,13 +485,19 @@ func TestModelPermissionsAllowMemberUseButHideInstanceConfiguration(t *testing.T
if err := db.Create(&entity.UserTenant{
ID: "user-tenant-member",
UserID: "member-1",
- TenantID: "tenant-1",
+ TenantID: "user-1",
Role: string(permission.RoleNormal),
InvitedBy: "user-1",
Status: &activeStatus,
}).Error; err != nil {
t.Fatalf("seed tenant member: %v", err)
}
+ if err := db.Create(&entity.UserTenant{
+ ID: "member-1-owner", UserID: "member-1", TenantID: "member-1",
+ Role: string(permission.RoleOwner), InvitedBy: "member-1", Status: &activeStatus,
+ }).Error; err != nil {
+ t.Fatalf("seed member's personal tenant: %v", err)
+ }
ctx := t.Context()
service := NewModelProviderService()
@@ -505,7 +511,7 @@ func TestModelPermissionsAllowMemberUseButHideInstanceConfiguration(t *testing.T
}
factory := NewModelFactory()
- access := ModelAccess{UserID: "member-1", TenantID: "tenant-1"}
+ access := ModelAccess{UserID: "member-1", TenantID: "user-1"}
if _, err = factory.resolveConfig(ctx, access, entity.ModelTypeChat, "model-1"); err != nil {
t.Fatalf("member should be able to use the tenant model: %v", err)
}
@@ -642,8 +648,11 @@ func TestShowProviderInstanceUsesOwnedTenantProvider(t *testing.T) {
if instance["id"] != "instance-1" || instance["provider_id"] != "provider-1" {
t.Fatalf("ShowProviderInstance() = %v, want user-1's own-tenant instance", instance)
}
+ if instance["api_key"] != "sk-test" {
+ t.Fatalf("ShowProviderInstance() api_key = %v, want owner credential", instance["api_key"])
+ }
- if _, code, err = service.ShowProviderInstance(t.Context(), "provider-2", "instance-2", "user-1"); err == nil || code != common.CodeDataError {
+ if _, code, err = service.ShowProviderInstance(t.Context(), "provider-2", "instance-2", "user-1"); err == nil || code != common.CodeNotFound {
t.Fatalf("ShowProviderInstance() for another tenant's provider = (%v, %v), want hidden provider", code, err)
}
}
@@ -688,7 +697,7 @@ func TestModelFactoryResolveModelConfigByID(t *testing.T) {
seedModelProviderServiceScope(t, db)
ctx := t.Context()
- target, err := NewModelFactory().resolveConfig(ctx, ModelAccess{TenantID: "tenant-1", UserID: "user-1"}, entity.ModelTypeChat, "model-1")
+ target, err := NewModelFactory().resolveConfig(ctx, ModelAccess{TenantID: "user-1", UserID: "user-1"}, entity.ModelTypeChat, "model-1")
if err != nil {
t.Fatalf("resolveConfig() error = %v", err)
}
@@ -748,13 +757,13 @@ func TestModelProviderServiceDecodesCompatibleInstanceExtra(t *testing.T) {
{
name: "model ID",
resolve: func() (*modelTarget, error) {
- return solver.resolveConfig(t.Context(), ModelAccess{TenantID: "tenant-1", UserID: "user-1"}, entity.ModelTypeChat, "model-1")
+ return solver.resolveConfig(t.Context(), ModelAccess{TenantID: "user-1", UserID: "user-1"}, entity.ModelTypeChat, "model-1")
},
},
{
name: "provider instance",
resolve: func() (*modelTarget, error) {
- return solver.resolveConfig(t.Context(), ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, "gpt-test@default@OpenAI")
+ return solver.resolveConfig(t.Context(), ModelAccess{TenantID: "user-1"}, entity.ModelTypeChat, "gpt-test@default@OpenAI")
},
},
}
diff --git a/internal/service/model_service_tts_test.go b/internal/service/model_service_tts_test.go
index 17cc57c79f..a52cb44c1e 100644
--- a/internal/service/model_service_tts_test.go
+++ b/internal/service/model_service_tts_test.go
@@ -33,14 +33,17 @@ func insertTTSTestTenant(t *testing.T, id string, ttsID *string) {
row := &entity.Tenant{
ID: id,
Name: &name,
- LLMID: "glm-4-flash@ZHIPU-AI",
- EmbdID: "BAAI/bge-m3@ZHIPU-AI",
- TTSID: ttsID,
ParserIDs: "naive",
}
if err := dao.DB.Create(row).Error; err != nil {
t.Fatalf("insert test tenant: %v", err)
}
+ if err := dao.DB.Create(&entity.UserTenant{
+ ID: "owner-" + id, UserID: id, TenantID: id, Role: "owner", Status: sptr(string(entity.StatusValid)),
+ LLMID: "glm-4-flash@ZHIPU-AI", EmbdID: "BAAI/bge-m3@ZHIPU-AI", TTSID: ttsID,
+ }).Error; err != nil {
+ t.Fatalf("insert test owner membership: %v", err)
+ }
}
// TestAudioSpeech_NoSelectionNoDefaultTTS covers the agent Message
diff --git a/internal/service/model_stored_provider_name_test.go b/internal/service/model_stored_provider_name_test.go
index 244b49bbf5..abfcd9f157 100644
--- a/internal/service/model_stored_provider_name_test.go
+++ b/internal/service/model_stored_provider_name_test.go
@@ -37,8 +37,8 @@ func seedStoredMistralOCRProvider(t *testing.T, db *gorm.DB) {
t.Helper()
activeStatus := "1"
rows := []interface{}{
- &entity.UserTenant{ID: "user-tenant-1", UserID: "user-1", TenantID: "tenant-1", Role: "owner", InvitedBy: "user-1", Status: &activeStatus},
- &entity.TenantModelProvider{ID: "provider-mistral-ocr", UserID: "user-1", TenantID: "tenant-1", ProviderName: "Mistral OCR"},
+ &entity.UserTenant{ID: "user-tenant-1", UserID: "user-1", TenantID: "user-1", Role: "owner", InvitedBy: "user-1", Status: &activeStatus},
+ &entity.TenantModelProvider{ID: "provider-mistral-ocr", UserID: "user-1", TenantID: "user-1", ProviderName: "Mistral OCR"},
&entity.TenantModelInstance{ID: "instance-mistral-ocr", ProviderID: "provider-mistral-ocr", InstanceName: "default", APIKey: mistralOCRStoredKey, Status: "active", Extra: "{}"},
&entity.TenantModel{ID: "model-mistral-ocr", ProviderID: "provider-mistral-ocr", InstanceID: "instance-mistral-ocr", ModelName: "mistral-ocr-latest", ModelType: int(entity.ModelTypeOCR), Status: "active"},
}
@@ -58,7 +58,7 @@ func TestModelFactoryResolvesStoredMistralOCRProvider(t *testing.T) {
useModelProviderServiceTestDB(t, db)
seedStoredMistralOCRProvider(t, db)
- access := ModelAccess{TenantID: "tenant-1", UserID: "user-1"}
+ access := ModelAccess{TenantID: "user-1", UserID: "user-1"}
for _, tc := range []struct {
name string
modelRef string
@@ -96,7 +96,7 @@ func TestModelFactoryResolveModelTypeForStoredMistralOCRProvider(t *testing.T) {
useModelProviderServiceTestDB(t, db)
seedStoredMistralOCRProvider(t, db)
- types, err := NewModelFactory().ResolveModelType(t.Context(), ModelAccess{TenantID: "tenant-1", UserID: "user-1"}, "mistral-ocr-2512@default@Mistral OCR")
+ types, err := NewModelFactory().ResolveModelType(t.Context(), ModelAccess{TenantID: "user-1", UserID: "user-1"}, "mistral-ocr-2512@default@Mistral OCR")
if err != nil {
t.Fatalf("ResolveModelType: %v", err)
}
@@ -148,7 +148,7 @@ func TestListProvidersOfTenantSkipsStoredMistralOCRProvider(t *testing.T) {
db := setupModelProviderServiceTestDB(t)
useModelProviderServiceTestDB(t, db)
seedStoredMistralOCRProvider(t, db)
- if err := db.Create(&entity.TenantModelProvider{ID: "provider-openai", UserID: "user-1", TenantID: "tenant-1", ProviderName: "OpenAI"}).Error; err != nil {
+ if err := db.Create(&entity.TenantModelProvider{ID: "provider-openai", UserID: "user-1", TenantID: "user-1", ProviderName: "OpenAI"}).Error; err != nil {
t.Fatalf("create provider: %v", err)
}
diff --git a/internal/service/operator_permission.go b/internal/service/operator_permission.go
new file mode 100644
index 0000000000..5d291a7c84
--- /dev/null
+++ b/internal/service/operator_permission.go
@@ -0,0 +1,22 @@
+package service
+
+import (
+ "context"
+
+ "ragflow/internal/dao"
+ "ragflow/internal/permission"
+)
+
+// ResolveOperatorPermission returns the caller's resource permission mask.
+// Feature-role limits are intentionally excluded from this value.
+func ResolveOperatorPermission(ctx context.Context, userID string, resource permission.ResourceRef) (int32, error) {
+ access, err := permission.NewDatabaseChecker(dao.DB).ResolveAccess(
+ ctx,
+ permission.Subject{UserID: userID},
+ resource,
+ )
+ if err != nil {
+ return 0, err
+ }
+ return access.PermissionMask, nil
+}
diff --git a/internal/service/related_question.go b/internal/service/related_question.go
index 6f3bcf3673..973f7f6eb0 100644
--- a/internal/service/related_question.go
+++ b/internal/service/related_question.go
@@ -92,7 +92,7 @@ func relatedQuestionsModelID(ctx context.Context, tenantID string, searchConfig
if modelID != "" || tenantSvc == nil {
return modelID
}
- defaultModel, err := tenantSvc.GetDefaultModelName(ctx, tenantID, entity.ModelTypeChat)
+ defaultModel, err := tenantSvc.GetDefaultModelNameForTenant(ctx, tenantID, entity.ModelTypeChat)
if err == nil {
modelID = defaultModel
}
diff --git a/internal/service/search.go b/internal/service/search.go
index 668009621e..863b5b8ac9 100644
--- a/internal/service/search.go
+++ b/internal/service/search.go
@@ -21,6 +21,7 @@ import (
"fmt"
"strings"
+ "gorm.io/gorm"
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
@@ -92,8 +93,17 @@ func (s *SearchService) ListSearches(ctx context.Context, userID string, keyword
// Convert to response format
searchApps := make([]map[string]interface{}, len(searches))
+ checker := permission.NewDatabaseChecker(dao.DB)
for i, search := range searches {
+ access, err := checker.ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
+ Kind: permission.ResourceKindSearchApp,
+ ID: search.ID,
+ })
+ if err != nil {
+ return nil, err
+ }
searchApps[i] = s.toSearchAppResponse(search)
+ searchApps[i]["operator_permission"] = access.PermissionMask
}
return &ListSearchAppsResponse{
@@ -144,6 +154,13 @@ type CreateSearchResponse struct {
// 6. Save to database within DB.atomic() transaction
// 7. Return {search_id: id} on success
func (s *SearchService) CreateSearch(ctx context.Context, userID string, name string, description *string) (*CreateSearchResponse, error) {
+ tenantID, err := requireCurrentTenantID(ctx, userID)
+ if err != nil {
+ return nil, err
+ }
+ if err := checkFeatureAction(ctx, userID, "search", permission.ActionWrite); err != nil {
+ return nil, err
+ }
if err := common.ValidateName(name); err != nil {
return nil, err
}
@@ -154,7 +171,7 @@ func (s *SearchService) CreateSearch(ctx context.Context, userID string, name st
// Generate unique name (same as Python duplicate_name)
// search.name is a 128-byte column; keep generated names within it.
uniqueName, err := common.UniqueName(name, 128, func(candidate string) (bool, error) {
- existing, err := s.searchDAO.GetByNameAndTenant(ctx, dao.DB, candidate, userID)
+ existing, err := s.searchDAO.GetByNameAndTenant(ctx, dao.DB, candidate, tenantID)
if err != nil {
return false, err
}
@@ -168,7 +185,7 @@ func (s *SearchService) CreateSearch(ctx context.Context, userID string, name st
// Create search entity
search := &entity.Search{
ID: searchID,
- TenantID: userID,
+ TenantID: tenantID,
Name: uniqueName,
CreatedBy: userID,
SearchConfig: make(entity.JSONMap),
@@ -183,7 +200,12 @@ func (s *SearchService) CreateSearch(ctx context.Context, userID string, name st
search.Status = &status
// Save to database
- if err = s.searchDAO.Create(ctx, dao.DB, search); err != nil {
+ if err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.searchDAO.Create(ctx, tx, search); err != nil {
+ return err
+ }
+ return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindSearchApp, search.ID)
+ }); err != nil {
return nil, fmt.Errorf("failed to create search: %w", err)
}
@@ -587,6 +609,14 @@ func (s *SearchService) GetDetail(ctx context.Context, userID, searchID string)
"update_time": search.UpdateTime,
"search_config": map[string]interface{}(search.SearchConfig),
}
+ access, err := permission.NewDatabaseChecker(dao.DB).ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
+ Kind: permission.ResourceKindSearchApp,
+ ID: search.ID,
+ })
+ if err != nil {
+ return nil, err
+ }
+ result["operator_permission"] = access.PermissionMask
if search.Avatar != nil {
result["avatar"] = *search.Avatar
diff --git a/internal/service/skill_space.go b/internal/service/skill_space.go
index 46ed6c862c..c31edf6aec 100644
--- a/internal/service/skill_space.go
+++ b/internal/service/skill_space.go
@@ -29,6 +29,7 @@ import (
"time"
"go.uber.org/zap"
+ "gorm.io/gorm"
)
// SkillSpaceService handles business logic for skills space operations
@@ -152,11 +153,24 @@ func (s *SkillSpaceService) CreateSpace(ctx context.Context, userID string, req
if req.Name == "" {
return nil, common.CodeDataError, fmt.Errorf("space name is required")
}
- tenantID, err := requireOwnedTenantID(ctx, userID)
+ tenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
code, normalized := normalizeSkillSpacePermissionError(err)
return nil, code, normalized
}
+ if err := checkFeatureAction(ctx, userID, "file", permission.ActionWrite); err != nil {
+ code, normalized := normalizeSkillSpacePermissionError(err)
+ return nil, code, normalized
+ }
+ defaultEmbdID := req.EmbdID
+ if defaultEmbdID == "" {
+ defaultEmbdID, _, err = NewTenantService().GetDefaultModelRefsForUser(ctx, userID, tenantID, entity.ModelTypeEmbedding)
+ if err != nil {
+ common.Error("Failed to resolve default embedding model for skill space", err,
+ zap.String("tenantID", tenantID), zap.String("userID", userID))
+ return nil, common.CodeOperatingError, fmt.Errorf("failed to resolve default embedding model: %w", err)
+ }
+ }
// Tenant-scoped serialization to prevent concurrent create/delete races
tenantKey := tenantID + ":" + req.Name
@@ -237,11 +251,6 @@ func (s *SkillSpaceService) CreateSpace(ctx context.Context, userID string, req
SourceType: "skill_space",
}
- if err = s.fileDAO.Create(ctx, dao.DB, folder); err != nil {
- common.Error("Failed to create space folder", err)
- return nil, common.CodeOperatingError, fmt.Errorf("failed to create space folder: %w", err)
- }
-
// Create the space
space := &entity.SkillSpace{
ID: spaceID,
@@ -255,23 +264,28 @@ func (s *SkillSpaceService) CreateSpace(ctx context.Context, userID string, req
Status: "1",
}
- if err = s.spaceDAO.Create(ctx, dao.DB, space); err != nil {
- // Rollback: delete the created folder
- common.Error("Failed to create space in database", err)
- s.fileDAO.DeleteByIDs(ctx, dao.DB, []string{folderID})
- return nil, common.CodeOperatingError, fmt.Errorf("failed to create space: %w", err)
+ if err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := s.fileDAO.Create(ctx, tx, folder); err != nil {
+ return fmt.Errorf("failed to create space folder: %w", err)
+ }
+ if err := s.spaceDAO.Create(ctx, tx, space); err != nil {
+ return fmt.Errorf("failed to create space: %w", err)
+ }
+ checker := permission.NewDatabaseChecker(tx)
+ if err := checker.GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindFolder, ID: folderID}); err != nil {
+ return err
+ }
+ return checker.GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindSkillSpace, ID: spaceID})
+ }); err != nil {
+ common.Error("Failed to create skill space", err)
+ return nil, common.CodeOperatingError, err
}
// Create default search config for this space
- defaultEmbdID := req.EmbdID
- if defaultEmbdID == "" {
- tenant, err := s.tenantDAO.GetByID(ctx, dao.DB, tenantID)
- if err == nil && tenant != nil && tenant.EmbdID != "" {
- defaultEmbdID = tenant.EmbdID
- common.Info("Using tenant default embedding model", zap.String("tenantID", tenantID), zap.String("embdID", defaultEmbdID))
- } else {
- common.Warn("Tenant has no default embedding model, skill search will not work until configured", zap.String("tenantID", tenantID))
- }
+ if req.EmbdID == "" && defaultEmbdID != "" {
+ common.Info("Using tenant member default embedding model", zap.String("tenantID", tenantID), zap.String("embdID", defaultEmbdID))
+ } else if defaultEmbdID == "" {
+ common.Warn("Tenant has no default embedding model, skill search will not work until configured", zap.String("tenantID", tenantID))
}
if defaultEmbdID != "" {
if _, err := s.configDAO.GetOrCreate(ctx, dao.DB, tenantID, spaceID, defaultEmbdID); err != nil {
diff --git a/internal/service/skill_space_permission.go b/internal/service/skill_space_permission.go
index 15b091a510..671f45ad27 100644
--- a/internal/service/skill_space_permission.go
+++ b/internal/service/skill_space_permission.go
@@ -27,7 +27,7 @@ import (
func resolveSkillSpaceTenantID(ctx context.Context, userID, spaceID string, operation permission.Operation) (string, error) {
spaceID = normalizeSpaceID(spaceID)
if spaceID == defaultSkillSpaceID {
- return requireOwnedTenantID(ctx, userID)
+ return requireCurrentTenantID(ctx, userID)
}
checker := permission.NewDatabaseChecker(dao.DB)
diff --git a/internal/service/skill_space_permission_test.go b/internal/service/skill_space_permission_test.go
index ce8c010bec..0d2540cf0e 100644
--- a/internal/service/skill_space_permission_test.go
+++ b/internal/service/skill_space_permission_test.go
@@ -35,6 +35,7 @@ func TestSkillSpacePermissionsUsePolicyAcrossServiceOperations(t *testing.T) {
for _, membership := range []entity.UserTenant{
{ID: "skill-owner-membership", UserID: "owner", TenantID: "team", Role: string(permission.RoleOwner), Status: &active},
{ID: "skill-member-membership", UserID: "member", TenantID: "team", Role: string(permission.RoleNormal), InvitedBy: "owner", Status: &active},
+ {ID: "skill-member-personal-owner", UserID: "member", TenantID: "member", Role: string(permission.RoleOwner), InvitedBy: "member", Status: &active},
{ID: "skill-outsider-membership", UserID: "outsider", TenantID: "other", Role: string(permission.RoleOwner), Status: &active},
} {
if err := db.Create(&membership).Error; err != nil {
@@ -81,11 +82,12 @@ func TestSkillSpacePermissionsUsePolicyAcrossServiceOperations(t *testing.T) {
t.Fatalf("outsider read should be hidden: code=%d err=%v", code, err)
}
- if _, code, err := service.CreateSpace(ctx, "member", &CreateSpaceRequest{Name: "denied"}); err == nil || code != common.CodeNotFound {
- t.Fatalf("member create should require owner membership: code=%d err=%v", code, err)
+ created, code, err := service.CreateSpace(ctx, "member", &CreateSpaceRequest{Name: "personal"})
+ if err != nil || code != common.CodeSuccess || created["tenant_id"] != "member" {
+ t.Fatalf("member should create a personal skill space without switching tenants: result=%#v code=%d err=%v", created, code, err)
}
- if tenantID, err := resolveSkillSpaceTenantID(ctx, "owner", "default", permission.OperationUse); err != nil || tenantID != "team" {
- t.Fatalf("default skill space tenant = %q, err=%v; want team", tenantID, err)
+ if tenantID, err := resolveSkillSpaceTenantID(ctx, "owner", "default", permission.OperationUse); err != nil || tenantID != "owner" {
+ t.Fatalf("default skill space tenant = %q, err=%v; want owner's personal tenant", tenantID, err)
}
updated, code, err := service.UpdateSpace(ctx, "owner", space.ID, &UpdateSpaceRequest{Description: "updated"})
diff --git a/internal/service/tenant.go b/internal/service/tenant.go
index 3f2443c045..c45e7ebc01 100644
--- a/internal/service/tenant.go
+++ b/internal/service/tenant.go
@@ -132,28 +132,27 @@ type TenantInfoResponse struct {
Role string `json:"role"`
}
-// GetTenantInfo get tenant information for the current user (owner tenant)
+// GetTenantInfo returns the user's own tenant and its owner membership settings.
func (s *TenantService) GetTenantInfo(ctx context.Context, userID string) (*TenantInfoResponse, error) {
- tenantInfos, err := s.tenantDAO.GetInfoByUserID(ctx, dao.DB, userID)
+ membership, tenantID, err := s.currentUserTenant(ctx, userID)
if err != nil {
return nil, err
}
- if len(tenantInfos) == 0 {
- return nil, nil // No tenant found (should not happen for valid user)
+ tenant, err := s.tenantDAO.GetByID(ctx, dao.DB, tenantID)
+ if err != nil {
+ return nil, err
}
- // Return the first tenant (should be only one owner tenant per user)
- ti := tenantInfos[0]
return &TenantInfoResponse{
- TenantID: ti.TenantID,
- Name: ti.Name,
- LLMID: ti.LLMID,
- EmbDID: ti.EmbDID,
- RerankID: ti.RerankID,
- ASRID: ti.ASRID,
- Img2TxtID: ti.Img2TxtID,
- TTSID: ti.TTSID,
- ParserIDs: ti.ParserIDs,
- Role: ti.Role,
+ TenantID: tenant.ID,
+ Name: tenant.Name,
+ LLMID: membership.LLMID,
+ EmbDID: membership.EmbdID,
+ RerankID: membership.RerankID,
+ ASRID: membership.ASRID,
+ Img2TxtID: membership.Img2TxtID,
+ TTSID: ptrStringValue(membership.TTSID),
+ ParserIDs: tenant.ParserIDs,
+ Role: membership.Role,
}, nil
}
@@ -403,41 +402,106 @@ func ptrStringValue(s *string) string {
return *s
}
-// GetDefaultModelName returns the full default model ID for a tenant and model type
-// Format: modelName@instanceName@providerName or modelName@providerName
-// Returns empty string if no default model is set
+// GetDefaultModelName returns the selected model reference for a tenant. Request
+// contexts use that user's membership; trusted background work uses the owner.
func (s *TenantService) GetDefaultModelName(ctx context.Context, tenantID string, modelType entity.ModelType) (string, error) {
- tenant, err := s.tenantDAO.GetByID(ctx, dao.DB, tenantID)
+ return s.GetDefaultModelNameForTenant(ctx, tenantID, modelType)
+}
+
+// GetDefaultModelNameForUser returns a user's setting in their personal tenant.
+func (s *TenantService) GetDefaultModelNameForUser(ctx context.Context, userID string, modelType entity.ModelType) (string, error) {
+ membership, _, err := s.currentUserTenant(ctx, userID)
+ if err != nil {
+ return "", err
+ }
+ if !isDefaultModelType(modelType) {
+ return "", fmt.Errorf("invalid model type: %s", modelType)
+ }
+ modelName, _ := defaultModelRefs(membership, modelType)
+ return modelName, nil
+}
+
+// GetDefaultModelNameForTenant resolves the request user's membership setting
+// when present and falls back to the tenant owner for background work.
+func (s *TenantService) GetDefaultModelNameForTenant(ctx context.Context, tenantID string, modelType entity.ModelType) (string, error) {
+ if !isDefaultModelType(modelType) {
+ return "", fmt.Errorf("invalid model type: %s", modelType)
+ }
+ membership, err := s.defaultModelMembershipForTenant(ctx, tenantID)
if err != nil {
return "", err
}
+ modelName, _ := defaultModelRefs(membership, modelType)
+ return modelName, nil
+}
- var modelID string
+// GetDefaultModelRefsForUser returns the model reference and resolved tenant
+// model ID configured by userID in tenantID.
+func (s *TenantService) GetDefaultModelRefsForUser(ctx context.Context, userID, tenantID string, modelType entity.ModelType) (string, string, error) {
+ if !isDefaultModelType(modelType) {
+ return "", "", fmt.Errorf("invalid model type: %s", modelType)
+ }
+ membership, err := s.defaultModelMembership(ctx, userID, tenantID)
+ if err != nil {
+ return "", "", err
+ }
+ modelName, modelID := defaultModelRefs(membership, modelType)
+ return modelName, modelID, nil
+}
+
+// GetDefaultModelRefsForTenant resolves model settings for the request user or,
+// without a request identity, the tenant owner.
+func (s *TenantService) GetDefaultModelRefsForTenant(ctx context.Context, tenantID string, modelType entity.ModelType) (string, string, error) {
+ if !isDefaultModelType(modelType) {
+ return "", "", fmt.Errorf("invalid model type: %s", modelType)
+ }
+ membership, err := s.defaultModelMembershipForTenant(ctx, tenantID)
+ if err != nil {
+ return "", "", err
+ }
+ modelName, modelID := defaultModelRefs(membership, modelType)
+ return modelName, modelID, nil
+}
+
+func isDefaultModelType(modelType entity.ModelType) bool {
switch modelType {
- case entity.ModelTypeChat:
- modelID = tenant.LLMID
- case entity.ModelTypeEmbedding:
- modelID = tenant.EmbdID
- case entity.ModelTypeRerank:
- modelID = tenant.RerankID
- case entity.ModelTypeSpeech2Text:
- modelID = tenant.ASRID
- case entity.ModelTypeImage2Text:
- modelID = tenant.Img2TxtID
- case entity.ModelTypeTTS:
- modelID = *tenant.TTSID
- case entity.ModelTypeOCR:
- modelID = *tenant.OCRID
- case entity.ModelTypeDecision:
- // Unset is a normal state: the decision gate is optional.
- if tenant.DecisionID != nil {
- modelID = *tenant.DecisionID
- }
+ case entity.ModelTypeChat, entity.ModelTypeEmbedding, entity.ModelTypeRerank,
+ entity.ModelTypeSpeech2Text, entity.ModelTypeImage2Text, entity.ModelTypeTTS,
+ entity.ModelTypeOCR, entity.ModelTypeDecision:
+ return true
default:
- return "", fmt.Errorf("invalid model type: %s", modelType)
+ return false
+ }
+}
+
+func (s *TenantService) currentUserTenant(ctx context.Context, userID string) (*entity.UserTenant, string, error) {
+ membership, err := s.userTenantDAO.GetOwnerByUserID(ctx, dao.DB, userID)
+ if err != nil {
+ return nil, "", err
+ }
+ return membership, membership.TenantID, nil
+}
+
+func (s *TenantService) defaultModelMembership(ctx context.Context, userID, tenantID string) (*entity.UserTenant, error) {
+ if strings.TrimSpace(userID) == "" {
+ return s.userTenantDAO.GetOwnerByTenantID(ctx, dao.DB, tenantID)
}
+ membership, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, userID, tenantID)
+ if err == nil {
+ return membership, nil
+ }
+ if !errors.Is(err, gorm.ErrRecordNotFound) || userID != tenantID {
+ return nil, err
+ }
+ return s.userTenantDAO.GetOwnerByTenantID(ctx, dao.DB, tenantID)
+}
- return modelID, nil
+func (s *TenantService) defaultModelMembershipForTenant(ctx context.Context, tenantID string) (*entity.UserTenant, error) {
+ if subject, ok := permission.SubjectFromContext(ctx); ok && strings.TrimSpace(subject.UserID) != "" &&
+ (strings.TrimSpace(subject.TenantID) == "" || strings.TrimSpace(subject.TenantID) == tenantID) {
+ return s.defaultModelMembership(ctx, subject.UserID, tenantID)
+ }
+ return s.userTenantDAO.GetOwnerByTenantID(ctx, dao.DB, tenantID)
}
func (s *TenantService) GetModelInfo(ctx context.Context, tenantID string, defaultModel string, modelType string) (*string, *string, *string, bool, error) {
@@ -533,122 +597,48 @@ func rsplitN(s, sep string, n int) []string {
}
func (s *TenantService) ListTenantDefaultModels(ctx context.Context, userID string) ([]ModelItem, error) {
-
- tenantInfos, err := s.tenantDAO.GetInfoByUserID(ctx, dao.DB, userID)
+ membership, tenantID, err := s.currentUserTenant(ctx, userID)
if err != nil {
return nil, err
}
- if len(tenantInfos) == 0 {
- return nil, nil // No tenant found (should not happen for valid user)
- }
-
- ownedTenant := tenantInfos[0]
-
- var result []ModelItem
-
- defaultChatModelProvider, defaultChatModelInstance, defaultChatModelName, defaultChatModelEnable, err := s.GetModelInfo(ctx, ownedTenant.TenantID, ownedTenant.LLMID, "chat")
- if err == nil {
- result = append(result, ModelItem{
- ModelProvider: defaultChatModelProvider,
- ModelInstance: defaultChatModelInstance,
- ModelName: defaultChatModelName,
- ModelID: ptrStringValue(ownedTenant.TenantLLMID),
- ModelType: "chat",
- Enable: defaultChatModelEnable,
- })
- }
-
- defaultEmbeddingModelProvider, defaultEmbeddingModelInstance, defaultEmbeddingModelName, defaultEmbeddingModelEnable, err := s.GetModelInfo(ctx, ownedTenant.TenantID, ownedTenant.EmbDID, "embedding")
- if err == nil {
- result = append(result, ModelItem{
- ModelProvider: defaultEmbeddingModelProvider,
- ModelInstance: defaultEmbeddingModelInstance,
- ModelName: defaultEmbeddingModelName,
- ModelID: ptrStringValue(ownedTenant.TenantEmbdID),
- ModelType: "embedding",
- Enable: defaultEmbeddingModelEnable,
- })
- }
-
- defaultRerankModelProvider, defaultRerankModelInstance, defaultRerankModelName, defaultRerankModelEnable, err := s.GetModelInfo(ctx, ownedTenant.TenantID, ownedTenant.RerankID, "rerank")
- if err == nil {
- result = append(result, ModelItem{
- ModelProvider: defaultRerankModelProvider,
- ModelInstance: defaultRerankModelInstance,
- ModelName: defaultRerankModelName,
- ModelID: ptrStringValue(ownedTenant.TenantRerankID),
- ModelType: "rerank",
- Enable: defaultRerankModelEnable,
- })
- }
-
- defaultASRModelProvider, defaultASRModelInstance, defaultASRModelName, defaultASREnable, err := s.GetModelInfo(ctx, ownedTenant.TenantID, ownedTenant.ASRID, "asr")
- if err == nil {
- result = append(result, ModelItem{
- ModelProvider: defaultASRModelProvider,
- ModelInstance: defaultASRModelInstance,
- ModelName: defaultASRModelName,
- ModelID: ptrStringValue(ownedTenant.TenantASRID),
- ModelType: "asr",
- Enable: defaultASREnable,
- })
- }
-
- defaultImage2TextModelProvider, defaultImage2TextModelInstance, defaultImage2TextModelName, defaultImage2TextModelEnable, err := s.GetModelInfo(ctx, ownedTenant.TenantID, ownedTenant.Img2TxtID, "vision")
- if err == nil {
- result = append(result, ModelItem{
- ModelProvider: defaultImage2TextModelProvider,
- ModelInstance: defaultImage2TextModelInstance,
- ModelName: defaultImage2TextModelName,
- ModelID: ptrStringValue(ownedTenant.TenantImg2TxtID),
- ModelType: "vision",
- Enable: defaultImage2TextModelEnable,
- })
- }
-
- if ownedTenant.OCRID != "" {
- defaultOCRModelProvider, defaultOCRModelInstance, defaultOCRModelName, defaultOCRModelEnable, err := s.GetModelInfo(ctx, ownedTenant.TenantID, ownedTenant.OCRID, "ocr")
- if err == nil {
- result = append(result, ModelItem{
- ModelProvider: defaultOCRModelProvider,
- ModelInstance: defaultOCRModelInstance,
- ModelName: defaultOCRModelName,
- ModelID: ptrStringValue(ownedTenant.TenantOCRID),
- ModelType: "ocr",
- Enable: defaultOCRModelEnable,
- })
- }
- }
+ return listDefaultModels(ctx, s, membership, tenantID), nil
+}
- if ownedTenant.TTSID != "" {
- defaultTTSModelProvider, defaultTTSModelInstance, defaultTTSModelName, defaultTTSModelEnable, err := s.GetModelInfo(ctx, ownedTenant.TenantID, ownedTenant.TTSID, "tts")
- if err == nil {
- result = append(result, ModelItem{
- ModelProvider: defaultTTSModelProvider,
- ModelInstance: defaultTTSModelInstance,
- ModelName: defaultTTSModelName,
- ModelID: ptrStringValue(ownedTenant.TenantTTSID),
- ModelType: "tts",
- Enable: defaultTTSModelEnable,
- })
+func listDefaultModels(ctx context.Context, s *TenantService, membership *entity.UserTenant, tenantID string) []ModelItem {
+ type defaultModel struct {
+ modelType string
+ modelID string
+ rowID *string
+ }
+ models := []defaultModel{
+ {modelType: "chat", modelID: membership.LLMID, rowID: membership.TenantLLMID},
+ {modelType: "embedding", modelID: membership.EmbdID, rowID: membership.TenantEmbdID},
+ {modelType: "rerank", modelID: membership.RerankID, rowID: membership.TenantRerankID},
+ {modelType: "asr", modelID: membership.ASRID, rowID: membership.TenantASRID},
+ {modelType: "vision", modelID: membership.Img2TxtID, rowID: membership.TenantImg2TxtID},
+ {modelType: "ocr", modelID: ptrStringValue(membership.OCRID), rowID: membership.TenantOCRID},
+ {modelType: "tts", modelID: ptrStringValue(membership.TTSID), rowID: membership.TenantTTSID},
+ {modelType: "decision", modelID: ptrStringValue(membership.DecisionID), rowID: membership.TenantDecisionID},
+ }
+ result := make([]ModelItem, 0, len(models))
+ for _, model := range models {
+ if strings.TrimSpace(model.modelID) == "" {
+ continue
}
- }
-
- if ownedTenant.DecisionID != nil && *ownedTenant.DecisionID != "" {
- defaultDecisionModelProvider, defaultDecisionModelInstance, defaultDecisionModelName, defaultDecisionModelEnable, err := s.GetModelInfo(ctx, ownedTenant.TenantID, *ownedTenant.DecisionID, "decision")
- if err == nil {
- result = append(result, ModelItem{
- ModelProvider: defaultDecisionModelProvider,
- ModelInstance: defaultDecisionModelInstance,
- ModelName: defaultDecisionModelName,
- ModelID: ptrStringValue(ownedTenant.TenantDecisionID),
- ModelType: "decision",
- Enable: defaultDecisionModelEnable,
- })
+ provider, instance, name, enabled, err := s.GetModelInfo(ctx, tenantID, model.modelID, model.modelType)
+ if err != nil {
+ continue
}
+ result = append(result, ModelItem{
+ ModelProvider: provider,
+ ModelInstance: instance,
+ ModelName: name,
+ ModelID: ptrStringValue(model.rowID),
+ ModelType: model.modelType,
+ Enable: enabled,
+ })
}
-
- return result, nil
+ return result
}
func (s *TenantService) checkModelAvailable(ctx context.Context, tenantID, providerName, instanceName, modelName, modelType string) error {
@@ -705,16 +695,10 @@ func (s *TenantService) checkModelAvailable(ctx context.Context, tenantID, provi
}
func (s *TenantService) SetTenantDefaultModels(ctx context.Context, userID, modelProvider, modelInstance, modelName, modelType, modelID string) error {
-
- tenantInfos, err := s.tenantDAO.GetInfoByUserID(ctx, dao.DB, userID)
+ membership, tenantID, err := s.currentUserTenant(ctx, userID)
if err != nil {
return err
}
- if len(tenantInfos) == 0 {
- return nil // No tenant found (should not happen for valid user)
- }
-
- ownedTenant := tenantInfos[0]
var defaultModel string
modelTypeID, tenantModelTypeID, modelTypeBit, err := tenantDefaultModelFields(modelType)
if err != nil {
@@ -735,8 +719,7 @@ func (s *TenantService) SetTenantDefaultModels(ctx context.Context, userID, mode
if err != nil {
return fmt.Errorf("provider for model %s not found: %w", modelID, err)
}
-
- if providerEntity.TenantID != ownedTenant.TenantID {
+ if providerEntity.TenantID != tenantID {
return fmt.Errorf("model %s does not belong to your tenant", modelID)
}
if modelEntity.Status != "active" {
@@ -745,7 +728,6 @@ func (s *TenantService) SetTenantDefaultModels(ctx context.Context, userID, mode
if !entity.ModelType(modelEntity.ModelType).Has(modelTypeBit) {
return fmt.Errorf("model %s isn't a %s model", modelEntity.ModelName, modelType)
}
-
modelProvider = providerEntity.ProviderName
modelInstance = instanceEntity.InstanceName
modelName = modelEntity.ModelName
@@ -756,29 +738,26 @@ func (s *TenantService) SetTenantDefaultModels(ctx context.Context, userID, mode
defaultModel = ""
tenantModelID = nil
} else if modelProvider != "" && modelInstance != "" && modelName != "" {
- err = s.checkModelAvailable(ctx, ownedTenant.TenantID, modelProvider, modelInstance, modelName, modelType)
- if err != nil {
+ if err := s.checkModelAvailable(ctx, tenantID, modelProvider, modelInstance, modelName, modelType); err != nil {
return err
}
if modelID == "" {
- // Builtin provider doesn't use tenant_model rows; leave tenantModelID nil
- // (mirrors Python resolve_model_id returning None for Builtin).
if modelProvider == "Builtin" {
tenantModelID = nil
} else {
- modelProviderEntity, err := s.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, ownedTenant.TenantID, modelProvider)
+ provider, err := s.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, modelProvider)
if err != nil {
return err
}
- modelInstanceEntity, err := s.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, modelProviderEntity.ID, modelInstance)
+ instance, err := s.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, modelInstance)
if err != nil {
return err
}
- modelEntity, err := s.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, modelProviderEntity.ID, modelInstanceEntity.ID, modelName)
+ model, err := s.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, provider.ID, instance.ID, modelName)
if err != nil {
return err
}
- tenantModelID = modelEntity.ID
+ tenantModelID = model.ID
}
}
defaultModel = fmt.Sprintf("%s@%s@%s", modelName, modelInstance, modelProvider)
@@ -786,19 +765,16 @@ func (s *TenantService) SetTenantDefaultModels(ctx context.Context, userID, mode
return fmt.Errorf("model provider, instance and name must be specified together")
}
- err = s.tenantDAO.Update(ctx, dao.DB, ownedTenant.TenantID, map[string]interface{}{
+ return dao.DB.WithContext(ctx).Model(&entity.UserTenant{}).Where("id = ?", membership.ID).Updates(map[string]interface{}{
modelTypeID: defaultModel,
tenantModelTypeID: tenantModelID,
- })
-
- return err
+ }).Error
}
// Tenant member role constants.
const (
TenantRoleOwner = "owner"
TenantRoleNormal = "normal"
- TenantRoleInvite = "invite"
TenantRoleAdmin = "admin"
)
@@ -885,55 +861,51 @@ func (s *TenantService) AddMember(ctx context.Context, userID, tenantID string,
}
return nil, common.CodeDataError, err
}
-
- // Reject if already a member or has a pending invitation.
- userTenant, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, invitee.ID, tenantID)
- if err == nil {
- if userTenant != nil {
- switch {
- case userTenant.Role == TenantRoleOwner:
- return nil, common.CodeDataError, fmt.Errorf("user is already the tenant owner")
- case userTenant.Role == TenantRoleInvite:
- return nil, common.CodeDataError, fmt.Errorf("user already has a pending invitation")
- case strings.TrimSpace(userTenant.Role) != "":
- return nil, common.CodeDataError, fmt.Errorf("user is already a member")
+ var membership entity.UserTenant
+ err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var existing entity.UserTenant
+ loadErr := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
+ Where("user_id = ? AND tenant_id = ?", invitee.ID, tenantID).Take(&existing).Error
+ if loadErr != nil && !errors.Is(loadErr, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("load existing Tenant membership: %w", loadErr)
+ }
+ if errors.Is(loadErr, gorm.ErrRecordNotFound) {
+ status := entity.TenantMembershipStatusInvited
+ membership = entity.UserTenant{ID: common.GenerateUUID(), UserID: invitee.ID, TenantID: tenantID, InvitedBy: userID, Status: &status}
+ if err := tx.Create(&membership).Error; err != nil {
+ return fmt.Errorf("failed to create invitation: %w", err)
}
+ return recordTenantPermissionChange(tx, tenantID, userID, "tenant.member.invited", "user", invitee.ID, "tenant_membership", membership.ID, "invite", 0, 0, nil,
+ map[string]interface{}{"user_id": invitee.ID, "email": invitee.Email, "role": membership.Role, "invited_by": userID, "status": status})
}
- }
- if err != nil && !dao.IsNotFoundErr(err) {
- return nil, common.CodeServerError, err
- }
-
- status := string(entity.StatusValid)
- ut := &entity.UserTenant{
- ID: common.GenerateUUID(),
- UserID: invitee.ID,
- TenantID: tenantID,
- Role: TenantRoleInvite,
- InvitedBy: userID,
- Status: &status,
- }
- err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- if err := s.userTenantDAO.Create(ctx, tx, ut); err != nil {
- return fmt.Errorf("failed to create invitation: %w", err)
+ oldStatus := tenantMembershipStatus(existing.Status)
+ switch oldStatus {
+ case entity.TenantMembershipStatusJoined:
+ if existing.Role == TenantRoleOwner {
+ return common.NewCodedError(common.CodeDataError, "user is already the tenant owner")
+ }
+ return common.NewCodedError(common.CodeDataError, "user is already a member")
+ case entity.TenantMembershipStatusInvited:
+ return common.NewCodedError(common.CodeDataError, "user already has a pending invitation")
+ case entity.TenantMembershipStatusRequested, entity.TenantMembershipStatusRejected, entity.TenantMembershipStatusLeft, entity.TenantMembershipStatusRemoved:
+ default:
+ return common.NewCodedError(common.CodeConflict, "Tenant membership has an unsupported status")
}
- return recordTenantPermissionChange(tx, tenantID, userID, "tenant.member.invited", "user", invitee.ID, "tenant_membership", ut.ID, "invite", 0, 0, nil,
- map[string]interface{}{"user_id": invitee.ID, "email": invitee.Email, "role": ut.Role, "invited_by": userID, "status": status})
+ before := map[string]interface{}{"user_id": invitee.ID, "role": existing.Role, "status": oldStatus, "invited_by": existing.InvitedBy}
+ status := entity.TenantMembershipStatusInvited
+ if err := tx.Model(&entity.UserTenant{}).Where("id = ?", existing.ID).Updates(map[string]interface{}{"role": "", "status": status, "invited_by": userID}).Error; err != nil {
+ return fmt.Errorf("reinvite Tenant member: %w", err)
+ }
+ existing.Role, existing.InvitedBy, existing.Status = "", userID, &status
+ membership = existing
+ return recordTenantPermissionChange(tx, tenantID, userID, "tenant.member.invited", "user", invitee.ID, "tenant_membership", membership.ID, "invite", 0, 0, before,
+ map[string]interface{}{"user_id": invitee.ID, "email": invitee.Email, "role": membership.Role, "invited_by": userID, "status": status})
})
if err != nil {
return nil, tenantRoleErrorCode(err), err
}
- avatar := ""
- if invitee.Avatar != nil {
- avatar = *invitee.Avatar
- }
- return &AddMemberResponse{
- ID: invitee.ID,
- Avatar: avatar,
- Email: invitee.Email,
- Nickname: invitee.Nickname,
- }, common.CodeSuccess, nil
+ return tenantMemberResponse(invitee), common.CodeSuccess, nil
}
// RemoveMember removes a user from the tenant. The owner may remove members,
@@ -943,65 +915,58 @@ func (s *TenantService) RemoveMember(ctx context.Context, userID, tenantID, targ
if s.userTenantDAO == nil {
return common.CodeServerError, fmt.Errorf("userTenantDAO not initialized")
}
- if userID != "" && userID == targetUserID {
- var removed bool
- err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- var invitation entity.UserTenant
- err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
- Where("user_id = ? AND tenant_id = ? AND role = ? AND status = ?", userID, tenantID, TenantRoleInvite, string(entity.StatusValid)).
- Take(&invitation).Error
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil
- }
- if err != nil {
- return fmt.Errorf("load pending tenant invitation: %w", err)
- }
- if err := tx.Unscoped().Where("id = ?", invitation.ID).Delete(&entity.UserTenant{}).Error; err != nil {
- return fmt.Errorf("failed to decline tenant invitation: %w", err)
- }
- removed = true
- return recordTenantPermissionChange(tx, tenantID, userID, "tenant.invitation.declined", "user", userID, "tenant_membership", invitation.ID, "decline", 0, 0,
- map[string]interface{}{"user_id": userID, "role": invitation.Role, "invited_by": invitation.InvitedBy, "status": invitation.Status},
- map[string]interface{}{"declined": true})
- })
- if err != nil {
+ if userID != targetUserID {
+ if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, entity.TenantPermissionManageMembers); err != nil {
return tenantRoleErrorCode(err), err
}
- if removed {
- return common.CodeSuccess, nil
- }
- }
-
- if userID == targetUserID {
- if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, 0); err != nil {
- return tenantRoleErrorCode(err), err
- }
- } else if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, entity.TenantPermissionManageMembers); err != nil {
- return tenantRoleErrorCode(err), err
}
err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- var targetMembership entity.UserTenant
+ var membership entity.UserTenant
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
- Where("user_id = ? AND tenant_id = ? AND status = ?", targetUserID, tenantID, string(entity.StatusValid)).
- Take(&targetMembership).Error; err != nil {
+ Where("user_id = ? AND tenant_id = ?", targetUserID, tenantID).Take(&membership).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
- return common.NewCodedError(common.CodeDataError, "user is not a tenant member")
+ return common.NewCodedError(common.CodeDataError, "user has no Tenant membership or invitation")
}
- return fmt.Errorf("failed to load tenant member: %w", err)
+ return fmt.Errorf("load Tenant membership: %w", err)
}
- if targetMembership.Role == TenantRoleOwner {
- return common.NewCodedError(common.CodeArgumentError, "cannot remove the tenant owner")
+ oldStatus := tenantMembershipStatus(membership.Status)
+ if oldStatus == entity.TenantMembershipStatusRemoved || oldStatus == entity.TenantMembershipStatusRejected || oldStatus == entity.TenantMembershipStatusLeft {
+ return nil
}
- if err := tx.Unscoped().Where("id = ?", targetMembership.ID).Delete(&entity.UserTenant{}).Error; err != nil {
- return fmt.Errorf("failed to remove member: %w", err)
+ if membership.Role == TenantRoleOwner {
+ return common.NewCodedError(common.CodeArgumentError, "cannot remove or leave the tenant owner")
}
+
+ newStatus := entity.TenantMembershipStatusRemoved
eventType, actionType := "tenant.member.removed", "remove"
- if targetMembership.Role == TenantRoleInvite {
+ if userID == targetUserID {
+ switch oldStatus {
+ case entity.TenantMembershipStatusInvited:
+ newStatus = entity.TenantMembershipStatusRejected
+ eventType, actionType = "tenant.invitation.declined", "reject"
+ case entity.TenantMembershipStatusJoined:
+ newStatus = entity.TenantMembershipStatusLeft
+ eventType, actionType = "tenant.member.left", "leave"
+ default:
+ return common.NewCodedError(common.CodeDataError, "user has no active Tenant membership or invitation")
+ }
+ } else if oldStatus == entity.TenantMembershipStatusInvited {
eventType, actionType = "tenant.invitation.revoked", "revoke"
}
- return recordTenantPermissionChange(tx, tenantID, userID, eventType, "user", targetUserID, "tenant_membership", targetMembership.ID, actionType, 0, 0,
- map[string]interface{}{"user_id": targetUserID, "role": targetMembership.Role, "invited_by": targetMembership.InvitedBy, "status": targetMembership.Status},
- map[string]interface{}{"removed": true})
+
+ before := map[string]interface{}{
+ "user_id": membership.UserID, "role": membership.Role,
+ "invited_by": membership.InvitedBy, "status": oldStatus,
+ }
+ if err := tx.Model(&entity.UserTenant{}).Where("id = ?", membership.ID).
+ Updates(map[string]interface{}{"role": "", "status": newStatus}).Error; err != nil {
+ return fmt.Errorf("update Tenant membership status: %w", err)
+ }
+ after := map[string]interface{}{
+ "user_id": membership.UserID, "role": "",
+ "invited_by": membership.InvitedBy, "status": newStatus,
+ }
+ return recordTenantPermissionChange(tx, tenantID, userID, eventType, "user", targetUserID, "tenant_membership", membership.ID, actionType, 0, 0, before, after)
})
if err != nil {
return tenantRoleErrorCode(err), err
@@ -1014,19 +979,17 @@ func (s *TenantService) AcceptInvite(ctx context.Context, userID, tenantID strin
if s.userTenantDAO == nil {
return common.CodeServerError, fmt.Errorf("userTenantDAO not initialized")
}
- existing, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, userID, tenantID)
- if err != nil || existing == nil {
- return common.CodeDataError, fmt.Errorf("no pending invitation found")
- }
- if existing.Role != TenantRoleInvite {
- return common.CodeArgumentError, fmt.Errorf("no pending invitation to accept")
- }
- err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var membership entity.UserTenant
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
- Where("id = ? AND user_id = ? AND tenant_id = ? AND role = ? AND status = ?", existing.ID, userID, tenantID, TenantRoleInvite, string(entity.StatusValid)).
- Take(&membership).Error; err != nil {
- return fmt.Errorf("reload pending Tenant invitation: %w", err)
+ Where("user_id = ? AND tenant_id = ?", userID, tenantID).Take(&membership).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return common.NewCodedError(common.CodeDataError, "no pending invitation found")
+ }
+ return fmt.Errorf("load pending Tenant invitation: %w", err)
+ }
+ if tenantMembershipStatus(membership.Status) != entity.TenantMembershipStatusInvited {
+ return common.NewCodedError(common.CodeArgumentError, "no pending invitation to accept")
}
role, err := resolveTenantInviteRole(tx, tenantID)
if err != nil {
@@ -1035,11 +998,13 @@ func (s *TenantService) AcceptInvite(ctx context.Context, userID, tenantID strin
if strings.TrimSpace(role.value) == "" {
return common.NewCodedError(common.CodeConflict, "Tenant default role is invalid")
}
- if err := tx.Model(&entity.UserTenant{}).Where("id = ?", membership.ID).Update("role", role.value).Error; err != nil {
+ status := entity.TenantMembershipStatusJoined
+ if err := tx.Model(&entity.UserTenant{}).Where("id = ?", membership.ID).
+ Updates(map[string]interface{}{"role": role.value, "status": status}).Error; err != nil {
return fmt.Errorf("accept Tenant invitation: %w", err)
}
- before := map[string]interface{}{"user_id": userID, "role": membership.Role}
- after := map[string]interface{}{"user_id": userID, "role": role.value}
+ before := map[string]interface{}{"user_id": userID, "role": membership.Role, "status": tenantMembershipStatus(membership.Status)}
+ after := map[string]interface{}{"user_id": userID, "role": role.value, "status": status}
if role.roleID != nil {
after["role_id"] = *role.roleID
}
@@ -1053,3 +1018,18 @@ func (s *TenantService) AcceptInvite(ctx context.Context, userID, tenantID strin
}
return common.CodeSuccess, nil
}
+
+func tenantMembershipStatus(status *string) string {
+ if status == nil {
+ return ""
+ }
+ return *status
+}
+
+func tenantMemberResponse(user *entity.User) *AddMemberResponse {
+ avatar := ""
+ if user.Avatar != nil {
+ avatar = *user.Avatar
+ }
+ return &AddMemberResponse{ID: user.ID, Avatar: avatar, Email: user.Email, Nickname: user.Nickname}
+}
diff --git a/internal/service/tenant_permission.go b/internal/service/tenant_permission.go
index f2ee5d8b26..fcb6c1e1fd 100644
--- a/internal/service/tenant_permission.go
+++ b/internal/service/tenant_permission.go
@@ -17,32 +17,42 @@ package service
import (
"context"
- "errors"
"strings"
+ "gorm.io/gorm"
"ragflow/internal/dao"
"ragflow/internal/permission"
)
-func requireOwnedTenantID(ctx context.Context, userID string) (string, error) {
+func requireCurrentTenantID(ctx context.Context, userID string) (string, error) {
if strings.TrimSpace(userID) == "" {
return "", permission.ErrUnauthenticated
}
- tenantDAO := dao.NewUserTenantDAO()
- tenants, err := tenantDAO.GetByUserIDAndRole(ctx, dao.DB, userID, string(permission.RoleOwner))
+ if subject, ok := permission.SubjectFromContext(ctx); ok {
+ if subject.UserID != "" && subject.UserID != userID {
+ return "", permission.ErrInvalidSubject
+ }
+ if tenantID := strings.TrimSpace(subject.TenantID); tenantID != "" {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, permission.TenantMember); err != nil {
+ return "", err
+ }
+ return tenantID, nil
+ }
+ }
+ tenantID, handled, err := resolveDefaultTenantIDEE(ctx, userID)
if err != nil {
return "", err
}
- checker := permission.NewDatabaseChecker(dao.DB)
- for _, tenant := range tenants {
- if tenant == nil || strings.TrimSpace(tenant.TenantID) == "" {
- continue
- }
- if err := checker.CheckTenant(ctx, permission.Subject{UserID: userID}, tenant.TenantID, permission.TenantOwner); err == nil {
- return tenant.TenantID, nil
- } else if !errors.Is(err, permission.ErrMembershipNotFound) {
- return "", err
- }
+ if handled {
+ return tenantID, nil
}
- return "", permission.ErrMembershipNotFound
+ return strings.TrimSpace(userID), nil
+}
+
+func checkFeatureAction(ctx context.Context, userID string, feature permission.Feature, action permission.Action) error {
+ return permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, feature, action)
+}
+
+func grantCreatedResourceOwner(ctx context.Context, tx *gorm.DB, userID, tenantID string, kind permission.ResourceKind, resourceID string) error {
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: kind, ID: resourceID})
}
diff --git a/internal/service/tenant_permission_ee.go b/internal/service/tenant_permission_ee.go
new file mode 100644
index 0000000000..252f59daf7
--- /dev/null
+++ b/internal/service/tenant_permission_ee.go
@@ -0,0 +1,22 @@
+//
+// 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 service
+
+import "context"
+
+func resolveDefaultTenantIDEE(context.Context, string) (string, bool, error) {
+ return "", false, nil
+}
diff --git a/internal/service/tenant_test.go b/internal/service/tenant_test.go
index b0c9b601a5..1b97d127cb 100644
--- a/internal/service/tenant_test.go
+++ b/internal/service/tenant_test.go
@@ -132,22 +132,33 @@ func TestRemoveMemberSelfAllowed(t *testing.T) {
if err != nil {
t.Fatalf("self-removal failed: %v", err)
}
- if _, err := dao.NewUserTenantDAO().FilterByUserIDAndTenantID(ctx, db, "user-abc", "tenant-xyz"); !dao.IsNotFoundErr(err) {
- t.Fatalf("self-membership remains after removal: %v", err)
+ var membership entity.UserTenant
+ if err := db.Where("user_id = ? AND tenant_id = ?", "user-abc", "tenant-xyz").Take(&membership).Error; err != nil {
+ t.Fatalf("read self-membership after leaving: %v", err)
+ }
+ if membership.Status == nil || *membership.Status != entity.TenantMembershipStatusLeft || membership.Role != "" {
+ t.Fatalf("self-membership after leaving = %+v, want left status and empty role", membership)
}
}
func TestDeclineOwnTenantInviteAllowed(t *testing.T) {
db := setupTenantPermissionTestDB(t)
- seedTenantMembership(t, db, "invite", "invitee-user", "tenant-xyz", TenantRoleInvite)
+ status := entity.TenantMembershipStatusInvited
+ if err := db.Create(&entity.UserTenant{ID: "invite", UserID: "invitee-user", TenantID: "tenant-xyz", Status: &status}).Error; err != nil {
+ t.Fatalf("seed pending invitation: %v", err)
+ }
s := &TenantService{userTenantDAO: dao.NewUserTenantDAO()}
code, err := s.RemoveMember(t.Context(), "invitee-user", "tenant-xyz", "invitee-user")
if err != nil || code != common.CodeSuccess {
t.Fatalf("RemoveMember(invitation self-decline) = (%v, %v), want success", code, err)
}
- if _, err := dao.NewUserTenantDAO().FilterByUserIDAndTenantID(t.Context(), db, "invitee-user", "tenant-xyz"); !dao.IsNotFoundErr(err) {
- t.Fatalf("pending invitation remains after decline: %v", err)
+ var membership entity.UserTenant
+ if err := db.Where("user_id = ? AND tenant_id = ?", "invitee-user", "tenant-xyz").Take(&membership).Error; err != nil {
+ t.Fatalf("read declined invitation: %v", err)
+ }
+ if membership.Status == nil || *membership.Status != entity.TenantMembershipStatusRejected || membership.Role != "" {
+ t.Fatalf("declined invitation = %+v, want rejected status and empty role", membership)
}
}
@@ -181,7 +192,6 @@ func TestTenantRoleConstants(t *testing.T) {
cases := map[string]string{
TenantRoleOwner: "owner",
TenantRoleNormal: "normal",
- TenantRoleInvite: "invite",
TenantRoleAdmin: "admin",
}
for got, want := range cases {
@@ -243,13 +253,7 @@ func TestSetTenantDefaultModels_WithModelID(t *testing.T) {
}
// Insert Tenant
- err = db.Create(&entity.Tenant{
- ID: tenantID,
- LLMID: "",
- EmbdID: "",
- ASRID: "",
- Status: &statusVal,
- }).Error
+ err = db.Create(&entity.Tenant{ID: tenantID, Status: &statusVal}).Error
if err != nil {
t.Fatalf("failed to create tenant: %v", err)
}
@@ -308,18 +312,18 @@ func TestSetTenantDefaultModels_WithModelID(t *testing.T) {
t.Fatalf("SetTenantDefaultModels failed: %v", err)
}
- // Verify Tenant default model is updated to composite name
- tenant := &entity.Tenant{}
- err = db.Where("id = ?", tenantID).First(tenant).Error
+ // Verify the default is stored on the user's owner membership.
+ var membership entity.UserTenant
+ err = db.Where("id = ?", "ut-1").First(&membership).Error
if err != nil {
- t.Fatalf("failed to retrieve tenant: %v", err)
+ t.Fatalf("failed to retrieve owner membership: %v", err)
}
expectedDefaultModel := "gpt-4o@dummy@OpenAI"
- if tenant.LLMID != expectedDefaultModel {
- t.Errorf("expected tenant default LLM to be %q, got %q", expectedDefaultModel, tenant.LLMID)
+ if membership.LLMID != expectedDefaultModel {
+ t.Errorf("expected owner default LLM to be %q, got %q", expectedDefaultModel, membership.LLMID)
}
- if tenant.TenantLLMID == nil || *tenant.TenantLLMID != modelID {
- t.Errorf("expected tenant_llm_id to be %q, got %v", modelID, tenant.TenantLLMID)
+ if membership.TenantLLMID == nil || *membership.TenantLLMID != modelID {
+ t.Errorf("expected owner tenant_llm_id to be %q, got %v", modelID, membership.TenantLLMID)
}
}
diff --git a/internal/service/user.go b/internal/service/user.go
index 3e7d743e08..77208a5e08 100644
--- a/internal/service/user.go
+++ b/internal/service/user.go
@@ -202,13 +202,6 @@ func (s *UserService) Register(ctx context.Context, req *RegisterRequest) (*enti
tenant := &entity.Tenant{
ID: userID,
Name: &tenantName,
- LLMID: llmID,
- EmbdID: embdID,
- ASRID: asrID,
- Img2TxtID: img2txtID,
- RerankID: rerankID,
- TTSID: &ttsID,
- OCRID: &ocrID,
ParserIDs: "naive:General,qa:Q&A,manual:Manual,table:Table,paper:Research Paper,book:Book,laws:Laws,presentation:Presentation,picture:Picture,one:One,audio:Audio,email:Email,tag:Tag",
Status: &status,
}
@@ -220,6 +213,13 @@ func (s *UserService) Register(ctx context.Context, req *RegisterRequest) (*enti
Role: "owner",
InvitedBy: userID,
Status: &status,
+ LLMID: llmID,
+ EmbdID: embdID,
+ ASRID: asrID,
+ Img2TxtID: img2txtID,
+ RerankID: rerankID,
+ TTSID: &ttsID,
+ OCRID: &ocrID,
}
fileID := common.GenerateToken()
file__ := ""
@@ -750,33 +750,64 @@ type SetTenantInfoRequest struct {
Raw map[string]interface{} `json:"-"`
}
-// SetTenantInfo updates tenant model configuration
+// SetTenantInfo updates default models on the caller's owner membership.
func (s *UserService) SetTenantInfo(ctx context.Context, userID string, req *SetTenantInfoRequest) (common.ErrorCode, error) {
- _ = userID
- tenantDAO := dao.NewTenantDAO()
- updates := make(map[string]interface{})
-
- for key, value := range req.Raw {
- if key == "tenant_id" {
- continue
- }
- updates[key] = value
+ if req == nil {
+ return common.CodeArgumentError, fmt.Errorf("model settings are required")
}
-
- tenantID := ""
- if req.TenantID != nil {
- tenantID = *req.TenantID
+ updates, err := tenantModelSettingUpdates(req.Raw)
+ if err != nil {
+ return common.CodeArgumentError, err
+ }
+ membershipDAO := dao.NewUserTenantDAO()
+ membership, err := membershipDAO.GetOwnerByUserID(ctx, dao.DB, userID)
+ if err != nil {
+ return common.CodeForbidden, err
+ }
+ if req.TenantID != nil && strings.TrimSpace(*req.TenantID) != "" && strings.TrimSpace(*req.TenantID) != membership.TenantID {
+ return common.CodeForbidden, fmt.Errorf("tenant_id must match the user's tenant")
}
-
if len(updates) > 0 {
- if err := tenantDAO.Update(ctx, dao.DB, tenantID, updates); err != nil {
+ if err := dao.DB.WithContext(ctx).Model(&entity.UserTenant{}).Where("id = ?", membership.ID).Updates(updates).Error; err != nil {
return common.CodeExceptionError, err
}
}
-
return common.CodeSuccess, nil
}
+func tenantModelSettingUpdates(raw map[string]interface{}) (map[string]interface{}, error) {
+ updates := make(map[string]interface{}, len(raw))
+ for key, value := range raw {
+ if key == "tenant_id" {
+ if _, ok := value.(string); !ok {
+ return nil, fmt.Errorf("tenant_id must be a string")
+ }
+ continue
+ }
+ nullable := false
+ switch key {
+ case "llm_id", "embd_id", "asr_id", "img2txt_id", "rerank_id":
+ case "tenant_llm_id", "tenant_embd_id", "tenant_asr_id", "tenant_img2txt_id", "tenant_rerank_id",
+ "tts_id", "tenant_tts_id", "ocr_id", "tenant_ocr_id", "decision_id", "tenant_decision_id":
+ nullable = true
+ default:
+ return nil, fmt.Errorf("unsupported model setting %q", key)
+ }
+ if value == nil {
+ if !nullable {
+ return nil, fmt.Errorf("%s cannot be null", key)
+ }
+ updates[key] = nil
+ continue
+ }
+ if _, ok := value.(string); !ok {
+ return nil, fmt.Errorf("%s must be a string", key)
+ }
+ updates[key] = value
+ }
+ return updates, nil
+}
+
// UserTenantService user tenant service
// Provides business logic for user-tenant relationship management
type UserTenantService struct {
diff --git a/internal/service/user_set_tenant_info_test.go b/internal/service/user_set_tenant_info_test.go
new file mode 100644
index 0000000000..688c0ecfb5
--- /dev/null
+++ b/internal/service/user_set_tenant_info_test.go
@@ -0,0 +1,69 @@
+//
+// 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 service
+
+import (
+ "context"
+ "testing"
+
+ "ragflow/internal/common"
+)
+
+func TestSetTenantInfoRejectsInvalidSettingTypesBeforeDatabaseLookup(t *testing.T) {
+ tests := []struct {
+ name string
+ raw map[string]interface{}
+ }{
+ {name: "numeric model id", raw: map[string]interface{}{"llm_id": 123}},
+ {name: "object model id", raw: map[string]interface{}{"tenant_embd_id": map[string]interface{}{"id": "model"}}},
+ {name: "null required model id", raw: map[string]interface{}{"img2txt_id": nil}},
+ {name: "non-string tenant id", raw: map[string]interface{}{"tenant_id": false}},
+ {name: "unsupported field", raw: map[string]interface{}{"other": "value"}},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ code, err := (&UserService{}).SetTenantInfo(context.Background(), "user-1", &SetTenantInfoRequest{Raw: tt.raw})
+ if code != common.CodeArgumentError || err == nil {
+ t.Fatalf("SetTenantInfo() = (%v, %v), want argument error", code, err)
+ }
+ })
+ }
+}
+
+func TestTenantModelSettingUpdatesAllowsNullOnlyForNullableColumns(t *testing.T) {
+ updates, err := tenantModelSettingUpdates(map[string]interface{}{
+ "llm_id": "chat@provider",
+ "tenant_llm_id": nil,
+ "tts_id": nil,
+ "tenant_tts_id": nil,
+ "ocr_id": nil,
+ "tenant_ocr_id": nil,
+ "decision_id": nil,
+ "tenant_decision_id": nil,
+ })
+ if err != nil {
+ t.Fatalf("tenantModelSettingUpdates() error = %v", err)
+ }
+ if len(updates) != 8 {
+ t.Fatalf("len(updates) = %d, want 8", len(updates))
+ }
+ for _, key := range []string{"tenant_llm_id", "tts_id", "tenant_tts_id", "ocr_id", "tenant_ocr_id", "decision_id", "tenant_decision_id"} {
+ if value, ok := updates[key]; !ok || value != nil {
+ t.Errorf("updates[%q] = %#v, present=%v; want present null", key, value, ok)
+ }
+ }
+}
diff --git a/test/api/document_raw_routes_test.go b/test/api/document_raw_routes_test.go
index 58479bb907..60b4641c37 100644
--- a/test/api/document_raw_routes_test.go
+++ b/test/api/document_raw_routes_test.go
@@ -144,7 +144,7 @@ func TestRESTDocumentDownloadIntegrity(t *testing.T) {
t.Fatalf("document metadata missing uploaded ID %q", id)
}
missing := restCall(t, TestConfig, http.MethodGet, "/documents/"+TestConfig.InvalidID, nil, nil)
- if missing.Status != http.StatusNotFound || missing.JSON["error"] != "document not found" {
+ if missing.Status != http.StatusOK || missing.JSON["code"] != float64(404) || missing.JSON["message"] != "document not found" {
t.Fatalf("missing document metadata contract=%d %v", missing.Status, missing.JSON)
}
for _, token := range []string{"", TestConfig.InvalidAPIKey} {