Skip to content

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

feat(tenant): add tenant roles and permissions (#21257)

buua43607209543cfc3
diff --git a/internal/admin/service.go b/internal/admin/service.go
index 264c79e7c9..fe4e017265 100644
--- a/internal/admin/service.go
+++ b/internal/admin/service.go
@@ -47,25 +47,26 @@ import (
// Service admin service layer
type Service struct {
- userDAO *dao.UserDAO
- licenseDAO *dao.LicenseDAO
- timeRecordDAO *dao.TimeRecordDAO
- systemSettingsDAO *dao.SystemSettingsDAO
- tenantDAO *dao.TenantDAO
- userTenantDAO *dao.UserTenantDAO
- fileDAO *dao.FileDAO
- documentDAO *dao.DocumentDAO
- taskDAO *dao.TaskDAO
- kbDAO *dao.KnowledgebaseDAO
- canvasDAO *dao.UserCanvasDAO
- chatDAO *dao.ChatDAO
- chatSessionDAO *dao.ChatSessionDAO
- apiTokenDAO *dao.APITokenDAO
- api4ConvDAO *dao.API4ConversationDAO
- llmDAO *dao.LLMDAO
- ingestionTaskDAO *dao.IngestionTaskDAO
- ingestionTaskLogDao *dao.IngestionTaskLogDAO
- ingestionTaskSvc *servicepkg.IngestionTaskService
+ userDAO *dao.UserDAO
+ licenseDAO *dao.LicenseDAO
+ timeRecordDAO *dao.TimeRecordDAO
+ systemSettingsDAO *dao.SystemSettingsDAO
+ tenantDAO *dao.TenantDAO
+ userTenantDAO *dao.UserTenantDAO
+ fileDAO *dao.FileDAO
+ documentDAO *dao.DocumentDAO
+ taskDAO *dao.TaskDAO
+ kbDAO *dao.KnowledgebaseDAO
+ canvasDAO *dao.UserCanvasDAO
+ chatDAO *dao.ChatDAO
+ chatSessionDAO *dao.ChatSessionDAO
+ apiTokenDAO *dao.APITokenDAO
+ api4ConvDAO *dao.API4ConversationDAO
+ llmDAO *dao.LLMDAO
+ ingestionTaskDAO *dao.IngestionTaskDAO
+ ingestionTaskLogDao *dao.IngestionTaskLogDAO
+ ingestionTaskSvc *servicepkg.IngestionTaskService
+ modelProviderService *servicepkg.ModelProviderService
BillingProductDAO *dao.BillingProductDAO
BillingSubscriptionDAO *dao.BillingSubscriptionDAO
@@ -78,25 +79,26 @@ type Service struct {
// NewService create admin service
func NewService() *Service {
return &Service{
- userDAO: dao.NewUserDAO(),
- licenseDAO: dao.NewLicenseDAO(),
- timeRecordDAO: dao.NewTimeRecordDAO(),
- systemSettingsDAO: dao.NewSystemSettingsDAO(),
- tenantDAO: dao.NewTenantDAO(),
- userTenantDAO: dao.NewUserTenantDAO(),
- fileDAO: dao.NewFileDAO(),
- documentDAO: dao.NewDocumentDAO(),
- taskDAO: dao.NewTaskDAO(),
- kbDAO: dao.NewKnowledgebaseDAO(),
- canvasDAO: dao.NewUserCanvasDAO(),
- chatDAO: dao.NewChatDAO(),
- chatSessionDAO: dao.NewChatSessionDAO(),
- apiTokenDAO: dao.NewAPITokenDAO(),
- api4ConvDAO: dao.NewAPI4ConversationDAO(),
- llmDAO: dao.NewLLMDAO(),
- ingestionTaskDAO: dao.NewIngestionTaskDAO(),
- ingestionTaskLogDao: dao.NewIngestionTaskLogDAO(),
- ingestionTaskSvc: servicepkg.NewIngestionTaskService(),
+ userDAO: dao.NewUserDAO(),
+ licenseDAO: dao.NewLicenseDAO(),
+ timeRecordDAO: dao.NewTimeRecordDAO(),
+ systemSettingsDAO: dao.NewSystemSettingsDAO(),
+ tenantDAO: dao.NewTenantDAO(),
+ userTenantDAO: dao.NewUserTenantDAO(),
+ fileDAO: dao.NewFileDAO(),
+ documentDAO: dao.NewDocumentDAO(),
+ taskDAO: dao.NewTaskDAO(),
+ kbDAO: dao.NewKnowledgebaseDAO(),
+ canvasDAO: dao.NewUserCanvasDAO(),
+ chatDAO: dao.NewChatDAO(),
+ chatSessionDAO: dao.NewChatSessionDAO(),
+ apiTokenDAO: dao.NewAPITokenDAO(),
+ api4ConvDAO: dao.NewAPI4ConversationDAO(),
+ llmDAO: dao.NewLLMDAO(),
+ ingestionTaskDAO: dao.NewIngestionTaskDAO(),
+ ingestionTaskLogDao: dao.NewIngestionTaskLogDAO(),
+ ingestionTaskSvc: servicepkg.NewIngestionTaskService(),
+ modelProviderService: servicepkg.NewModelProviderService(),
BillingProductDAO: dao.NewBillingProductDAO(),
BillingSubscriptionDAO: dao.NewBillingSubscriptionDAO(),
@@ -284,7 +286,11 @@ func (s *Service) CreateUser(ctx context.Context, username, password, role strin
Credit: 512,
Status: &tenantStatus,
}
- if err = tx.Create(tenant).Error; err != nil {
+ if err = dao.ApplyDefaultTenantInviteEnabled(ctx, tx, tenant); err != nil {
+ rollbackTx()
+ return nil, fmt.Errorf("failed to initialize tenant invitation setting: %w", err)
+ }
+ if err = dao.NewTenantDAO().Create(ctx, tx, tenant); err != nil {
rollbackTx()
return nil, fmt.Errorf("failed to create tenant: %w", err)
}
@@ -1426,8 +1432,11 @@ func (s *Service) addTenantForAdmin(userID, nickname string) error {
ID: userID,
Name: &tenantName,
}
+ if err := dao.ApplyDefaultTenantInviteEnabled(context.Background(), dao.DB, tenant); err != nil {
+ return fmt.Errorf("failed to initialize tenant invitation setting: %w", err)
+ }
- if err := dao.DB.Create(tenant).Error; err != nil {
+ if err := dao.NewTenantDAO().Create(context.Background(), dao.DB, tenant); err != nil {
return err
}
diff --git a/internal/dao/database.go b/internal/dao/database.go
index 025f03a87b..4432130963 100644
--- a/internal/dao/database.go
+++ b/internal/dao/database.go
@@ -256,6 +256,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 = migrateTenantModelProviderUserUniqueIndex(ctx, DB); err != nil {
+ return fmt.Errorf("failed to migrate tenant model provider unique index: %w", err)
+ }
common.Info("Database schema migrated successfully")
} else {
if err = migrateIngestionLogRunIdentity(ctx, DB); err != nil {
@@ -268,6 +271,9 @@ func InitDB(ctx context.Context, migrateDB bool) error {
return fmt.Errorf("failed to auto-migrate runtime models: %w", err)
}
}
+ if err = initializeSystemSettingsEE(ctx, DB); err != nil {
+ return fmt.Errorf("failed to initialize enterprise system settings: %w", err)
+ }
// Conversation lists filter by dialog and usually order by update time.
for _, table := range []string{"conversation", "api_4_conversation"} {
indexName := "idx_" + table + "_dialog_updated"
diff --git a/internal/dao/database_ee.go b/internal/dao/database_ee.go
index 9d1fb8283c..a6baabe90b 100644
--- a/internal/dao/database_ee.go
+++ b/internal/dao/database_ee.go
@@ -16,7 +16,17 @@
package dao
-// permissionDataModelsEE returns the entities included in the enterprise schema.
+import (
+ "context"
+
+ "gorm.io/gorm"
+)
+
+// permissionDataModelsEE returns no additional entities in the community edition.
func permissionDataModelsEE() []interface{} {
return nil
}
+
+func initializeSystemSettingsEE(context.Context, *gorm.DB) error {
+ return nil
+}
diff --git a/internal/dao/migration_version.go b/internal/dao/migration_version.go
index e9fdf6761f..098c1aced4 100644
--- a/internal/dao/migration_version.go
+++ b/internal/dao/migration_version.go
@@ -56,6 +56,10 @@ const devPrereleaseIdentifier = "dev"
// GetDatabaseMigrationVersion reads the stored migration version. It returns an
// empty string when the marker or the system_settings table is absent.
func GetDatabaseMigrationVersion(ctx context.Context, db *gorm.DB) (string, error) {
+ return getDatabaseMigrationVersion(ctx, db, migrationDBVersionMarker)
+}
+
+func getDatabaseMigrationVersion(ctx context.Context, db *gorm.DB, marker string) (string, error) {
scoped := db.WithContext(ctx)
if !scoped.Migrator().HasTable("system_settings") {
common.Info("Table 'system_settings' does not exist, migration version marker is unavailable")
@@ -63,7 +67,7 @@ func GetDatabaseMigrationVersion(ctx context.Context, db *gorm.DB) (string, erro
}
var value string
- err := scoped.Raw("SELECT `value` FROM `system_settings` WHERE `name` = ?", migrationDBVersionMarker).Row().Scan(&value)
+ err := scoped.Raw("SELECT `value` FROM `system_settings` WHERE `name` = ?", marker).Row().Scan(&value)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return "", nil
@@ -75,6 +79,10 @@ func GetDatabaseMigrationVersion(ctx context.Context, db *gorm.DB) (string, erro
// setDatabaseMigrationVersion upserts the migration version marker.
func setDatabaseMigrationVersion(ctx context.Context, db *gorm.DB, version string) error {
+ return setDatabaseMigrationVersionForMarker(ctx, db, migrationDBVersionMarker, version)
+}
+
+func setDatabaseMigrationVersionForMarker(ctx context.Context, db *gorm.DB, marker, version string) error {
scoped := db.WithContext(ctx)
if !scoped.Migrator().HasTable("system_settings") {
common.Warn("Table 'system_settings' does not exist, migration version marker was not saved")
@@ -84,7 +92,7 @@ func setDatabaseMigrationVersion(ctx context.Context, db *gorm.DB, version strin
nowMs := time.Now().UnixMilli()
now := time.Now()
setting := entity.SystemSettings{
- Name: migrationDBVersionMarker,
+ Name: marker,
Source: "migration",
DataType: "string",
Value: version,
diff --git a/internal/dao/permission_migration.go b/internal/dao/permission_migration.go
index ebf06dec15..40ed87aa16 100644
--- a/internal/dao/permission_migration.go
+++ b/internal/dao/permission_migration.go
@@ -26,10 +26,16 @@ import (
"gorm.io/gorm"
)
-const permissionMigrationTargetVersion = "v1.0.0-rc3.dev1"
+const permissionMigrationTargetVersion = "v1.0.0-rc3.dev3"
// migratePermissions applies the permission schema migration and records its version.
func migratePermissions(ctx context.Context, db *gorm.DB) error {
+ // Enterprise migrations have their own marker. Run this hook before checking
+ // the shared marker so a community migration cannot skip enterprise data work.
+ if err := migratePermissionDataEE(ctx, db); err != nil {
+ return fmt.Errorf("migrate enterprise permission data: %w", err)
+ }
+
version, err := GetDatabaseMigrationVersion(ctx, db)
if err != nil {
return fmt.Errorf("read database migration version: %w", err)
@@ -37,9 +43,6 @@ func migratePermissions(ctx context.Context, db *gorm.DB) error {
if shouldSkipMigration(version, permissionMigrationTargetVersion) {
return nil
}
- if err := migratePermissionDataEE(ctx, db); err != nil {
- return fmt.Errorf("migrate enterprise permission data: %w", err)
- }
if err := migrateInvitedByNullable(ctx, db); err != nil {
return err
}
diff --git a/internal/dao/permission_migration_test.go b/internal/dao/permission_migration_test.go
index 460f90dbd3..7ebc9de347 100644
--- a/internal/dao/permission_migration_test.go
+++ b/internal/dao/permission_migration_test.go
@@ -79,7 +79,7 @@ func TestMigratePermissions(t *testing.T) {
t.Fatalf("auto-migrate enterprise permission entities: %v", err)
}
ctx := context.Background()
- if err := setDatabaseMigrationVersion(ctx, db, tenantModelMaxTokensTargetVersion); err != nil {
+ if err := setDatabaseMigrationVersion(ctx, db, "v1.0.0-rc3.dev2"); err != nil {
t.Fatalf("set previous migration version: %v", err)
}
if err := migratePermissions(ctx, db); err != nil {
diff --git a/internal/dao/tenant.go b/internal/dao/tenant.go
index 3d95ffaefe..7561515b7c 100644
--- a/internal/dao/tenant.go
+++ b/internal/dao/tenant.go
@@ -102,7 +102,12 @@ func (dao *TenantDAO) GetByID(ctx context.Context, db *gorm.DB, id string) (*ent
// Create creates a new tenant
func (dao *TenantDAO) Create(ctx context.Context, db *gorm.DB, tenant *entity.Tenant) error {
- return db.WithContext(ctx).Create(tenant).Error
+ return db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := initializeTenantDefaultRoleEE(ctx, tx, tenant); err != nil {
+ return err
+ }
+ return tx.Create(tenant).Error
+ })
}
// GetAllIDs returns the IDs of all active tenants.
diff --git a/internal/dao/tenant_invite_ee.go b/internal/dao/tenant_invite_ee.go
new file mode 100644
index 0000000000..7f356d2631
--- /dev/null
+++ b/internal/dao/tenant_invite_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 dao
+
+import (
+ "context"
+
+ "ragflow/internal/entity"
+
+ "gorm.io/gorm"
+)
+
+func ApplyDefaultTenantInviteEnabled(context.Context, *gorm.DB, *entity.Tenant) error {
+ return nil
+}
diff --git a/internal/dao/tenant_model_provider_migration.go b/internal/dao/tenant_model_provider_migration.go
new file mode 100644
index 0000000000..d237c0765c
--- /dev/null
+++ b/internal/dao/tenant_model_provider_migration.go
@@ -0,0 +1,99 @@
+//
+// 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 tenantModelProviderUserUniqueIndex = "idx_tenant_provider_user_unique"
+
+// migrateTenantModelProviderUserUniqueIndex scopes provider names to the
+// owning user and tenant. It removes the former (provider_name, tenant_id)
+// constraint after the replacement index exists.
+func migrateTenantModelProviderUserUniqueIndex(ctx context.Context, db *gorm.DB) error {
+ scoped := db.WithContext(ctx)
+ model := &entity.TenantModelProvider{}
+ migrator := scoped.Migrator()
+ if !migrator.HasTable(model) {
+ return nil
+ }
+ if !migrator.HasColumn(model, "UserID") {
+ return fmt.Errorf("tenant_model_provider.user_id is missing")
+ }
+
+ indexes, err := migrator.GetIndexes(model)
+ if err != nil {
+ return fmt.Errorf("inspect tenant_model_provider indexes: %w", err)
+ }
+ var hasUserScopedIndex bool
+ for _, index := range indexes {
+ if index.Name() == tenantModelProviderUserUniqueIndex && !sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id", "user_id"}) {
+ if err := migrator.DropIndex(model, index.Name()); err != nil {
+ return fmt.Errorf("drop malformed index %s: %w", index.Name(), err)
+ }
+ continue
+ }
+ unique, known := index.Unique()
+ if known && unique && sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id", "user_id"}) {
+ hasUserScopedIndex = true
+ }
+ }
+ if !hasUserScopedIndex {
+ if err := migrator.CreateIndex(model, tenantModelProviderUserUniqueIndex); err != nil {
+ return fmt.Errorf("create user-scoped provider index: %w", err)
+ }
+ }
+
+ indexes, err = migrator.GetIndexes(model)
+ if err != nil {
+ return fmt.Errorf("inspect tenant_model_provider indexes after creating replacement: %w", err)
+ }
+ for _, index := range indexes {
+ unique, known := index.Unique()
+ if !known || !unique || index.Name() == tenantModelProviderUserUniqueIndex {
+ continue
+ }
+ if !sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id"}) {
+ continue
+ }
+ if err := migrator.DropIndex(model, index.Name()); err != nil {
+ return fmt.Errorf("drop legacy provider index %s: %w", index.Name(), err)
+ }
+ }
+ return nil
+}
+
+func sameIndexColumns(columns, expected []string) bool {
+ if len(columns) != len(expected) {
+ return false
+ }
+ columnSet := make(map[string]struct{}, len(expected))
+ for _, column := range expected {
+ columnSet[strings.ToLower(column)] = struct{}{}
+ }
+ for _, column := range columns {
+ delete(columnSet, strings.ToLower(column))
+ }
+ return len(columnSet) == 0
+}
diff --git a/internal/dao/tenant_model_provider_migration_test.go b/internal/dao/tenant_model_provider_migration_test.go
new file mode 100644
index 0000000000..4cb74610c5
--- /dev/null
+++ b/internal/dao/tenant_model_provider_migration_test.go
@@ -0,0 +1,88 @@
+//
+// 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"
+ "testing"
+
+ "github.com/glebarez/sqlite"
+ "gorm.io/gorm"
+ "ragflow/internal/entity"
+)
+
+func TestMigrateTenantModelProviderUserUniqueIndex(t *testing.T) {
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{TranslateError: true})
+ if err != nil {
+ t.Fatalf("open database: %v", err)
+ }
+ if err = db.Exec(`CREATE TABLE tenant_model_provider (
+ id varchar(32) PRIMARY KEY,
+ user_id varchar(32),
+ provider_name varchar(128) NOT NULL,
+ tenant_id varchar(32) NOT NULL
+ )`).Error; err != nil {
+ t.Fatalf("create legacy provider table: %v", err)
+ }
+ if err = db.Exec("CREATE UNIQUE INDEX idx_tenant_provider_unique ON tenant_model_provider (provider_name, tenant_id)").Error; err != nil {
+ t.Fatalf("create legacy provider index: %v", err)
+ }
+ if err = db.Exec(`INSERT INTO tenant_model_provider (id, user_id, provider_name, tenant_id)
+ VALUES ('provider-1', 'user-1', 'OpenAI', 'tenant-1')`).Error; err != nil {
+ t.Fatalf("create existing provider: %v", err)
+ }
+ if err = db.AutoMigrate(&entity.TenantModelProvider{}); err != nil {
+ t.Fatalf("auto-migrate provider table: %v", err)
+ }
+
+ ctx := context.Background()
+ if err = migrateTenantModelProviderUserUniqueIndex(ctx, db); err != nil {
+ t.Fatalf("migrate provider index: %v", err)
+ }
+ if err = migrateTenantModelProviderUserUniqueIndex(ctx, db); err != nil {
+ t.Fatalf("rerun provider index migration: %v", err)
+ }
+
+ indexes, err := db.Migrator().GetIndexes(&entity.TenantModelProvider{})
+ if err != nil {
+ t.Fatalf("inspect provider indexes: %v", err)
+ }
+ var hasUserScopedIndex, hasLegacyIndex bool
+ for _, index := range indexes {
+ if index.Name() == tenantModelProviderUserUniqueIndex {
+ unique, known := index.Unique()
+ hasUserScopedIndex = known && unique && sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id", "user_id"})
+ }
+ if sameIndexColumns(index.Columns(), []string{"provider_name", "tenant_id"}) {
+ unique, known := index.Unique()
+ hasLegacyIndex = known && unique
+ }
+ }
+ if !hasUserScopedIndex {
+ t.Fatal("user-scoped unique provider index was not created")
+ }
+ if hasLegacyIndex {
+ t.Fatal("legacy unique provider index was not removed")
+ }
+
+ if err = db.Create(&entity.TenantModelProvider{ID: "provider-2", UserID: "user-2", ProviderName: "OpenAI", TenantID: "tenant-1"}).Error; err != nil {
+ t.Fatalf("same provider name for another user in the tenant was rejected: %v", err)
+ }
+ if err = db.Create(&entity.TenantModelProvider{ID: "provider-3", UserID: "user-1", ProviderName: "OpenAI", TenantID: "tenant-1"}).Error; err == nil {
+ t.Fatal("duplicate provider name for the same user and tenant was accepted")
+ }
+}
diff --git a/internal/dao/tenant_role_ee.go b/internal/dao/tenant_role_ee.go
new file mode 100644
index 0000000000..854bc9cafc
--- /dev/null
+++ b/internal/dao/tenant_role_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 dao
+
+import (
+ "context"
+
+ "ragflow/internal/entity"
+
+ "gorm.io/gorm"
+)
+
+func initializeTenantDefaultRoleEE(context.Context, *gorm.DB, *entity.Tenant) error {
+ return nil
+}
diff --git a/internal/entity/permission_change_log_ee.go b/internal/entity/permission_change_log_ee.go
new file mode 100644
index 0000000000..fc35ea7f18
--- /dev/null
+++ b/internal/entity/permission_change_log_ee.go
@@ -0,0 +1,24 @@
+//
+// 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 entity
+
+// PermissionChangeLog is a test-only placeholder in the community edition.
+type PermissionChangeLog struct {
+ BaseModel
+}
+
+func (PermissionChangeLog) TableName() string { return "permission_change_log" }
diff --git a/internal/entity/permission_ee.go b/internal/entity/permission_ee.go
new file mode 100644
index 0000000000..868e4c087a
--- /dev/null
+++ b/internal/entity/permission_ee.go
@@ -0,0 +1,23 @@
+//
+// 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 entity
+
+const (
+ TenantPermissionManageMembers int32 = 1 << iota
+ TenantPermissionManageRoles
+ TenantPermissionOwner
+)
diff --git a/internal/entity/tenant_model_provider.go b/internal/entity/tenant_model_provider.go
index cbb3c170a4..b62b6b9b12 100644
--- a/internal/entity/tenant_model_provider.go
+++ b/internal/entity/tenant_model_provider.go
@@ -19,9 +19,9 @@ package entity
// TenantModelProvider tenant model provider table
type TenantModelProvider struct {
ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
- UserID string `gorm:"column:user_id;size:32;index" json:"user_id"`
- ProviderName string `gorm:"column:provider_name;size:128;not null;index:idx_tenant_provider_unique,unique" json:"provider_name"`
- TenantID string `gorm:"column:tenant_id;size:32;not null;index;index:idx_tenant_provider_unique,unique" json:"tenant_id"`
+ UserID string `gorm:"column:user_id;size:32;index;index:idx_tenant_provider_user_unique,unique,priority:3" json:"user_id"`
+ ProviderName string `gorm:"column:provider_name;size:128;not null;index:idx_tenant_provider_user_unique,unique,priority:1" json:"provider_name"`
+ TenantID string `gorm:"column:tenant_id;size:32;not null;index;index:idx_tenant_provider_user_unique,unique,priority:2" json:"tenant_id"`
BaseModel
}
diff --git a/internal/entity/user.go b/internal/entity/user.go
index 4746ff0dac..59ec9a6aa2 100644
--- a/internal/entity/user.go
+++ b/internal/entity/user.go
@@ -35,6 +35,7 @@ type User struct {
IsAnonymous string `gorm:"column:is_anonymous;size:1;not null;default:0;index" json:"is_anonymous"`
LoginChannel *string `gorm:"column:login_channel;index" json:"login_channel,omitempty"`
Status *string `gorm:"column:status;size:1;default:1;index" json:"status"`
+ RoleID *int32 `gorm:"column:role_id;index" json:"role_id,omitempty"`
IsSuperuser *bool `gorm:"column:is_superuser;index" json:"is_superuser,omitempty"`
BaseModel
}
diff --git a/internal/handler/tenant.go b/internal/handler/tenant.go
index 296846733d..ca093ef236 100644
--- a/internal/handler/tenant.go
+++ b/internal/handler/tenant.go
@@ -345,6 +345,10 @@ func (h *TenantHandler) ListTenantMembers(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()
members, code, err := h.tenantService.ListMembers(ctx, user.ID, tenantID)
@@ -502,6 +506,10 @@ func (h *TenantHandler) AddTenantMember(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 req service.AddMemberRequest
if err := c.ShouldBindJSON(&req); err != nil {
@@ -552,6 +560,10 @@ 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"`
@@ -588,6 +600,10 @@ 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)
@@ -597,3 +613,8 @@ func (h *TenantHandler) AcceptTenantInvite(c *gin.Context) {
}
common.SuccessWithData(c, true, "success")
}
+
+func matchesActiveTenant(c *gin.Context, tenantID string) bool {
+ activeTenantID := strings.TrimSpace(c.GetString("tenant_id"))
+ return activeTenantID == "" || activeTenantID == tenantID
+}
diff --git a/internal/permission/database_source.go b/internal/permission/database_source.go
index 9e45245c8e..96b733931f 100644
--- a/internal/permission/database_source.go
+++ b/internal/permission/database_source.go
@@ -58,15 +58,76 @@ func (s *databaseSource) GetMembership(ctx context.Context, userID, tenantID str
}
return nil, err
}
+ role, valid, err := s.resolveMembershipRole(ctx, relation.TenantID, relation.Role)
+ if err != nil {
+ return nil, err
+ }
+ if !valid {
+ return nil, nil
+ }
return &Membership{
ID: relation.ID,
UserID: relation.UserID,
TenantID: relation.TenantID,
- Role: TenantRole(relation.Role),
+ Role: role,
Active: relation.Status != nil && *relation.Status == string(entity.StatusValid),
}, nil
}
+func (s *databaseSource) resolveMembershipRole(ctx context.Context, tenantID, roleValue string) (TenantRole, bool, error) {
+ role := TenantRole(strings.TrimSpace(roleValue))
+ switch role {
+ case RoleOwner, RoleAdmin, RoleNormal, RoleInvite:
+ return role, true, nil
+ }
+ valid, err := isTenantRoleID(ctx, s.db, tenantID, string(role))
+ if err != nil {
+ return "", false, err
+ }
+ if !valid {
+ return "", false, nil
+ }
+ // Feature roles grant capabilities, while tenant membership still denotes
+ // ordinary membership to the shared resource policy.
+ return RoleNormal, true, nil
+}
+
+func (s *databaseSource) activeTenantIDsForUser(ctx context.Context, userID string) ([]string, error) {
+ if s == nil || s.db == nil {
+ return nil, ErrSourceUnavailable
+ }
+ var memberships []entity.UserTenant
+ if err := s.db.WithContext(ctx).
+ Select("tenant_id", "role").
+ Where("user_id = ? AND status = ?", userID, string(entity.StatusValid)).
+ Find(&memberships).Error; err != nil {
+ return nil, err
+ }
+
+ type roleResult struct {
+ role TenantRole
+ valid bool
+ err error
+ }
+ resolved := make(map[string]roleResult)
+ tenantIDs := make([]string, 0, len(memberships))
+ for _, membership := range memberships {
+ key := membership.TenantID + "\x00" + membership.Role
+ result, ok := resolved[key]
+ if !ok {
+ result.role, result.valid, result.err = s.resolveMembershipRole(ctx, membership.TenantID, membership.Role)
+ resolved[key] = result
+ }
+ if result.err != nil {
+ return nil, result.err
+ }
+ if result.valid && result.role != RoleInvite {
+ tenantIDs = append(tenantIDs, membership.TenantID)
+ }
+ }
+ return uniqueStringValues(tenantIDs), nil
+}
+
func (s *databaseSource) GetResources(ctx context.Context, refs []ResourceRef) ([]Resource, error) {
if s == nil || s.db == nil {
return nil, ErrSourceUnavailable
@@ -411,13 +472,8 @@ func (s *databaseSource) ListResourceRefs(ctx context.Context, subject Subject,
if parent.ID != "" || parent.Kind != "" {
return nil, fmt.Errorf("%w: canvases cannot have a parent scope", ErrInvalidPermission)
}
- var tenantIDs []string
- if err := s.db.WithContext(ctx).Model(&entity.UserTenant{}).
- Distinct("tenant_id").
- Where("user_id = ? AND status = ? AND role IN ?", subject.UserID, string(entity.StatusValid), []string{
- string(RoleOwner), string(RoleAdmin), string(RoleNormal),
- }).
- Pluck("tenant_id", &tenantIDs).Error; err != nil {
+ tenantIDs, err := s.activeTenantIDsForUser(ctx, subject.UserID)
+ if err != nil {
return nil, err
}
ownerIDs := append(append(make([]string, 0, len(tenantIDs)+1), tenantIDs...), subject.UserID)
diff --git a/internal/permission/database_source_test.go b/internal/permission/database_source_test.go
index 27ab3a88a1..c64225a3dd 100644
--- a/internal/permission/database_source_test.go
+++ b/internal/permission/database_source_test.go
@@ -97,6 +97,69 @@ func TestDatabaseCheckerAuthorizesDatasetFromPersistedRows(t *testing.T) {
}
}
+func TestDatabaseCheckerValidatesTenantRoleIDsAndLegacyMembershipRoles(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.UserTenant{}); err != nil {
+ t.Fatalf("migrate membership table: %v", err)
+ }
+ if err := db.Exec("CREATE TABLE role (id INTEGER PRIMARY KEY, tenant_id TEXT NOT NULL)").Error; err != nil {
+ t.Fatalf("create tenant role table: %v", err)
+ }
+ if err := db.Exec("INSERT INTO role (id, tenant_id) VALUES (17, 'tenant-1')").Error; err != nil {
+ t.Fatalf("create tenant role: %v", err)
+ }
+ if !tenantRoleMembershipEnabled(db) {
+ t.Skip("Tenant feature roles are not enabled")
+ }
+
+ valid := string(entity.StatusValid)
+ memberships := []entity.UserTenant{
+ {ID: "role-member", UserID: "role-user", TenantID: "tenant-1", Role: "17", Status: &valid},
+ {ID: "wrong-tenant-role", UserID: "foreign-role-user", TenantID: "tenant-2", Role: "17", Status: &valid},
+ {ID: "unknown-role", UserID: "unknown-role-user", TenantID: "tenant-1", Role: "not-a-role", Status: &valid},
+ {ID: "admin", UserID: "admin-user", TenantID: "tenant-1", Role: string(RoleAdmin), Status: &valid},
+ {ID: "normal", UserID: "normal-user", TenantID: "tenant-1", Role: string(RoleNormal), Status: &valid},
+ {ID: "invite", UserID: "invite-user", TenantID: "tenant-1", Role: string(RoleInvite), Status: &valid},
+ }
+ if err := db.Create(&memberships).Error; err != nil {
+ t.Fatalf("create memberships: %v", err)
+ }
+
+ checker := NewDatabaseChecker(db)
+ if err := checker.CheckTenant(t.Context(), Subject{UserID: "role-user"}, "tenant-1", TenantMember); err != nil {
+ t.Fatalf("valid Tenant role ID should be normalized to an ordinary member: %v", err)
+ }
+ for _, test := range []struct {
+ userID string
+ tenantID string
+ }{
+ {userID: "foreign-role-user", tenantID: "tenant-2"},
+ {userID: "unknown-role-user", tenantID: "tenant-1"},
+ {userID: "invite-user", tenantID: "tenant-1"},
+ } {
+ if err := checker.CheckTenant(t.Context(), Subject{UserID: test.userID}, test.tenantID, TenantMember); !errors.Is(err, ErrMembershipNotFound) {
+ t.Errorf("CheckTenant(%q) error = %v, want %v", test.userID, err, ErrMembershipNotFound)
+ }
+ }
+ if err := checker.CheckTenant(t.Context(), Subject{UserID: "admin-user"}, "tenant-1", TenantNormalMember); !errors.Is(err, ErrMembershipNotFound) {
+ t.Errorf("admin CheckTenant(normal member) error = %v, want %v", err, ErrMembershipNotFound)
+ }
+ if err := checker.CheckTenant(t.Context(), Subject{UserID: "normal-user"}, "tenant-1", TenantNormalMember); err != nil {
+ t.Errorf("normal member CheckTenant(normal member) error = %v, want nil", err)
+ }
+
+ tenantIDs, err := (&databaseSource{db: db}).activeTenantIDsForUser(t.Context(), "role-user")
+ if err != nil {
+ t.Fatalf("load member Tenant IDs: %v", err)
+ }
+ if len(tenantIDs) != 1 || tenantIDs[0] != "tenant-1" {
+ t.Fatalf("activeTenantIDsForUser() = %v, want [tenant-1]", tenantIDs)
+ }
+}
+
func TestDatabaseCheckerRejectsPrivateDatasetForOtherTenantMember(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/model_resources.go b/internal/permission/model_resources.go
index ec8c6499b0..e017eb4999 100644
--- a/internal/permission/model_resources.go
+++ b/internal/permission/model_resources.go
@@ -106,13 +106,7 @@ func (s *databaseSource) loadTenantOwnerIDs(ctx context.Context, tenantIDs []str
}
func (s *databaseSource) tenantIDsForSubject(ctx context.Context, subject Subject) ([]string, error) {
- var tenantIDs []string
- err := s.db.WithContext(ctx).Model(&entity.UserTenant{}).
- Distinct("tenant_id").
- Where("user_id = ? AND status = ? AND role IN ?", subject.UserID, string(entity.StatusValid), []string{
- string(RoleOwner), string(RoleAdmin), string(RoleNormal),
- }).
- Pluck("tenant_id", &tenantIDs).Error
+ tenantIDs, err := s.activeTenantIDsForUser(ctx, subject.UserID)
if err != nil {
return nil, err
}
diff --git a/internal/permission/policy_ce.go b/internal/permission/policy_ce.go
index 2a43d4fc29..4bb47a3d3c 100644
--- a/internal/permission/policy_ce.go
+++ b/internal/permission/policy_ce.go
@@ -184,6 +184,12 @@ func (p *communityPolicy) QueryScope(ctx context.Context, subject Subject, query
if err := source.validateDatasetTenants(ctx, subject.UserID); err != nil {
return QueryScope{}, true, err
}
+ // Enterprise tenant roles are stored as numeric IDs. The generic SQL fast
+ // path cannot resolve those IDs safely, so let the normal resource checks
+ // evaluate candidate IDs through databaseSource.GetMembership instead.
+ if tenantRoleMembershipEnabled(source.db) {
+ return QueryScope{}, false, nil
+ }
return QueryScope{apply: func(query *gorm.DB) *gorm.DB {
db := source.db.WithContext(ctx)
diff --git a/internal/permission/tenant_role_ee.go b/internal/permission/tenant_role_ee.go
new file mode 100644
index 0000000000..4832542960
--- /dev/null
+++ b/internal/permission/tenant_role_ee.go
@@ -0,0 +1,32 @@
+//
+// 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 permission
+
+import (
+ "context"
+
+ "gorm.io/gorm"
+)
+
+// Community memberships use the legacy string roles and have no Tenant role table.
+func tenantRoleMembershipEnabled(*gorm.DB) bool {
+ return false
+}
+
+func isTenantRoleID(context.Context, *gorm.DB, string, string) (bool, error) {
+ return false, nil
+}
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index d7c8475b62..1077e84246 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -595,27 +595,29 @@ func (m *ModelProviderService) addModelToInstance(ctx context.Context, tenantID,
extraFields[k] = v
}
}
- extraBytes, err := json.Marshal(extraFields)
- if err != nil {
- return fmt.Errorf("fail to marshal extra: %w", err)
+ if err = m.createModelRecord(ctx, dao.DB, provider.ID, instance.ID, model.ModelName, combinedType, "active", extraFields); err != nil {
+ return fmt.Errorf("fail to create model '%s': %w", model.ModelName, err)
}
- modelID := common.GenerateToken()
- tenantModel := &entity.TenantModel{
- ID: modelID,
- ModelName: model.ModelName,
- ModelType: int(combinedType),
- ProviderID: provider.ID,
- InstanceID: instance.ID,
- Status: "active",
- Extra: string(extraBytes),
- }
+ return nil
+}
- if err = m.modelDAO.Create(ctx, dao.DB, tenantModel); err != nil {
- return fmt.Errorf("fail to create model '%s': %w", model.ModelName, err)
+func (m *ModelProviderService) createModelRecord(ctx context.Context, db *gorm.DB, providerID, instanceID, modelName string, modelType entity.ModelType, status string, extra map[string]interface{}) error {
+ extraBytes, err := json.Marshal(extra)
+ if err != nil {
+ return fmt.Errorf("fail to marshal model extra: %w", err)
}
- return nil
+ model := &entity.TenantModel{
+ ID: common.GenerateToken(),
+ ModelName: modelName,
+ ModelType: int(modelType),
+ ProviderID: providerID,
+ InstanceID: instanceID,
+ Status: status,
+ Extra: string(extraBytes),
+ }
+ return m.modelDAO.Create(ctx, db, model)
}
func (m *ModelProviderService) ListProviderInstances(ctx context.Context, providerIDOrName, userID string) ([]map[string]interface{}, common.ErrorCode, error) {
diff --git a/internal/service/tenant.go b/internal/service/tenant.go
index 63d91506f7..3ea4af93de 100644
--- a/internal/service/tenant.go
+++ b/internal/service/tenant.go
@@ -18,6 +18,7 @@ package service
import (
"context"
+ "errors"
"fmt"
"ragflow/internal/common"
"ragflow/internal/dao"
@@ -26,6 +27,9 @@ import (
"ragflow/internal/permission"
permissionresponse "ragflow/internal/permission/response"
"strings"
+
+ "gorm.io/gorm"
+ "gorm.io/gorm/clause"
)
// TenantService tenant service
@@ -40,6 +44,66 @@ type TenantService struct {
docEngine engine.DocEngine
}
+type tenantInviteRole struct {
+ value string
+ roleID *int32
+ roleName string
+}
+
+// tenantMemberPermission keeps community membership policy in shared code and
+// lets Enterprise apply its Tenant permission grants through the EE hook.
+func tenantMemberPermission(ctx context.Context, db *gorm.DB, userID, tenantID string, required int32) (*entity.UserTenant, int32, error) {
+ membership, mask, handled, err := tenantMemberPermissionEE(ctx, db, userID, tenantID, required)
+ if err != nil || handled {
+ return membership, mask, err
+ }
+
+ requirement := permission.TenantMember
+ if required != 0 {
+ requirement = permission.TenantOwner
+ }
+ checker := permission.NewDatabaseChecker(db)
+ if err := checker.CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, requirement); err != nil {
+ return nil, 0, err
+ }
+ var communityMembership entity.UserTenant
+ if err := db.WithContext(ctx).
+ Where("user_id = ? AND tenant_id = ? AND status = ?", userID, tenantID, string(entity.StatusValid)).
+ Take(&communityMembership).Error; err != nil {
+ return nil, 0, err
+ }
+ return &communityMembership, 0, nil
+}
+
+func tenantRoleErrorCode(err error) common.ErrorCode {
+ var coded *common.CodedError
+ if errors.As(err, &coded) {
+ return coded.Code
+ }
+ code, _ := permissionresponse.Normalize(err)
+ return code
+}
+
+func recordTenantPermissionChange(tx *gorm.DB, tenantID, actorUserID, eventType, targetType, targetID, resourceType, resourceID, actionType string, beforePermission, afterPermission int32, beforeData, afterData interface{}) error {
+ return recordTenantPermissionChangeEE(tx, tenantID, actorUserID, eventType, targetType, targetID, resourceType, resourceID, actionType, beforePermission, afterPermission, beforeData, afterData)
+}
+
+func resolveTenantInviteRole(tx *gorm.DB, tenantID string) (tenantInviteRole, error) {
+ role, handled, err := resolveTenantInviteRoleEE(tx, tenantID)
+ if err != nil || handled {
+ return role, err
+ }
+ return tenantInviteRole{value: TenantRoleNormal}, nil
+}
+
+func (s *TenantService) checkTenantInviteEnabled(ctx context.Context, tenantID string) (common.ErrorCode, error) {
+ code, handled, err := s.checkTenantInviteEnabledEE(ctx, tenantID)
+ if err != nil || handled {
+ return code, err
+ }
+ return common.CodeSuccess, nil
+}
+
// NewTenantService create tenant service
func NewTenantService() *TenantService {
return &TenantService{
@@ -733,9 +797,8 @@ type TenantMemberResponse struct {
// ListMembers returns all non-owner members of tenantID.
func (s *TenantService) ListMembers(ctx context.Context, userID, tenantID string) ([]*TenantMemberResponse, common.ErrorCode, error) {
- if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, permission.TenantOwner); err != nil {
- code, permissionErr := permissionresponse.Normalize(err)
- return nil, code, permissionErr
+ if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, entity.TenantPermissionManageMembers); err != nil {
+ return nil, tenantRoleErrorCode(err), err
}
rows, err := s.userTenantDAO.GetMembersByTenantID(ctx, dao.DB, tenantID)
if err != nil {
@@ -778,13 +841,18 @@ type AddMemberResponse struct {
// AddMember invites a user (by email) to the tenant.
func (s *TenantService) AddMember(ctx context.Context, userID, tenantID string, req *AddMemberRequest) (*AddMemberResponse, common.ErrorCode, error) {
- if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, permission.TenantOwner); err != nil {
- code, permissionErr := permissionresponse.Normalize(err)
- return nil, code, permissionErr
+ if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, entity.TenantPermissionManageMembers); err != nil {
+ return nil, tenantRoleErrorCode(err), err
+ }
+ if req == nil {
+ return nil, common.CodeArgumentError, fmt.Errorf("request is required")
}
if strings.TrimSpace(req.Email) == "" {
return nil, common.CodeArgumentError, fmt.Errorf("email is required")
}
+ if code, err := s.checkTenantInviteEnabled(ctx, tenantID); err != nil {
+ return nil, code, err
+ }
invitee, err := s.userDAO.GetByEmail(ctx, dao.DB, req.Email)
if err != nil {
@@ -798,13 +866,13 @@ func (s *TenantService) AddMember(ctx context.Context, userID, tenantID string,
userTenant, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, invitee.ID, tenantID)
if err == nil {
if userTenant != nil {
- switch userTenant.Role {
- case TenantRoleOwner:
+ switch {
+ case userTenant.Role == TenantRoleOwner:
return nil, common.CodeDataError, fmt.Errorf("user is already the tenant owner")
- case TenantRoleNormal, TenantRoleAdmin:
- return nil, common.CodeDataError, fmt.Errorf("user is already a member")
- case TenantRoleInvite:
+ 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")
}
}
}
@@ -821,8 +889,15 @@ func (s *TenantService) AddMember(ctx context.Context, userID, tenantID string,
InvitedBy: userID,
Status: &status,
}
- if err = s.userTenantDAO.Create(ctx, dao.DB, ut); err != nil {
- return nil, common.CodeServerError, fmt.Errorf("failed to create invitation: %w", err)
+ 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)
+ }
+ 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})
+ })
+ if err != nil {
+ return nil, tenantRoleErrorCode(err), err
}
avatar := ""
@@ -845,40 +920,72 @@ func (s *TenantService) RemoveMember(ctx context.Context, userID, tenantID, targ
return common.CodeServerError, fmt.Errorf("userTenantDAO not initialized")
}
if userID != "" && userID == targetUserID {
- removed, err := s.userTenantDAO.DeleteByUserAndTenantAndRole(ctx, dao.DB, userID, tenantID, TenantRoleInvite)
+ 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 {
- return common.CodeServerError, fmt.Errorf("failed to decline tenant invitation: %w", err)
+ return tenantRoleErrorCode(err), err
}
if removed {
return common.CodeSuccess, nil
}
}
- requirement := permission.TenantOwner
if userID == targetUserID {
- requirement = permission.TenantMember
- }
- if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, requirement); err != nil {
- code, permissionErr := permissionresponse.Normalize(err)
- return code, permissionErr
- }
- targetMembership, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, targetUserID, tenantID)
- if err != nil {
- if dao.IsNotFoundErr(err) {
- return common.CodeDataError, fmt.Errorf("user is not a tenant member")
+ if _, _, err := tenantMemberPermission(ctx, dao.DB.WithContext(ctx), userID, tenantID, 0); err != nil {
+ return tenantRoleErrorCode(err), err
}
- return common.CodeServerError, fmt.Errorf("failed to load tenant member: %w", err)
- }
- if targetMembership.Role == TenantRoleOwner {
- return common.CodeArgumentError, fmt.Errorf("cannot remove the tenant owner")
- }
- if err := s.userTenantDAO.DeleteByUserAndTenant(ctx, dao.DB, targetUserID, tenantID); err != nil {
- return common.CodeServerError, fmt.Errorf("failed to remove member: %w", 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
+ 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 {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return common.NewCodedError(common.CodeDataError, "user is not a tenant member")
+ }
+ return fmt.Errorf("failed to load tenant member: %w", err)
+ }
+ if targetMembership.Role == TenantRoleOwner {
+ return common.NewCodedError(common.CodeArgumentError, "cannot remove the tenant owner")
+ }
+ if err := tx.Unscoped().Where("id = ?", targetMembership.ID).Delete(&entity.UserTenant{}).Error; err != nil {
+ return fmt.Errorf("failed to remove member: %w", err)
+ }
+ eventType, actionType := "tenant.member.removed", "remove"
+ if targetMembership.Role == TenantRoleInvite {
+ 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})
+ })
+ if err != nil {
+ return tenantRoleErrorCode(err), err
}
return common.CodeSuccess, nil
}
-// AcceptInvite transitions the calling user's role from "invite" → "normal" for the given tenant.
+// AcceptInvite assigns the Tenant default role when a pending invitation is accepted.
func (s *TenantService) AcceptInvite(ctx context.Context, userID, tenantID string) (common.ErrorCode, error) {
if s.userTenantDAO == nil {
return common.CodeServerError, fmt.Errorf("userTenantDAO not initialized")
@@ -890,8 +997,35 @@ func (s *TenantService) AcceptInvite(ctx context.Context, userID, tenantID strin
if existing.Role != TenantRoleInvite {
return common.CodeArgumentError, fmt.Errorf("no pending invitation to accept")
}
- if err := s.userTenantDAO.UpdateRoleByUserAndTenant(ctx, dao.DB, userID, tenantID, TenantRoleNormal); err != nil {
- return common.CodeServerError, fmt.Errorf("failed to accept invitation: %w", err)
+ 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)
+ }
+ role, err := resolveTenantInviteRole(tx, tenantID)
+ if err != nil {
+ return err
+ }
+ 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 {
+ 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}
+ if role.roleID != nil {
+ after["role_id"] = *role.roleID
+ }
+ if role.roleName != "" {
+ after["role_name"] = role.roleName
+ }
+ return recordTenantPermissionChange(tx, tenantID, userID, "tenant.member.joined", "user", userID, "tenant_membership", membership.ID, "join", 0, 0, before, after)
+ })
+ if err != nil {
+ return tenantRoleErrorCode(err), err
}
return common.CodeSuccess, nil
}
diff --git a/internal/service/tenant_invite_ee.go b/internal/service/tenant_invite_ee.go
new file mode 100644
index 0000000000..800ebb3794
--- /dev/null
+++ b/internal/service/tenant_invite_ee.go
@@ -0,0 +1,33 @@
+//
+// 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"
+
+ "ragflow/internal/common"
+
+ "gorm.io/gorm"
+)
+
+func resolveTenantInviteRoleEE(*gorm.DB, string) (tenantInviteRole, bool, error) {
+ return tenantInviteRole{}, false, nil
+}
+
+func (*TenantService) checkTenantInviteEnabledEE(context.Context, string) (common.ErrorCode, bool, error) {
+ return common.CodeSuccess, false, nil
+}
diff --git a/internal/service/tenant_role_ee.go b/internal/service/tenant_role_ee.go
new file mode 100644
index 0000000000..ab78c144b3
--- /dev/null
+++ b/internal/service/tenant_role_ee.go
@@ -0,0 +1,33 @@
+//
+// 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"
+
+ "ragflow/internal/entity"
+
+ "gorm.io/gorm"
+)
+
+func tenantMemberPermissionEE(context.Context, *gorm.DB, string, string, int32) (*entity.UserTenant, int32, bool, error) {
+ return nil, 0, false, nil
+}
+
+func recordTenantPermissionChangeEE(*gorm.DB, string, string, string, string, string, string, string, string, int32, int32, interface{}, interface{}) error {
+ return nil
+}
diff --git a/internal/service/tenant_test.go b/internal/service/tenant_test.go
index 7ac2bbe41d..b0c9b601a5 100644
--- a/internal/service/tenant_test.go
+++ b/internal/service/tenant_test.go
@@ -38,7 +38,7 @@ func setupTenantPermissionTestDB(t *testing.T) *gorm.DB {
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
- if err := db.AutoMigrate(&entity.UserTenant{}); err != nil {
+ if err := db.AutoMigrate(&entity.UserTenant{}, &entity.PermissionChangeLog{}); err != nil {
t.Fatalf("migrate tenant permission table: %v", err)
}
originalDB := dao.DB
diff --git a/internal/service/user.go b/internal/service/user.go
index 9ea3fa31f3..3e7d743e08 100644
--- a/internal/service/user.go
+++ b/internal/service/user.go
@@ -235,12 +235,16 @@ func (s *UserService) Register(ctx context.Context, req *RegisterRequest) (*enti
}
db := dao.GetDB()
+ tenantDAO := dao.NewTenantDAO()
if err = db.Transaction(func(tx *gorm.DB) error {
if err = tx.Create(user).Error; err != nil {
return fmt.Errorf("failed to create user: %w", err)
}
+ if err = dao.ApplyDefaultTenantInviteEnabled(ctx, tx, tenant); err != nil {
+ return fmt.Errorf("failed to initialize tenant invitation setting: %w", err)
+ }
- if err = tx.Create(tenant).Error; err != nil {
+ if err = tenantDAO.Create(ctx, tx, tenant); err != nil {
return fmt.Errorf("failed to create tenant: %w", err)
}