Skip to content

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

refa: remove permission service wrappers (#21856)

buua436e9b1b6b48f26
diff --git a/internal/handler/agent_component.go b/internal/handler/agent_component.go
index cc9e8c45a1..8fb3793fad 100644
--- a/internal/handler/agent_component.go
+++ b/internal/handler/agent_component.go
@@ -45,7 +45,6 @@ import (
"ragflow/internal/dao"
"ragflow/internal/entity/models"
"ragflow/internal/permission"
- "ragflow/internal/service"
)
// GetComponentInputForm GET /api/v1/agents/:canvas_id/components/:component_id/input-form
@@ -211,7 +210,7 @@ func (h *AgentHandler) DebugComponent(c *gin.Context) {
common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Model inputs are available only for Agent components.")
return
}
- if err := service.CheckCanvasPermission(c.Request.Context(), permission.Subject{UserID: user.ID}, canvasID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(c.Request.Context(), permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}, permission.OperationUpdate); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
common.ResponseWithCodeData(c, common.CodeOperatingError, nil, canvasNoAccessMessage)
} else {
diff --git a/internal/handler/dataset.go b/internal/handler/dataset.go
index 3cebce9954..a2164efa57 100644
--- a/internal/handler/dataset.go
+++ b/internal/handler/dataset.go
@@ -32,6 +32,7 @@ import (
"github.com/gin-gonic/gin"
"ragflow/internal/common"
+ "ragflow/internal/dao"
"ragflow/internal/permission"
"ragflow/internal/service"
"ragflow/internal/service/billing"
@@ -1157,7 +1158,7 @@ func (h *DatasetsHandler) ListMetadataFlattened(c *gin.Context) {
ctx := c.Request.Context()
// Check access for each dataset
for _, datasetID := range datasetIDs {
- if err := h.datasetsService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
respondPermissionError(c, err, false)
return
}
diff --git a/internal/handler/dataset_artifact.go b/internal/handler/dataset_artifact.go
index 91bc80efa2..2c8eb123cd 100644
--- a/internal/handler/dataset_artifact.go
+++ b/internal/handler/dataset_artifact.go
@@ -73,7 +73,7 @@ func (h *DatasetArtifactHandler) datasetOwner(c *gin.Context, datasetID string)
common.ErrorWithCode(c, common.CodeNotFound, "dataset not found")
return nil, "", ""
}
- if err := h.datasetSvc.CheckAccess(c.Request.Context(), permission.Subject{UserID: user.ID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(c.Request.Context(), permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
respondPermissionError(c, err, false)
return nil, "", ""
}
diff --git a/internal/handler/dify_retrieval_handler.go b/internal/handler/dify_retrieval_handler.go
index 4c3bdff5f4..b7b984cfd6 100644
--- a/internal/handler/dify_retrieval_handler.go
+++ b/internal/handler/dify_retrieval_handler.go
@@ -45,7 +45,6 @@ import (
// KBServiceIface abstracts KnowledgebaseService for the Dify handler.
type KBServiceIface interface {
GetKnowledgebaseByID(ctx context.Context, kbID string) (*entity.Knowledgebase, error)
- CheckAccess(ctx context.Context, subject permission.Subject, datasetID string, operation permission.Operation) error
}
// ModelCreator supplies typed model instances to Dify retrieval.
@@ -130,14 +129,19 @@ type difyRecord struct {
// --- Handler ---
+type resourcePermissionChecker interface {
+ CheckResource(context.Context, permission.Subject, permission.ResourceRef, permission.Operation) error
+}
+
// DifyRetrievalHandler handles Dify-compatible retrieval requests.
type DifyRetrievalHandler struct {
- kbSvc KBServiceIface
- modelFactory ModelCreator
- metadataSvc MetadataServiceIface
- retrievalSvc RetrievalServiceIface
- docDAO DocumentDAOIface
- docEngine engine.DocEngine
+ kbSvc KBServiceIface
+ permissionChecker resourcePermissionChecker
+ modelFactory ModelCreator
+ metadataSvc MetadataServiceIface
+ retrievalSvc RetrievalServiceIface
+ docDAO DocumentDAOIface
+ docEngine engine.DocEngine
}
// NewDifyRetrievalHandler creates a new DifyRetrievalHandler.
@@ -152,12 +156,13 @@ func NewDifyRetrievalHandler(
docEngine engine.DocEngine,
) *DifyRetrievalHandler {
return &DifyRetrievalHandler{
- kbSvc: kbSvc,
- modelFactory: modelFactory,
- metadataSvc: metadataSvc,
- retrievalSvc: retrievalSvc,
- docDAO: docDAO,
- docEngine: docEngine,
+ kbSvc: kbSvc,
+ permissionChecker: permission.NewDatabaseChecker(dao.DB),
+ modelFactory: modelFactory,
+ metadataSvc: metadataSvc,
+ retrievalSvc: retrievalSvc,
+ docDAO: docDAO,
+ docEngine: docEngine,
}
}
@@ -216,7 +221,7 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
return
}
- if err := h.kbSvc.CheckAccess(ctx, permission.Subject{UserID: user.ID}, req.KnowledgeID, permission.OperationUse); err != nil {
+ if err := h.permissionChecker.CheckResource(ctx, permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: req.KnowledgeID}, permission.OperationUse); err != nil {
respondHTTPPermissionError(c, err, false)
return
}
diff --git a/internal/handler/dify_retrieval_handler_test.go b/internal/handler/dify_retrieval_handler_test.go
index 29a71c0506..45893ff625 100644
--- a/internal/handler/dify_retrieval_handler_test.go
+++ b/internal/handler/dify_retrieval_handler_test.go
@@ -56,9 +56,9 @@ func (m *mockKBService) GetKnowledgebaseByID(ctx context.Context, kbID string) (
}, nil
}
-func (m *mockKBService) CheckAccess(ctx context.Context, subject permission.Subject, datasetID string, operation permission.Operation) error {
+func (m *mockKBService) CheckResource(ctx context.Context, subject permission.Subject, resource permission.ResourceRef, operation permission.Operation) error {
if m.checkAccessFn != nil {
- return m.checkAccessFn(ctx, subject, datasetID, operation)
+ return m.checkAccessFn(ctx, subject, resource.ID, operation)
}
return nil
}
@@ -155,13 +155,15 @@ func (m *mockDocEngine) GetChunk(ctx context.Context, _, _ string, _ []string) (
// --- Helper ---
func setupDifyTest(userID string) (*DifyRetrievalHandler, *gin.Engine) {
+ kbSvc := &mockKBService{}
h := &DifyRetrievalHandler{
- kbSvc: &mockKBService{},
- modelFactory: mockModelFactory{},
- metadataSvc: &mockMetadataService{},
- retrievalSvc: &mockRetrievalService{},
- docDAO: &mockDocDAO{},
- docEngine: &mockDocEngine{},
+ kbSvc: kbSvc,
+ permissionChecker: kbSvc,
+ modelFactory: mockModelFactory{},
+ metadataSvc: &mockMetadataService{},
+ retrievalSvc: &mockRetrievalService{},
+ docDAO: &mockDocDAO{},
+ docEngine: &mockDocEngine{},
}
gin.SetMode(gin.TestMode)
@@ -380,7 +382,7 @@ func TestDifyRetrieval_NoAuth(t *testing.T) {
func TestDifyRetrieval_Unauthorized(t *testing.T) {
h, r := setupDifyTest("user1")
- h.kbSvc = &mockKBService{
+ kbSvc := &mockKBService{
checkAccessFn: func(ctx context.Context, subject permission.Subject, datasetID string, operation permission.Operation) error {
if operation != permission.OperationUse {
t.Errorf("dataset operation = %q, want %q", operation, permission.OperationUse)
@@ -388,6 +390,8 @@ func TestDifyRetrieval_Unauthorized(t *testing.T) {
return permission.ErrPermissionDenied
},
}
+ h.kbSvc = kbSvc
+ h.permissionChecker = kbSvc
w := httptest.NewRecorder()
body := `{"knowledge_id": "kb1", "query": "test"}`
req, _ := http.NewRequest("POST", "/api/v1/dify/retrieval", strings.NewReader(body))
diff --git a/internal/handler/document.go b/internal/handler/document.go
index 623d425629..49a1445040 100644
--- a/internal/handler/document.go
+++ b/internal/handler/document.go
@@ -646,7 +646,7 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
}
ctx := c.Request.Context()
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -1040,7 +1040,7 @@ func (h *DocumentHandler) UploadDocuments(c *gin.Context) {
common.ResponseWithCodeData(c, common.CodeDataError, nil, fmt.Sprintf("Can't find the dataset with ID %s!", datasetID))
return
}
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: user.ID}, kb.ID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: kb.ID}, permission.OperationUpdate); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -1424,7 +1424,7 @@ func (h *DocumentHandler) ListIngestionTasks(c *gin.Context) {
var err error
ctx := c.Request.Context()
if req.DatasetID != nil {
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: userID}, *req.DatasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: *req.DatasetID}, permission.OperationRead); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -1482,7 +1482,7 @@ func (h *DocumentHandler) StartIngestionTask(c *gin.Context) {
operationLog.UserID = userID
ctx := c.Request.Context()
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRun); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRun); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -1565,7 +1565,7 @@ func (h *DocumentHandler) ParseDocuments(c *gin.Context) {
userID := c.GetString("user_id")
ctx := c.Request.Context()
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRun); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRun); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -1607,7 +1607,7 @@ func (h *DocumentHandler) StopParseDocuments(c *gin.Context) {
}
ctx := c.Request.Context()
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRun); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRun); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -1633,7 +1633,7 @@ func (h *DocumentHandler) MetadataSummaryByDataset(c *gin.Context) {
return
}
ctx := c.Request.Context()
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -1841,7 +1841,7 @@ func (h *DocumentHandler) handleBatchUpdateDocumentMetadatas(c *gin.Context) {
return
}
ctx := c.Request.Context()
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, datasetID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationUpdate); err != nil {
respondPermissionError(c, err, false)
return
}
diff --git a/internal/handler/file_commit.go b/internal/handler/file_commit.go
index d7dc072cd5..ff5d688d6b 100644
--- a/internal/handler/file_commit.go
+++ b/internal/handler/file_commit.go
@@ -24,7 +24,6 @@ import (
"ragflow/internal/dao"
"ragflow/internal/entity"
"ragflow/internal/permission"
- "ragflow/internal/service"
"ragflow/internal/service/file"
"strconv"
"strings"
@@ -103,7 +102,7 @@ func CommitFolderResolver(h *FileCommitHandler, entityType, urlParam string) gin
if c.Request.Method == "GET" || c.Request.Method == "HEAD" {
operation = permission.OperationRead
}
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: user.ID}, id, operation); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: id}, operation); err != nil {
respondPermissionError(c, err, true)
c.Abort()
return
diff --git a/internal/handler/tenant.go b/internal/handler/tenant.go
index 31b420b19c..d21b46e25b 100644
--- a/internal/handler/tenant.go
+++ b/internal/handler/tenant.go
@@ -35,6 +35,7 @@ import (
dataset "ragflow/internal/service/dataset"
"go.uber.org/zap"
+ "ragflow/internal/dao"
)
// TenantHandler tenant handler
@@ -276,7 +277,7 @@ func (h *TenantHandler) CreateChunkStore(c *gin.Context) {
ctx := c.Request.Context()
// Check authorization - user must have access to this kb
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, req.KBID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: req.KBID}, permission.OperationUpdate); err != nil {
respondPermissionError(c, err, false)
return
}
@@ -324,7 +325,7 @@ func (h *TenantHandler) DeleteChunkStore(c *gin.Context) {
}
// Check authorization
- if err := h.datasetService.CheckAccess(ctx, permission.Subject{UserID: user.ID}, req.KBID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: user.ID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: req.KBID}, permission.OperationUpdate); err != nil {
respondPermissionError(c, err, false)
return
}
diff --git a/internal/router/router.go b/internal/router/router.go
index 8ebf5ec38c..5f8deece9b 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -592,7 +592,7 @@ func (r *Router) Setup(engine *gin.Engine) {
// with the binary, but the endpoint is gated behind auth so the
// /pipelines namespace is already auth-protected when per-tenant
// user pipelines (dataflow canvases) are added later. Those will
- // reuse user_canvas + CheckCanvasPermission for ownership checks.
+ // reuse user_canvas and the permission checker for ownership checks.
// Query: ?type=builtin returns built-in templates (default).
v1.GET("/pipelines", r.pipelineHandler.ListPipelines)
v1.GET("/pipelines/:id", r.pipelineHandler.GetPipeline)
diff --git a/internal/service/agent.go b/internal/service/agent.go
index 2e690a7da8..af62c5e557 100644
--- a/internal/service/agent.go
+++ b/internal/service/agent.go
@@ -508,10 +508,17 @@ func (s *AgentService) ListAgentFilters(ctx context.Context, userID, canvasCateg
return s.listCompilationGroupFilters(ctx, userID)
}
- canvasIDs, err := AccessibleCanvasIDs(ctx, permission.Subject{UserID: userID}, permission.OperationRead)
+ canvasScope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindCanvas,
+ Operation: permission.OperationRead,
+ })
if err != nil {
return nil, common.CodeServerError, fmt.Errorf("failed to scope accessible canvases: %w", err)
}
+ canvasIDs := canvasScope.ResourceIDs
+ if canvasScope.Mode == permission.ScopeNone {
+ canvasIDs = []string{}
+ }
owners, err := s.canvasDAO.GetOwnerFilterByCanvasIDs(ctx, dao.DB, canvasIDs, canvasCategory)
if err != nil {
return nil, common.CodeServerError, fmt.Errorf("failed to aggregate agent owners: %w", err)
@@ -636,11 +643,18 @@ func toAgentItem(c *dao.UserCanvasListItem) *AgentItem {
// then delegates to the DAO.
func (s *AgentService) ListAgents(ctx context.Context, userID string, keywords string, page, pageSize int, terms []dao.OrderTerm, ownerIDs []string, canvasCategory, canvasType string, tags []string) (*ListAgentsResponse, common.ErrorCode, error) {
subject := permission.Subject{UserID: userID}
- canvasIDs, err := AccessibleCanvasIDs(ctx, subject, permission.OperationRead)
+ checker := permission.NewDatabaseChecker(dao.DB)
+ canvasScope, err := checker.Scope(ctx, subject, permission.ScopeQuery{
+ Kind: permission.ResourceKindCanvas,
+ Operation: permission.OperationRead,
+ })
if err != nil {
return nil, common.CodeServerError, fmt.Errorf("failed to scope accessible canvases: %w", err)
}
- checker := permission.NewDatabaseChecker(dao.DB)
+ canvasIDs := canvasScope.ResourceIDs
+ if canvasScope.Mode == permission.ScopeNone {
+ canvasIDs = []string{}
+ }
if len(ownerIDs) > 0 {
for _, id := range ownerIDs {
if id == userID {
@@ -1103,7 +1117,7 @@ func (s *AgentService) loadCanvasForUser(ctx context.Context, userID, canvasID s
if userID == "" {
return nil, dao.ErrUserCanvasNotFound
}
- if err := CheckCanvasPermission(ctx, permission.Subject{UserID: userID}, canvasID, operation); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}, operation); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
return nil, dao.ErrUserCanvasNotFound
}
@@ -1165,7 +1179,7 @@ func (s *AgentService) UpdateAgent(ctx context.Context, userID, canvasID string,
ownerUserID := canvasInstance.UserID
if v, ok := patch["permission"]; ok {
- shareErr := CheckCanvasPermission(ctx, permission.Subject{UserID: userID}, canvasID, permission.OperationShare)
+ shareErr := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}, permission.OperationShare)
if shareErr != nil {
if !errors.Is(shareErr, permission.ErrPermissionDenied) {
return fmt.Errorf("check agent sharing permission: %w", shareErr)
@@ -1377,7 +1391,7 @@ func (s *AgentService) ResetAgent(ctx context.Context, userID, canvasID string)
// orphan version rows. Canvas delete access is decided by the permission
// policy, including its sharing rules.
func (s *AgentService) DeleteAgent(ctx context.Context, userID, canvasID string) error {
- if err := CheckCanvasPermission(ctx, permission.Subject{UserID: userID}, canvasID, permission.OperationDelete); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}, permission.OperationDelete); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
return ErrAgentNotOwner
}
diff --git a/internal/service/agent_sessions.go b/internal/service/agent_sessions.go
index 733fa6806d..c87a5f4bc1 100644
--- a/internal/service/agent_sessions.go
+++ b/internal/service/agent_sessions.go
@@ -77,7 +77,7 @@ type DeleteAgentSessionsResponse struct {
// CheckCanvasAccess returns true when the user is the canvas owner or
// holds team-level permission for the owner's tenant.
func (s *AgentService) CheckCanvasAccess(ctx context.Context, userID, canvasID string) (bool, error) {
- err := CheckCanvasPermission(ctx, permission.Subject{UserID: userID}, canvasID, permission.OperationRead)
+ err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}, permission.OperationRead)
if errors.Is(err, permission.ErrResourceNotFound) {
return false, dao.ErrUserCanvasNotFound
}
@@ -352,7 +352,7 @@ func (s *AgentService) DeleteAgentSessionItem(ctx context.Context, userID, agent
return false, common.CodeArgumentError, errors.New("session_id is required")
}
subject := permission.Subject{UserID: userID}
- if err := CheckCanvasPermission(ctx, subject, agentID, permission.OperationUse); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, subject, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: agentID}, permission.OperationUse); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
return false, common.CodeOperatingError, errors.New("agent not found or no permission")
}
@@ -384,7 +384,7 @@ func (s *AgentService) DeleteAgentSessions(ctx context.Context, userID, agentID
return nil, common.CodeArgumentError, errors.New("agent_id is required")
}
- if err := CheckCanvasPermission(ctx, permission.Subject{UserID: userID}, agentID, permission.OperationUse); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: agentID}, permission.OperationUse); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
return nil, common.CodeDataError, fmt.Errorf("you don't have permission to delete sessions for agent %s", agentID)
}
@@ -460,10 +460,17 @@ func (s *AgentService) DeleteAgentSessions(ctx context.Context, userID, agentID
// ListAgentTags list agent tags
func (s *AgentService) ListAgentTags(ctx context.Context, userID, canvasCategory string) ([]AgentTagCount, common.ErrorCode, error) {
- canvasIDs, err := AccessibleCanvasIDs(ctx, permission.Subject{UserID: userID}, permission.OperationRead)
+ canvasScope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindCanvas,
+ Operation: permission.OperationRead,
+ })
if err != nil {
return nil, common.CodeServerError, err
}
+ canvasIDs := canvasScope.ResourceIDs
+ if canvasScope.Mode == permission.ScopeNone {
+ canvasIDs = []string{}
+ }
counts, err := s.canvasDAO.ListTagsByCanvasIDs(ctx, dao.DB, canvasIDs, canvasCategory)
if err != nil {
return nil, common.CodeServerError, err
@@ -551,7 +558,7 @@ func normalizeAgentTags(rawTags interface{}) (string, error) {
// UpdateAgentTags normalises tags and persists them on a single canvas.
func (s *AgentService) UpdateAgentTags(ctx context.Context, userID, canvasID string, tags interface{}) (bool, common.ErrorCode, error) {
- if err := CheckCanvasPermission(ctx, permission.Subject{UserID: userID}, canvasID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}, permission.OperationUpdate); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
return false, common.CodeOperatingError, errors.New("agent not found or no permission")
}
@@ -618,7 +625,7 @@ func (s *AgentService) CreateAgentSession(ctx context.Context, req *CreateAgentS
return nil, common.CodeArgumentError, errors.New("create agent session: user_id is required")
}
- if err := CheckCanvasPermission(ctx, permission.Subject{UserID: req.UserID}, req.AgentID, permission.OperationRun); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: req.UserID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: req.AgentID}, permission.OperationRun); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
return nil, common.CodeOperatingError, errors.New("agent not found or no permission")
}
diff --git a/internal/service/bot.go b/internal/service/bot.go
index 6b216bcca6..3e2ccc1530 100644
--- a/internal/service/bot.go
+++ b/internal/service/bot.go
@@ -35,6 +35,7 @@ import (
"ragflow/internal/engine/kvrocks"
"ragflow/internal/entity"
"ragflow/internal/permission"
+ permissionresponse "ragflow/internal/permission/response"
)
// BotService coordinates chatbot + agentbot reads and the matching
@@ -67,21 +68,21 @@ func NewBotService(agentSvc *AgentService) *BotService {
func (s *BotService) ChatbotInfo(ctx context.Context, userID, dialogID string) (
title, avatar, prologue, llmID string, hasWebSearch bool, ec common.ErrorCode, err error,
) {
- if err = checkChatPermission(ctx, nil, userID, dialogID, permission.OperationRead); err != nil {
- ec, err = normalizeChatPermissionError(err)
+ if err = permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: dialogID}, permission.OperationRead); err != nil {
+ ec, err = permissionresponse.NormalizeHidden(err)
return "", "", "", "", false, ec, err
}
dialog, err := s.chatDAO.GetDialogByID(ctx, dao.DB, dialogID)
if err != nil {
if dao.IsNotFoundErr(err) {
- ec, err = normalizeChatPermissionError(permission.ErrResourceNotFound)
+ ec, err = permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return "", "", "", "", false, ec, err
}
return "", "", "", "", false, common.CodeServerError, err
}
if dialog == nil {
- ec, err = normalizeChatPermissionError(permission.ErrResourceNotFound)
+ ec, err = permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return "", "", "", "", false, ec, err
}
pc := dialog.PromptConfig
@@ -247,7 +248,7 @@ func (s *BotService) loadCanvas(ctx context.Context, userID, agentID string, ope
if userID == "" {
return nil, dao.ErrUserCanvasNotFound
}
- if err := CheckCanvasPermission(ctx, permission.Subject{UserID: userID}, agentID, operation); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: agentID}, operation); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
return nil, dao.ErrUserCanvasNotFound
}
diff --git a/internal/service/bot_completion.go b/internal/service/bot_completion.go
index a0ca1b395f..bf2d82f0de 100644
--- a/internal/service/bot_completion.go
+++ b/internal/service/bot_completion.go
@@ -45,6 +45,7 @@ import (
"ragflow/internal/common"
"ragflow/internal/entity"
"ragflow/internal/permission"
+ permissionresponse "ragflow/internal/permission/response"
)
// ChatbotSSEFrame is one envelope pushed to the SSE writer by the
@@ -297,20 +298,20 @@ func (s *BotService) ChatbotCompletion(
}
req.Question = question
// 1. Authorize and load the dialog before touching session state.
- if err := checkChatPermission(ctx, nil, userID, dialogID, permission.OperationRun); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: dialogID}, permission.OperationRun); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
dialog, err := s.chatDAO.GetDialogByID(ctx, dao.DB, dialogID)
if err != nil {
if dao.IsNotFoundErr(err) {
- code, normalizedErr := normalizeChatPermissionError(permission.ErrResourceNotFound)
+ code, normalizedErr := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalizedErr
}
return nil, common.CodeServerError, err
}
if dialog == nil {
- code, normalizedErr := normalizeChatPermissionError(permission.ErrResourceNotFound)
+ code, normalizedErr := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalizedErr
}
diff --git a/internal/service/canvas_permission.go b/internal/service/canvas_permission.go
deleted file mode 100644
index 568f2ca298..0000000000
--- a/internal/service/canvas_permission.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package service
-
-import (
- "context"
-
- "ragflow/internal/dao"
- "ragflow/internal/permission"
-)
-
-// CheckCanvasPermission checks a canvas operation through the active permission policy.
-func CheckCanvasPermission(ctx context.Context, subject permission.Subject, canvasID string, operation permission.Operation) error {
- return permission.NewDatabaseChecker(dao.DB).CheckResource(
- ctx,
- subject,
- permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID},
- operation,
- )
-}
-
-// AccessibleCanvasIDs returns the canvas IDs visible for an operation.
-func AccessibleCanvasIDs(ctx context.Context, subject permission.Subject, operation permission.Operation) ([]string, error) {
- scope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, subject, permission.ScopeQuery{
- Kind: permission.ResourceKindCanvas,
- Operation: operation,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode == permission.ScopeNone {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
diff --git a/internal/service/chat.go b/internal/service/chat.go
index 9cec5b42cd..c8101fc07a 100644
--- a/internal/service/chat.go
+++ b/internal/service/chat.go
@@ -50,6 +50,11 @@ var ReadOnlyFields = map[string]struct{}{
"update_date": {},
}
+type resourceScopeChecker interface {
+ CheckResource(context.Context, permission.Subject, permission.ResourceRef, permission.Operation) error
+ Scope(context.Context, permission.Subject, permission.ScopeQuery) (permission.Scope, error)
+}
+
// ChatService chat service
type ChatService struct {
chatDAO *dao.ChatDAO
@@ -61,9 +66,10 @@ type ChatService struct {
// NewChatService create chat service
func NewChatService() *ChatService {
return &ChatService{
- chatDAO: dao.NewChatDAO(),
- kbDAO: dao.NewKnowledgebaseDAO(),
- tenantDAO: dao.NewTenantDAO(),
+ chatDAO: dao.NewChatDAO(),
+ kbDAO: dao.NewKnowledgebaseDAO(),
+ tenantDAO: dao.NewTenantDAO(),
+ permissionChecker: permission.NewDatabaseChecker(dao.DB),
}
}
@@ -102,10 +108,17 @@ type ListChatsResponse struct {
// ListChats list chats for a user
func (s *ChatService) ListChats(ctx context.Context, userID, status, keywords, id, name string, page, pageSize int, terms []dao.OrderTerm, ownerIDs []string) (*ListChatsResponse, error) {
- chatIDs, err := accessibleChatIDs(ctx, s.permissionChecker, userID, permission.OperationRead)
+ chatScope, err := s.permissionChecker.Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindChat,
+ Operation: permission.OperationRead,
+ })
if err != nil {
return nil, err
}
+ chatIDs := chatScope.ResourceIDs
+ if chatScope.Mode == permission.ScopeNone {
+ chatIDs = []string{}
+ }
var ownerFilter []string
if len(ownerIDs) > 0 {
ownerFilter = make([]string, 0, len(ownerIDs))
@@ -189,7 +202,7 @@ func (s *ChatService) Create(ctx context.Context, userID string, req map[string]
code, normalized := permissionresponse.Normalize(err)
return nil, code, normalized
}
- if err := checkFeatureAction(ctx, userID, "chat", permission.ActionWrite); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "chat", permission.ActionWrite); err != nil {
code, normalized := permissionresponse.Normalize(err)
return nil, code, normalized
}
@@ -346,7 +359,7 @@ func (s *ChatService) Create(ctx context.Context, userID string, req map[string]
if err := s.chatDAO.Create(ctx, tx, chat); err != nil {
return err
}
- return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindChat, chat.ID)
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chat.ID})
}); err != nil {
return nil, common.CodeDataError, fmt.Errorf("failed to create chat: %w", err)
}
@@ -401,7 +414,7 @@ func (s *ChatService) validateCreateDatasetIDs(ctx context.Context, value interf
}
for _, datasetID := range normalizedIDs {
- if err := CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUse); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationUse); err != nil {
_, permissionErr := permissionresponse.Normalize(err)
return nil, permissionErr
}
@@ -427,7 +440,7 @@ func validateChatDatasetAccess(ctx context.Context, userID string, kbIDs entity.
if !ok || strings.TrimSpace(datasetID) == "" {
continue
}
- if err := CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUse); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationUse); err != nil {
_, permissionErr := permissionresponse.Normalize(err)
return permissionErr
}
@@ -807,7 +820,7 @@ const (
)
func (s *ChatService) getChatForOperation(ctx context.Context, userID, chatID string, operation permission.Operation) (*entity.Chat, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, operation); err != nil {
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, operation); err != nil {
return nil, err
}
return s.chatDAO.GetByIDAndStatus(ctx, dao.DB, chatID, string(entity.StatusValid))
@@ -1141,7 +1154,7 @@ func (s *ChatService) validateRESTDatasetIDs(ctx context.Context, value interfac
continue
}
datasetID := fmt.Sprint(item)
- if err := CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUse); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationUse); err != nil {
_, permissionErr := permissionresponse.Normalize(err)
return nil, permissionErr
}
@@ -1328,10 +1341,17 @@ func checkDuplicateChatIDs(ids []string) ([]string, []string) {
func (s *ChatService) BulkDeleteChats(ctx context.Context, userID string, req *BulkDeleteChatsRequest) (map[string]interface{}, error) {
ids := req.IDs
if len(ids) == 0 && req.DeleteAll {
- chatIDs, err := accessibleChatIDs(ctx, s.permissionChecker, userID, permission.OperationDelete)
+ chatScope, err := s.permissionChecker.Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindChat,
+ Operation: permission.OperationDelete,
+ })
if err != nil {
return nil, err
}
+ chatIDs := chatScope.ResourceIDs
+ if chatScope.Mode == permission.ScopeNone {
+ chatIDs = []string{}
+ }
ids = append(ids, chatIDs...)
if len(ids) == 0 {
return map[string]interface{}{}, nil
@@ -1390,7 +1410,7 @@ type GetChatResponse struct {
// GetChat gets chat detail by ID with permission check
func (s *ChatService) GetChat(ctx context.Context, userID string, chatID string) (*GetChatResponse, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationRead); err != nil {
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationRead); err != nil {
return nil, err
}
diff --git a/internal/service/chat_channel.go b/internal/service/chat_channel.go
index 74e956943a..ad4e112c13 100644
--- a/internal/service/chat_channel.go
+++ b/internal/service/chat_channel.go
@@ -28,6 +28,7 @@ import (
"ragflow/internal/dao"
"ragflow/internal/entity"
"ragflow/internal/permission"
+ permissionresponse "ragflow/internal/permission/response"
)
type ChatChannelService struct {
@@ -77,10 +78,17 @@ func getChatChannelRuntimeProvider() ChatChannelRuntimeProvider {
}
func (s *ChatChannelService) List(ctx context.Context, userID string) ([]*entity.ChatChannelListResponse, error) {
- channelIDs, err := accessibleChatChannelIDs(ctx, userID, permission.OperationRead)
+ channelScope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindChatChannel,
+ Operation: permission.OperationRead,
+ })
if err != nil {
return nil, err
}
+ channelIDs := channelScope.ResourceIDs
+ if channelScope.Mode != permission.ScopeIDs {
+ channelIDs = []string{}
+ }
return s.chatChannelDAO.ListByIDs(ctx, dao.DB, channelIDs)
}
@@ -92,11 +100,11 @@ func (s *ChatChannelService) CreateChatChannel(ctx context.Context, userID, name
if err != nil {
return nil, err
}
- if err := checkFeatureAction(ctx, userID, "chat", permission.ActionWrite); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "chat", permission.ActionWrite); err != nil {
return nil, err
}
if chatID != nil && *chatID != "" {
- if err := checkChatPermission(ctx, nil, userID, *chatID, permission.OperationUse); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: *chatID}, permission.OperationUse); err != nil {
return nil, err
}
}
@@ -114,7 +122,7 @@ func (s *ChatChannelService) CreateChatChannel(ctx context.Context, userID, name
if err := s.chatChannelDAO.Create(ctx, tx, row); err != nil {
return err
}
- return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindChatChannel, row.ID)
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindChatChannel, ID: row.ID})
}); err != nil {
return nil, err
}
@@ -127,15 +135,15 @@ func (s *ChatChannelService) CreateChatChannel(ctx context.Context, userID, name
}
func (s *ChatChannelService) GetChatChannel(ctx context.Context, userID, channelID string) (*entity.ChatChannel, common.ErrorCode, error) {
- if err := checkChatChannelPermission(ctx, userID, channelID, permission.OperationRead); err != nil {
- code, permissionErr := normalizeChatChannelPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatChannel, ID: channelID}, permission.OperationRead); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, code, permissionErr
}
channel, err := s.chatChannelDAO.GetByID(ctx, dao.DB, channelID)
if err != nil {
if dao.IsNotFoundErr(err) {
- code, permissionErr := normalizeChatChannelPermissionError(permission.ErrResourceNotFound)
+ code, permissionErr := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, permissionErr
}
return nil, common.CodeServerError, err
@@ -144,14 +152,14 @@ func (s *ChatChannelService) GetChatChannel(ctx context.Context, userID, channel
}
func (s *ChatChannelService) UpdateChatChannel(ctx context.Context, userID, channelID string, req map[string]interface{}) (*entity.ChatChannel, common.ErrorCode, error) {
- if err := checkChatChannelPermission(ctx, userID, channelID, permission.OperationUpdate); err != nil {
- code, permissionErr := normalizeChatChannelPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatChannel, ID: channelID}, permission.OperationUpdate); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, code, permissionErr
}
channel, err := s.chatChannelDAO.GetByID(ctx, dao.DB, channelID)
if err != nil {
if dao.IsNotFoundErr(err) {
- code, permissionErr := normalizeChatChannelPermissionError(permission.ErrResourceNotFound)
+ code, permissionErr := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, permissionErr
}
return nil, common.CodeServerError, err
@@ -188,13 +196,13 @@ func (s *ChatChannelService) UpdateChatChannel(ctx context.Context, userID, chan
return nil, common.CodeDataError, errors.New("chat_id must be string or null")
}
if chatID != "" {
- if err := checkChatPermission(ctx, nil, userID, chatID, permission.OperationUse); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationUse); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
if channel.TenantID != userID {
- if err := checkChatPermission(ctx, nil, channel.TenantID, chatID, permission.OperationUse); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: channel.TenantID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationUse); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
}
@@ -212,7 +220,7 @@ func (s *ChatChannelService) UpdateChatChannel(ctx context.Context, userID, chan
updated, err := s.chatChannelDAO.GetByID(ctx, dao.DB, channelID)
if err != nil {
if dao.IsNotFoundErr(err) {
- code, permissionErr := normalizeChatChannelPermissionError(permission.ErrResourceNotFound)
+ code, permissionErr := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, permissionErr
}
return nil, common.CodeServerError, err
@@ -222,14 +230,14 @@ func (s *ChatChannelService) UpdateChatChannel(ctx context.Context, userID, chan
// GetChatChannelRuntime returns the live runtime metadata for a WhatsApp chat channel.
func (s *ChatChannelService) GetChatChannelRuntime(ctx context.Context, userID, channelID string) (map[string]any, common.ErrorCode, error) {
- if err := checkChatChannelPermission(ctx, userID, channelID, permission.OperationUse); err != nil {
- code, permissionErr := normalizeChatChannelPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatChannel, ID: channelID}, permission.OperationUse); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, code, permissionErr
}
conn, err := s.chatChannelDAO.GetByID(ctx, dao.DB, channelID)
if err != nil {
if dao.IsNotFoundErr(err) {
- code, permissionErr := normalizeChatChannelPermissionError(permission.ErrResourceNotFound)
+ code, permissionErr := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, permissionErr
}
return nil, common.CodeServerError, err
@@ -304,14 +312,14 @@ func (s *ChatChannelService) HandleIncomingMessage(ctx context.Context, msg Chat
}
func (s *ChatChannelService) DeleteChatChannel(ctx context.Context, userID, channelID string) (bool, common.ErrorCode, error) {
- if err := checkChatChannelPermission(ctx, userID, channelID, permission.OperationDelete); err != nil {
- code, permissionErr := normalizeChatChannelPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatChannel, ID: channelID}, permission.OperationDelete); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return false, code, permissionErr
}
channel, err := s.chatChannelDAO.GetByID(ctx, dao.DB, channelID)
if err != nil {
if dao.IsNotFoundErr(err) {
- code, permissionErr := normalizeChatChannelPermissionError(permission.ErrResourceNotFound)
+ code, permissionErr := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return false, code, permissionErr
}
return false, common.CodeServerError, err
diff --git a/internal/service/chat_channel_permission.go b/internal/service/chat_channel_permission.go
deleted file mode 100644
index 91aef6fcba..0000000000
--- a/internal/service/chat_channel_permission.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// 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"
- "ragflow/internal/dao"
- "ragflow/internal/permission"
- permissionresponse "ragflow/internal/permission/response"
-)
-
-func checkChatChannelPermission(ctx context.Context, userID, channelID string, operation permission.Operation) error {
- return permission.NewDatabaseChecker(dao.DB).CheckResource(
- ctx,
- permission.Subject{UserID: userID},
- permission.ResourceRef{Kind: permission.ResourceKindChatChannel, ID: channelID},
- operation,
- )
-}
-
-func accessibleChatChannelIDs(ctx context.Context, userID string, operation permission.Operation) ([]string, error) {
- scope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
- Kind: permission.ResourceKindChatChannel,
- Operation: operation,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode != permission.ScopeIDs {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
-
-func normalizeChatChannelPermissionError(err error) (common.ErrorCode, error) {
- return permissionresponse.NormalizeHidden(err)
-}
diff --git a/internal/service/chat_permission.go b/internal/service/chat_permission.go
deleted file mode 100644
index 9c0bb13112..0000000000
--- a/internal/service/chat_permission.go
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// 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"
- "ragflow/internal/dao"
- "ragflow/internal/permission"
- permissionresponse "ragflow/internal/permission/response"
-)
-
-type resourceChecker interface {
- CheckResource(context.Context, permission.Subject, permission.ResourceRef, permission.Operation) error
-}
-
-type resourceScopeChecker interface {
- resourceChecker
- Scope(context.Context, permission.Subject, permission.ScopeQuery) (permission.Scope, error)
-}
-
-func checkChatPermission(ctx context.Context, checker resourceChecker, userID, chatID string, operation permission.Operation) error {
- if checker == nil {
- checker = permission.NewDatabaseChecker(dao.DB)
- }
- return checker.CheckResource(
- ctx,
- permission.Subject{UserID: userID},
- permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID},
- operation,
- )
-}
-
-func checkChatSessionPermission(ctx context.Context, checker resourceChecker, userID, sessionID string, operation permission.Operation) error {
- if checker == nil {
- checker = permission.NewDatabaseChecker(dao.DB)
- }
- return checker.CheckResource(
- ctx,
- permission.Subject{UserID: userID},
- permission.ResourceRef{Kind: permission.ResourceKindChatSession, ID: sessionID},
- operation,
- )
-}
-
-func accessibleChatIDs(ctx context.Context, checker resourceScopeChecker, userID string, operation permission.Operation) ([]string, error) {
- if checker == nil {
- checker = permission.NewDatabaseChecker(dao.DB)
- }
- scope, err := checker.Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
- Kind: permission.ResourceKindChat,
- Operation: operation,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode == permission.ScopeNone {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
-
-func accessibleChatSessionIDs(ctx context.Context, checker resourceScopeChecker, userID, chatID string, operation permission.Operation) ([]string, error) {
- if checker == nil {
- checker = permission.NewDatabaseChecker(dao.DB)
- }
- chatRef := permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}
- if err := checkChatPermission(ctx, checker, userID, chatID, permission.OperationRead); err != nil {
- return nil, err
- }
- scope, err := checker.Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
- Kind: permission.ResourceKindChatSession,
- Parent: chatRef,
- Operation: operation,
- Entry: &chatRef,
- EntryOp: permission.OperationRead,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode == permission.ScopeNone {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
-
-func normalizeChatPermissionError(err error) (common.ErrorCode, error) {
- return permissionresponse.NormalizeHidden(err)
-}
diff --git a/internal/service/chat_session.go b/internal/service/chat_session.go
index 4980983014..5d21f07f1f 100644
--- a/internal/service/chat_session.go
+++ b/internal/service/chat_session.go
@@ -38,6 +38,7 @@ import (
"ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
"ragflow/internal/permission"
+ permissionresponse "ragflow/internal/permission/response"
"ragflow/internal/utility"
)
@@ -98,10 +99,11 @@ type ChatSessionService struct {
// NewChatSessionService create chat session service
func NewChatSessionService() *ChatSessionService {
return &ChatSessionService{
- chatSessionDAO: dao.NewChatSessionDAO(),
- pipeline: NewChatPipelineService(),
- modelFactory: NewModelFactory(),
- docEngine: engine.Get(),
+ chatSessionDAO: dao.NewChatSessionDAO(),
+ permissionChecker: permission.NewDatabaseChecker(dao.DB),
+ pipeline: NewChatPipelineService(),
+ modelFactory: NewModelFactory(),
+ docEngine: engine.Get(),
}
}
@@ -131,8 +133,8 @@ type ChatSessionPayload struct {
// ListChatSessions lists chat sessions for a dialog
func (s *ChatSessionService) ListChatSessions(ctx context.Context, userID, chatID, sessionID, name, sessionUserID string, terms []dao.OrderTerm, page, pageSize int, options ...dao.ConversationHistoryOptions) (*ListChatSessionsResponse, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationRead); err != nil {
- _, normalizedErr := normalizeChatPermissionError(err)
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationRead); err != nil {
+ _, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, normalizedErr
}
@@ -155,7 +157,7 @@ func (s *ChatSessionService) ListChatSessions(ctx context.Context, userID, chatI
}
accessible, err := checker.FilterResources(ctx, permission.Subject{UserID: userID}, refs, permission.OperationRead)
if err != nil {
- _, normalizedErr := normalizeChatPermissionError(err)
+ _, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, normalizedErr
}
allowedIDs := make(map[string]bool, len(accessible))
@@ -174,8 +176,8 @@ func (s *ChatSessionService) ListChatSessions(ctx context.Context, userID, chatI
// GetSession returns one chat session after ownership validation.
func (s *ChatSessionService) GetSession(ctx context.Context, userID, chatID, sessionID string, options ...dao.ConversationHistoryOptions) (*ChatSessionPayload, common.ErrorCode, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationRead); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationRead); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
@@ -189,8 +191,8 @@ func (s *ChatSessionService) GetSession(ctx context.Context, userID, chatID, ses
if session.DialogID != chatID {
return nil, common.CodeDataError, errors.New("session does not belong to this chat")
}
- if err = checkChatSessionPermission(ctx, s.permissionChecker, userID, sessionID, permission.OperationRead); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err = s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatSession, ID: sessionID}, permission.OperationRead); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
@@ -204,8 +206,8 @@ func (s *ChatSessionService) GetSession(ctx context.Context, userID, chatID, ses
// CreateSession create a session in a dialog
func (s *ChatSessionService) CreateSession(ctx context.Context, userID, chatID string, req map[string]interface{}) (*ChatSessionPayload, common.ErrorCode, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationCreate); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationCreate); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
@@ -265,8 +267,8 @@ func (s *ChatSessionService) CreateSession(ctx context.Context, userID, chatID s
// DeleteSessions delete a session in a dialog
func (s *ChatSessionService) DeleteSessions(ctx context.Context, userID, chatID string, req map[string]interface{}) (interface{}, string, common.ErrorCode, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationRead); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationRead); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, "", code, normalizedErr
}
@@ -278,12 +280,22 @@ func (s *ChatSessionService) DeleteSessions(ctx context.Context, userID, chatID
if !hasIDs || len(sessionIDs) == 0 {
deleteAll, _ := req["delete_all"].(bool)
if deleteAll {
- authorizedSessionIDs, err := accessibleChatSessionIDs(ctx, s.permissionChecker, userID, chatID, permission.OperationDelete)
+ chatRef := permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}
+ sessionScope, err := s.permissionChecker.Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindChatSession,
+ Parent: chatRef,
+ Operation: permission.OperationDelete,
+ Entry: &chatRef,
+ EntryOp: permission.OperationRead,
+ })
if err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, "", code, normalizedErr
}
- sessionIDs = authorizedSessionIDs
+ sessionIDs = sessionScope.ResourceIDs
+ if sessionScope.Mode == permission.ScopeNone {
+ sessionIDs = []string{}
+ }
if len(sessionIDs) == 0 {
return map[string]interface{}{}, "success", common.CodeSuccess, nil
}
@@ -315,8 +327,8 @@ func (s *ChatSessionService) DeleteSessions(ctx context.Context, userID, chatID
continue
}
- if werr := checkChatSessionPermission(ctx, s.permissionChecker, userID, sid, permission.OperationDelete); werr != nil {
- _, normalizedErr := normalizeChatPermissionError(werr)
+ if werr := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatSession, ID: sid}, permission.OperationDelete); werr != nil {
+ _, normalizedErr := permissionresponse.NormalizeHidden(werr)
errorsList = append(errorsList, fmt.Sprintf("%s: %s", normalizedErr, sid))
continue
}
@@ -436,8 +448,8 @@ func checkDuplicateChatSessionIDs(ids []string) ([]string, []string) {
// UpdateSession updates one chat session after Python-style field validation.
func (s *ChatSessionService) UpdateSession(ctx context.Context, userID, chatID, sessionID string, req map[string]interface{}) (*ChatSessionPayload, common.ErrorCode, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationRead); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationRead); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
@@ -449,8 +461,8 @@ func (s *ChatSessionService) UpdateSession(ctx context.Context, userID, chatID,
return nil, common.CodeServerError, err
}
- if err = checkChatSessionPermission(ctx, s.permissionChecker, userID, sessionID, permission.OperationUpdate); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err = s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatSession, ID: sessionID}, permission.OperationUpdate); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
@@ -508,8 +520,8 @@ func (s *ChatSessionService) UpdateSession(ctx context.Context, userID, chatID,
}
func (s *ChatSessionService) DeleteSessionMessage(ctx context.Context, userID, chatID, sessionID, msgID string) (*ChatSessionPayload, common.ErrorCode, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationRead); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationRead); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
@@ -521,8 +533,8 @@ func (s *ChatSessionService) DeleteSessionMessage(ctx context.Context, userID, c
return nil, common.CodeDataError, errors.New("session not found")
}
- if werr := checkChatSessionPermission(ctx, s.permissionChecker, userID, sessionID, permission.OperationUpdate); werr != nil {
- code, normalizedErr := normalizeChatPermissionError(werr)
+ if werr := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatSession, ID: sessionID}, permission.OperationUpdate); werr != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(werr)
return nil, code, normalizedErr
}
@@ -568,8 +580,8 @@ func (s *ChatSessionService) DeleteSessionMessage(ctx context.Context, userID, c
}
func (s *ChatSessionService) UpdateMessageFeedback(ctx context.Context, userID, chatID, sessionID, msgID string, req map[string]interface{}) (*ChatSessionPayload, common.ErrorCode, error) {
- if err := checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationRead); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err := s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationRead); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
@@ -583,8 +595,8 @@ func (s *ChatSessionService) UpdateMessageFeedback(ctx context.Context, userID,
return nil, common.CodeDataError, errors.New("session not found")
}
- if err = checkChatSessionPermission(ctx, s.permissionChecker, userID, sessionID, permission.OperationUpdate); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err = s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatSession, ID: sessionID}, permission.OperationUpdate); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return nil, code, normalizedErr
}
dialog, err := s.chatSessionDAO.GetDialogByID(ctx, dao.DB, chatID)
@@ -1157,8 +1169,8 @@ func (s *ChatSessionService) ChatCompletions(
var dialog *entity.Chat
var session *entity.ChatSession
if chatID != "" {
- if err = checkChatPermission(ctx, s.permissionChecker, userID, chatID, permission.OperationRun); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err = s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChat, ID: chatID}, permission.OperationRun); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return fail(common.NewCodedError(code, normalizedErr.Error()))
}
dialog, err = s.chatSessionDAO.GetDialogByID(ctx, dao.DB, chatID)
@@ -1173,8 +1185,8 @@ func (s *ChatSessionService) ChatCompletions(
if session.DialogID != chatID {
return fail(common.NewCodedError(common.CodeDataError, "Session does not belong to this chat!"))
}
- if err = checkChatSessionPermission(ctx, s.permissionChecker, userID, sessionID, permission.OperationRun); err != nil {
- code, normalizedErr := normalizeChatPermissionError(err)
+ if err = s.permissionChecker.CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindChatSession, ID: sessionID}, permission.OperationRun); err != nil {
+ code, normalizedErr := permissionresponse.NormalizeHidden(err)
return fail(common.NewCodedError(code, normalizedErr.Error()))
}
} else if storeHistoryMessages {
diff --git a/internal/service/chunk/chunk.go b/internal/service/chunk/chunk.go
index d853f228eb..0a21d86753 100644
--- a/internal/service/chunk/chunk.go
+++ b/internal/service/chunk/chunk.go
@@ -636,7 +636,7 @@ func (s *ChunkService) cancelAllTasksOfDoc(ctx context.Context, doc *entity.Docu
}
func (s *ChunkService) StopParsing(ctx context.Context, userID, datasetID string, req service.StopParsingRequest) (*service.StopParsingResponse, common.ErrorCode, error) {
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRun); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRun); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
@@ -711,7 +711,7 @@ func (s *ChunkService) checkDatasetAccess(ctx context.Context, datasetID, userID
if s.checkDatasetAccessFunc != nil {
return s.checkDatasetAccessFunc(datasetID, userID)
}
- return service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, operation)
+ return permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, operation)
}
func (s *ChunkService) getKnowledgebaseByID(ctx context.Context, datasetID string) (*entity.Knowledgebase, error) {
diff --git a/internal/service/connector.go b/internal/service/connector.go
index 410d5febe0..565a73571e 100644
--- a/internal/service/connector.go
+++ b/internal/service/connector.go
@@ -282,7 +282,7 @@ func (s *ConnectorService) CreateConnector(ctx context.Context, userID string, r
if err != nil {
return nil, err
}
- if err := checkFeatureAction(ctx, userID, "file", permission.ActionWrite); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "file", permission.ActionWrite); err != nil {
return nil, err
}
if req.RefreshFreq != nil && *req.RefreshFreq <= 0 {
@@ -323,7 +323,7 @@ func (s *ConnectorService) CreateConnector(ctx context.Context, userID string, r
if err := s.connectorDAO.Create(ctx, tx, connector); err != nil {
return err
}
- return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindConnector, connector.ID)
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connector.ID})
}); err != nil {
return nil, err
}
@@ -336,7 +336,7 @@ func (s *ConnectorService) GetConnector(ctx context.Context, connectorID, userID
if strings.TrimSpace(connectorID) == "" {
return nil, ErrConnectorIDRequired
}
- if err := checkConnectorPermission(ctx, userID, connectorID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}, permission.OperationRead); err != nil {
return nil, err
}
@@ -386,7 +386,7 @@ func (s *ConnectorService) ListConnectors(ctx context.Context, userID, requested
func (s *ConnectorService) TestConnector(ctx context.Context, connectorID, userID string, config entity.JSONMap) error {
var storedConnector *entity.Connector
if connectorID != "" {
- permissionErr := checkConnectorPermission(ctx, userID, connectorID, permission.OperationUse)
+ permissionErr := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}, permission.OperationUse)
if permissionErr != nil && !errors.Is(permissionErr, permission.ErrResourceNotFound) {
return permissionErr
}
@@ -945,8 +945,8 @@ func (s *ConnectorService) DeleteConnector(ctx context.Context, connectorID, use
if connectorID == "" {
return false, common.CodeDataError, fmt.Errorf("connector_id is required")
}
- if err := checkConnectorPermission(ctx, userID, connectorID, permission.OperationDelete); err != nil {
- code, permissionErr := normalizeConnectorPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}, permission.OperationDelete); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return false, code, permissionErr
}
@@ -981,13 +981,13 @@ func (s *ConnectorService) UpdateConnector(ctx context.Context, connectorID, use
if connectorID == "" {
return nil, common.CodeDataError, fmt.Errorf("connector_id is required")
}
- if err := checkConnectorPermission(ctx, userID, connectorID, permission.OperationUpdate); err != nil {
- code, permissionErr := normalizeConnectorPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}, permission.OperationUpdate); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, code, permissionErr
}
if req != nil && (req.Reschedule || isConnectorCancelStatus(req.Status) || isConnectorScheduleStatus(req.Status)) {
- if err := checkConnectorPermission(ctx, userID, connectorID, permission.OperationRun); err != nil {
- code, permissionErr := normalizeConnectorPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}, permission.OperationRun); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, code, permissionErr
}
}
@@ -1080,8 +1080,8 @@ func (s *ConnectorService) RebuildConnector(ctx context.Context, connectorID, us
if kbID == "" {
return false, common.CodeArgumentError, fmt.Errorf("required argument is missing: kb_id")
}
- if err := checkConnectorPermission(ctx, userID, connectorID, permission.OperationRun); err != nil {
- code, permissionErr := normalizeConnectorPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}, permission.OperationRun); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return false, code, permissionErr
}
@@ -1095,7 +1095,7 @@ func (s *ConnectorService) RebuildConnector(ctx context.Context, connectorID, us
// The caller-supplied kb is targeted by delete + re-sync below, so it must
// be accessible to the caller and the connector must be bound to it.
- if err := CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, kbID, permission.OperationRun); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: kbID}, permission.OperationRun); err != nil {
common.Warn("rebuild denied: kb not accessible",
zap.String("connector_id", connectorID), zap.String("kb_id", kbID), zap.String("user_id", userID))
code, permissionErr := permissionresponse.Normalize(err)
@@ -1150,15 +1150,34 @@ func (s *ConnectorService) ResumeFailedSync(ctx context.Context, connectorID, us
if req.TaskID == "" {
return false, common.CodeArgumentError, fmt.Errorf("required argument is missing: task_id")
}
- if err := checkConnectorPermission(ctx, userID, connectorID, permission.OperationRun); err != nil {
- code, permissionErr := normalizeConnectorPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}, permission.OperationRun); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return false, code, permissionErr
}
- if err := checkSyncTaskPermission(ctx, userID, connectorID, req.TaskID, permission.OperationRun); err != nil {
- code, permissionErr := normalizeConnectorPermissionError(err)
+ connectorRef := permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}
+ taskScope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindSyncTask,
+ Parent: connectorRef,
+ Operation: permission.OperationRun,
+ Entry: &connectorRef,
+ EntryOp: permission.OperationRun,
+ })
+ if err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
+ return false, code, permissionErr
+ }
+ taskAccessible := false
+ for _, taskID := range taskScope.ResourceIDs {
+ if taskID == req.TaskID {
+ taskAccessible = true
+ break
+ }
+ }
+ if !taskAccessible {
+ code, permissionErr := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return false, code, permissionErr
}
- if err := CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, req.KbID, permission.OperationRun); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: req.KbID}, permission.OperationRun); err != nil {
code, permissionErr := permissionresponse.NormalizeHidden(err)
return false, code, permissionErr
}
@@ -1258,11 +1277,28 @@ func (s *ConnectorService) ListLog(ctx context.Context, connectorID, userID stri
return nil, 0, common.CodeDataError, fmt.Errorf("connector_id is required")
}
- taskIDs, err := accessibleSyncTaskIDs(ctx, userID, connectorID, permission.OperationRead)
+ checker := permission.NewDatabaseChecker(dao.DB)
+ subject := permission.Subject{UserID: userID}
+ connectorRef := permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}
+ if err := checker.CheckResource(ctx, subject, connectorRef, permission.OperationRead); err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
+ return nil, 0, code, permissionErr
+ }
+ taskScope, err := checker.Scope(ctx, subject, permission.ScopeQuery{
+ Kind: permission.ResourceKindSyncTask,
+ Parent: connectorRef,
+ Operation: permission.OperationRead,
+ Entry: &connectorRef,
+ EntryOp: permission.OperationRead,
+ })
if err != nil {
- code, permissionErr := normalizeConnectorPermissionError(err)
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, 0, code, permissionErr
}
+ taskIDs := taskScope.ResourceIDs
+ if taskScope.Mode != permission.ScopeIDs {
+ taskIDs = []string{}
+ }
if page < 1 {
page = 1
@@ -1291,19 +1327,41 @@ func (s *ConnectorService) ListLogs(ctx context.Context, userID, datasetID strin
}
if datasetID != "" {
- if err := CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, 0, code, permissionErr
}
}
- connectorIDs, err := accessibleConnectorIDs(ctx, userID, permission.OperationRead)
+ checker := permission.NewDatabaseChecker(dao.DB)
+ subject := permission.Subject{UserID: userID}
+ connectorScope, err := checker.Scope(ctx, subject, permission.ScopeQuery{
+ Kind: permission.ResourceKindConnector,
+ Operation: permission.OperationRead,
+ })
if err != nil {
return nil, 0, common.CodeServerError, err
}
- taskIDs, err := accessibleSyncTaskIDsForConnectors(ctx, userID, connectorIDs, permission.OperationRead)
- if err != nil {
- code, permissionErr := normalizeConnectorPermissionError(err)
- return nil, 0, code, permissionErr
+ connectorIDs := connectorScope.ResourceIDs
+ if connectorScope.Mode != permission.ScopeIDs {
+ connectorIDs = []string{}
+ }
+ var taskIDs []string
+ for _, connectorID := range connectorIDs {
+ connectorRef := permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}
+ taskScope, err := checker.Scope(ctx, subject, permission.ScopeQuery{
+ Kind: permission.ResourceKindSyncTask,
+ Parent: connectorRef,
+ Operation: permission.OperationRead,
+ Entry: &connectorRef,
+ EntryOp: permission.OperationRead,
+ })
+ if err != nil {
+ code, permissionErr := permissionresponse.NormalizeHidden(err)
+ return nil, 0, code, permissionErr
+ }
+ if taskScope.Mode == permission.ScopeIDs {
+ taskIDs = append(taskIDs, taskScope.ResourceIDs...)
+ }
}
offset, limit := 0, pageSize
diff --git a/internal/service/connector_permission.go b/internal/service/connector_permission.go
deleted file mode 100644
index 4e1e84766c..0000000000
--- a/internal/service/connector_permission.go
+++ /dev/null
@@ -1,108 +0,0 @@
-//
-// 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"
- "ragflow/internal/dao"
- "ragflow/internal/permission"
- permissionresponse "ragflow/internal/permission/response"
-)
-
-func checkConnectorPermission(ctx context.Context, userID, connectorID string, operation permission.Operation) error {
- return permission.NewDatabaseChecker(dao.DB).CheckResource(
- ctx,
- permission.Subject{UserID: userID},
- permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID},
- operation,
- )
-}
-
-func accessibleConnectorIDs(ctx context.Context, userID string, operation permission.Operation) ([]string, error) {
- scope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
- Kind: permission.ResourceKindConnector,
- Operation: operation,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode != permission.ScopeIDs {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
-
-func checkSyncTaskPermission(ctx context.Context, userID, connectorID, taskID string, operation permission.Operation) error {
- checker := permission.NewDatabaseChecker(dao.DB)
- connectorRef := permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}
- scope, err := checker.Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
- Kind: permission.ResourceKindSyncTask,
- Parent: connectorRef,
- Operation: operation,
- Entry: &connectorRef,
- EntryOp: operation,
- })
- if err != nil {
- return err
- }
- for _, scopedTaskID := range scope.ResourceIDs {
- if scopedTaskID == taskID {
- return nil
- }
- }
- return permission.ErrResourceNotFound
-}
-
-func accessibleSyncTaskIDs(ctx context.Context, userID, connectorID string, operation permission.Operation) ([]string, error) {
- checker := permission.NewDatabaseChecker(dao.DB)
- subject := permission.Subject{UserID: userID}
- connectorRef := permission.ResourceRef{Kind: permission.ResourceKindConnector, ID: connectorID}
- if err := checker.CheckResource(ctx, subject, connectorRef, permission.OperationRead); err != nil {
- return nil, err
- }
- scope, err := checker.Scope(ctx, subject, permission.ScopeQuery{
- Kind: permission.ResourceKindSyncTask,
- Parent: connectorRef,
- Operation: operation,
- Entry: &connectorRef,
- EntryOp: permission.OperationRead,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode != permission.ScopeIDs {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
-
-func accessibleSyncTaskIDsForConnectors(ctx context.Context, userID string, connectorIDs []string, operation permission.Operation) ([]string, error) {
- var taskIDs []string
- for _, connectorID := range connectorIDs {
- ids, err := accessibleSyncTaskIDs(ctx, userID, connectorID, operation)
- if err != nil {
- return nil, err
- }
- taskIDs = append(taskIDs, ids...)
- }
- return taskIDs, nil
-}
-
-func normalizeConnectorPermissionError(err error) (common.ErrorCode, error) {
- return permissionresponse.NormalizeHidden(err)
-}
diff --git a/internal/service/dataset/compilation_status.go b/internal/service/dataset/compilation_status.go
index acae524cfd..24ab4c83de 100644
--- a/internal/service/dataset/compilation_status.go
+++ b/internal/service/dataset/compilation_status.go
@@ -42,7 +42,7 @@ func (d *DatasetService) GetDatasetCompilationStatus(ctx context.Context, userID
if datasetID == "" {
return CompilationStatus{}, common.CodeDataError, errors.New("dataset_id is required")
}
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return CompilationStatus{}, code, permissionErr
}
diff --git a/internal/service/dataset/crud.go b/internal/service/dataset/crud.go
index 21a046ec7e..449fdeabd0 100644
--- a/internal/service/dataset/crud.go
+++ b/internal/service/dataset/crud.go
@@ -339,7 +339,7 @@ func (d *DatasetService) GetDataset(ctx context.Context, datasetID, userID strin
}
datasetID = normalizedID
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, code, permissionErr
}
@@ -351,7 +351,7 @@ func (d *DatasetService) GetDataset(ctx context.Context, datasetID, userID strin
}
data := datasetToMap(ctx, kb)
- operatorPermission, err := service.ResolveOperatorPermission(ctx, userID, permission.ResourceRef{
+ access, err := permission.NewDatabaseChecker(dao.DB).ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
Kind: permission.ResourceKindDataset,
ID: kb.ID,
})
@@ -359,7 +359,7 @@ func (d *DatasetService) GetDataset(ctx context.Context, datasetID, userID strin
code, permissionErr := permissionresponse.NormalizeHidden(err)
return nil, code, permissionErr
}
- data["operator_permission"] = operatorPermission
+ data["operator_permission"] = access.PermissionMask
size, err := d.documentDAO.SumSizeByDatasetID(ctx, dao.DB, datasetID)
if err != nil {
diff --git a/internal/service/dataset/embedding.go b/internal/service/dataset/embedding.go
index ad59f4b124..fb2bb1c9a2 100644
--- a/internal/service/dataset/embedding.go
+++ b/internal/service/dataset/embedding.go
@@ -41,7 +41,7 @@ func (d *DatasetService) CheckEmbedding(ctx context.Context, userID, datasetID s
if datasetID == "" {
return nil, common.CodeDataError, errors.New(`lack of "Dataset ID"`)
}
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUse); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationUse); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
diff --git a/internal/service/dataset/helpers.go b/internal/service/dataset/helpers.go
index fbc30d6ce3..ce8f1d0721 100644
--- a/internal/service/dataset/helpers.go
+++ b/internal/service/dataset/helpers.go
@@ -301,7 +301,7 @@ func pythonStringListRepr(items []string) string {
}
func canvasAccessibleForUser(ctx context.Context, subject permission.Subject, canvasID string) (bool, error) {
- err := service.CheckCanvasPermission(ctx, subject, canvasID, permission.OperationUse)
+ err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, subject, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}, permission.OperationUse)
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
return false, nil
}
diff --git a/internal/service/dataset/ingestion.go b/internal/service/dataset/ingestion.go
index f7bf67f6ea..59d7a46588 100644
--- a/internal/service/dataset/ingestion.go
+++ b/internal/service/dataset/ingestion.go
@@ -48,7 +48,7 @@ func (d *DatasetService) GetIngestionSummary(ctx context.Context, datasetID, use
if datasetID == "" {
return nil, common.CodeDataError, errors.New(`lack of "Dataset ID"`)
}
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
@@ -171,7 +171,7 @@ func (d *DatasetService) ListIngestionMessages(ctx context.Context, datasetID, u
if limit < 0 || limit > maxIngestionMessagesLimit {
return nil, common.CodeArgumentError, fmt.Errorf("limit must be between 1 and %d", maxIngestionMessagesLimit)
}
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
@@ -233,7 +233,7 @@ func (d *DatasetService) ListSyncLogs(ctx context.Context, datasetID, userID str
if datasetID == "" {
return nil, common.CodeDataError, errors.New(`lack of "Dataset ID"`)
}
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
@@ -292,7 +292,7 @@ func (d *DatasetService) ListIngestionLogs(ctx context.Context, datasetID, userI
if datasetID == "" {
return nil, common.CodeDataError, errors.New(`lack of "Dataset ID"`)
}
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
@@ -357,7 +357,7 @@ func (d *DatasetService) GetIngestionLog(ctx context.Context, datasetID, userID,
if logID == "" {
return nil, common.CodeDataError, errors.New(`lack of "Log ID"`)
}
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
diff --git a/internal/service/dataset/permission.go b/internal/service/dataset/lookup.go
similarity index 70%
rename from internal/service/dataset/permission.go
rename to internal/service/dataset/lookup.go
index 48ab0e9774..e5d6c1cb73 100644
--- a/internal/service/dataset/permission.go
+++ b/internal/service/dataset/lookup.go
@@ -7,15 +7,8 @@ import (
"ragflow/internal/dao"
"ragflow/internal/entity"
- "ragflow/internal/permission"
- "ragflow/internal/service"
)
-// CheckAccess authorizes an operation on a dataset under the active edition's policy.
-func (d *DatasetService) CheckAccess(ctx context.Context, subject permission.Subject, datasetID string, operation permission.Operation) error {
- return service.CheckDatasetAccess(ctx, subject, datasetID, operation)
-}
-
// GetKnowledgebaseByID resolves a dataset entity without applying permission
// checks. Upload needs the same existence-then-auth ordering as Python.
func (d *DatasetService) GetKnowledgebaseByID(ctx context.Context, datasetID string) (*entity.Knowledgebase, error) {
diff --git a/internal/service/dataset/metadata.go b/internal/service/dataset/metadata.go
index 28b5600834..ecc46d857b 100644
--- a/internal/service/dataset/metadata.go
+++ b/internal/service/dataset/metadata.go
@@ -18,7 +18,7 @@ import (
func (d *DatasetService) UpdateDocumentMetadataConfig(ctx context.Context, userID, datasetID, documentID string, req map[string]interface{}) (*entity.Document, common.ErrorCode, error) {
userID = strings.TrimSpace(userID)
datasetID = strings.TrimSpace(datasetID)
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationUpdate); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
@@ -72,7 +72,7 @@ func (d *DatasetService) UpdateDocumentMetadataConfig(ctx context.Context, userI
func (d *DatasetService) GetMetadataConfig(ctx context.Context, datasetID, userID string) (map[string]interface{}, common.ErrorCode, error) {
datasetID = strings.TrimSpace(datasetID)
userID = strings.TrimSpace(userID)
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
@@ -104,7 +104,7 @@ func (d *DatasetService) UpdateMetadataConfig(ctx context.Context, datasetID, us
datasetID = strings.TrimSpace(datasetID)
userID = strings.TrimSpace(userID)
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationUpdate); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
diff --git a/internal/service/dataset/search.go b/internal/service/dataset/search.go
index 8724332b5a..0dcf433c44 100644
--- a/internal/service/dataset/search.go
+++ b/internal/service/dataset/search.go
@@ -117,7 +117,7 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
var kbRecords []*entity.Knowledgebase
seenTenants := make(map[string]bool)
for _, datasetID := range datasetIDs {
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationUse); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationUse); err != nil {
common.Warn("SearchDatasets access denied", zap.String("datasetID", datasetID), zap.String("userID", userID))
_, permissionErr := permissionresponse.Normalize(err)
return nil, permissionErr
diff --git a/internal/service/dataset/tags.go b/internal/service/dataset/tags.go
index 960502dd00..c221377f9c 100644
--- a/internal/service/dataset/tags.go
+++ b/internal/service/dataset/tags.go
@@ -70,7 +70,7 @@ func (d *DatasetService) AggregateTags(ctx context.Context, datasetIDs []string,
}
authorized := make([]authorizedDataset, 0, len(orderedIDs))
for _, datasetID := range orderedIDs {
- if err := d.CheckAccess(ctx, permission.Subject{UserID: userID}, datasetID, permission.OperationRead); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return nil, code, permissionErr
}
diff --git a/internal/service/dataset_permission.go b/internal/service/dataset_permission.go
deleted file mode 100644
index b1f3c9edcd..0000000000
--- a/internal/service/dataset_permission.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package service
-
-import (
- "context"
-
- "ragflow/internal/dao"
- "ragflow/internal/permission"
-)
-
-// CheckDatasetAccess checks a dataset operation using the active edition's permission policy.
-func CheckDatasetAccess(ctx context.Context, subject permission.Subject, datasetID string, operation permission.Operation) error {
- return permission.NewDatabaseChecker(dao.DB).CheckResource(
- ctx,
- subject,
- permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID},
- operation,
- )
-}
diff --git a/internal/service/document/document_artifact.go b/internal/service/document/document_artifact.go
index 75a6f02826..0ecde2a717 100644
--- a/internal/service/document/document_artifact.go
+++ b/internal/service/document/document_artifact.go
@@ -235,7 +235,7 @@ func (s *DocumentService) sandboxArtifactAccessible(ctx context.Context, filenam
return false
}
for _, dialogID := range s.sandboxArtifactDialogIDsForUser(ctx, filename, userID) {
- if service.CheckCanvasPermission(ctx, permission.Subject{UserID: userID}, dialogID, permission.OperationRead) == nil {
+ if permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: dialogID}, permission.OperationRead) == nil {
return true
}
}
diff --git a/internal/service/document/document_crud.go b/internal/service/document/document_crud.go
index 3db512b3a2..c78220b1b3 100644
--- a/internal/service/document/document_crud.go
+++ b/internal/service/document/document_crud.go
@@ -220,7 +220,7 @@ func (s *DocumentService) DeleteDocuments(ctx context.Context, ids []string, del
// 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 {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationDeleteContent); err != nil {
_, permissionErr := permissionresponse.Normalize(err)
return 0, permissionErr
}
@@ -233,7 +233,7 @@ 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 &&
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationDeleteContent); err != nil &&
!errors.Is(err, permission.ErrPermissionDenied) && !errors.Is(err, permission.ErrMembershipNotFound) {
_, permissionErr := permissionresponse.Normalize(err)
return 0, permissionErr
diff --git a/internal/service/document/document_ingest.go b/internal/service/document/document_ingest.go
index 15d839c582..8f1c927690 100644
--- a/internal/service/document/document_ingest.go
+++ b/internal/service/document/document_ingest.go
@@ -66,7 +66,7 @@ func (s *DocumentService) Ingest(ctx context.Context, userID string, req *Ingest
if err != nil {
return common.CodeDataError, fmt.Errorf("dataset not found")
}
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, kb.ID, permission.OperationRun); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: kb.ID}, permission.OperationRun); err != nil {
code, permissionErr := permissionresponse.Normalize(err)
return code, permissionErr
}
diff --git a/internal/service/document/file2document.go b/internal/service/document/file2document.go
index c08b1eb1dc..5b3f32d030 100644
--- a/internal/service/document/file2document.go
+++ b/internal/service/document/file2document.go
@@ -29,7 +29,7 @@ import (
"ragflow/internal/entity"
"ragflow/internal/permission"
permissionresponse "ragflow/internal/permission/response"
- "ragflow/internal/service"
+
"ragflow/internal/utility"
)
@@ -155,7 +155,7 @@ func (s *File2DocumentService) LinkToDatasets(ctx context.Context, userID string
// ── 5. Validate KB permissions ────────────────────────────────────────────
for _, kb := range kbMap {
- if err := service.CheckDatasetAccess(ctx, permission.Subject{UserID: userID}, kb.ID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: kb.ID}, permission.OperationUpdate); err != nil {
_, permissionErr := permissionresponse.Normalize(err)
return permissionErr
}
diff --git a/internal/service/mcp.go b/internal/service/mcp.go
index 4ccfed8d1f..4fda9f2d0d 100644
--- a/internal/service/mcp.go
+++ b/internal/service/mcp.go
@@ -128,7 +128,7 @@ func (s *MCPService) CreateMCPServer(ctx context.Context, userID string, req Cre
code, normalized := permissionresponse.Normalize(err)
return nil, code, normalized
}
- if err := checkFeatureAction(ctx, userID, "mcp", permission.ActionWrite); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "mcp", permission.ActionWrite); err != nil {
code, normalized := permissionresponse.Normalize(err)
return nil, code, normalized
}
@@ -166,7 +166,7 @@ func (s *MCPService) CreateMCPServer(ctx context.Context, userID string, req Cre
if err := s.mcpServerDAO.CreateMCPServer(ctx, tx, server); err != nil {
return err
}
- return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindMCPServer, server.ID)
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindMCPServer, ID: server.ID})
}); err != nil {
return nil, common.CodeDataError, errors.New("failed to create MCP server")
}
@@ -369,8 +369,8 @@ func importedMCPHeaders(raw interface{}) (map[string]string, map[string]interfac
}
func (s *MCPService) GetMCPServer(ctx context.Context, userID, mcpID string) (*entity.MCPServer, common.ErrorCode, error) {
- if err := checkMCPServerPermission(ctx, userID, mcpID, permission.OperationRead); err != nil {
- code, normalized := normalizeMCPServerPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindMCPServer, ID: mcpID}, permission.OperationRead); err != nil {
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
server, err := s.mcpServerDAO.GetByID(ctx, dao.DB, mcpID)
@@ -378,7 +378,7 @@ func (s *MCPService) GetMCPServer(ctx context.Context, userID, mcpID string) (*e
return nil, common.CodeServerError, fmt.Errorf("failed to get MCP server %s: %w", mcpID, err)
}
if server == nil {
- code, normalized := normalizeMCPServerPermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalized
}
return server, common.CodeSuccess, nil
@@ -394,8 +394,8 @@ func (s *MCPService) ExportMCPServer(ctx context.Context, userID, mcpID string)
// UpdateMCPServer updates an MCP server the caller can manage.
func (s *MCPService) UpdateMCPServer(ctx context.Context, userID, mcpID string, req UpdateMCPServerRequest) (*entity.MCPServer, common.ErrorCode, error) {
- if err := checkMCPServerPermission(ctx, userID, mcpID, permission.OperationUpdate); err != nil {
- code, normalized := normalizeMCPServerPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindMCPServer, ID: mcpID}, permission.OperationUpdate); err != nil {
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
server, err := s.mcpServerDAO.GetByID(ctx, dao.DB, mcpID)
@@ -403,7 +403,7 @@ func (s *MCPService) UpdateMCPServer(ctx context.Context, userID, mcpID string,
return nil, common.CodeServerError, fmt.Errorf("failed to get MCP server %s: %w", mcpID, err)
}
if server == nil {
- code, normalized := normalizeMCPServerPermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalized
}
@@ -524,7 +524,7 @@ func (s *MCPService) UpdateMCPServer(ctx context.Context, userID, mcpID string,
return nil, common.CodeServerError, fmt.Errorf("failed to fetch updated MCP server %s: %w", mcpID, err)
}
if updatedServer == nil {
- code, normalized := normalizeMCPServerPermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalized
}
return updatedServer, common.CodeSuccess, nil
@@ -550,11 +550,11 @@ func (s *MCPService) ListMCPServers(ctx context.Context, userID, requestedTenant
return &ListMCPServersResponse{MCPServers: []*MCPServerListItem{}}, common.CodeSuccess, nil
}
if err != nil {
- code, normalized := normalizeMCPServerPermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
} else if err := permission.NewDatabaseChecker(dao.DB).CheckTenant(ctx, permission.Subject{UserID: userID}, tenantID, permission.TenantMember); err != nil {
- code, normalized := normalizeMCPServerPermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
@@ -565,7 +565,7 @@ func (s *MCPService) ListMCPServers(ctx context.Context, userID, requestedTenant
Operation: permission.OperationRead,
})
if err != nil {
- code, normalized := normalizeMCPServerPermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
servers, total, err := s.mcpServerDAO.ListMCPServers(ctx, dao.DB, tenantID, ids, keywords, orderby, desc, page, pageSize, queryScope.Apply)
@@ -586,7 +586,7 @@ func (s *MCPService) ListMCPServers(ctx context.Context, userID, requestedTenant
}
accesses, err := checker.ResolveAccesses(ctx, subject, refs)
if err != nil {
- code, normalized := normalizeMCPServerPermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
for _, ref := range refs {
@@ -628,8 +628,8 @@ func (s *MCPService) ListMCPServers(ctx context.Context, userID, requestedTenant
// DeleteMCPServer deletes an MCP server the caller can manage.
func (s *MCPService) DeleteMCPServer(ctx context.Context, userID, mcpID string) (bool, common.ErrorCode, error) {
- if err := checkMCPServerPermission(ctx, userID, mcpID, permission.OperationDelete); err != nil {
- code, normalized := normalizeMCPServerPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindMCPServer, ID: mcpID}, permission.OperationDelete); err != nil {
+ code, normalized := permissionresponse.NormalizeHidden(err)
return false, code, normalized
}
server, err := s.mcpServerDAO.GetByID(ctx, dao.DB, mcpID)
@@ -637,7 +637,7 @@ func (s *MCPService) DeleteMCPServer(ctx context.Context, userID, mcpID string)
return false, common.CodeServerError, fmt.Errorf("failed to get MCP server %s: %w", mcpID, err)
}
if server == nil {
- code, normalized := normalizeMCPServerPermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return false, code, normalized
}
@@ -646,7 +646,7 @@ func (s *MCPService) DeleteMCPServer(ctx context.Context, userID, mcpID string)
return false, common.CodeServerError, err
}
if !deleted {
- code, normalized := normalizeMCPServerPermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return false, code, normalized
}
@@ -732,7 +732,7 @@ func (s *MCPService) ImportServers(ctx context.Context, userID string, servers m
_, normalized := permissionresponse.Normalize(err)
return nil, normalized
}
- if err := checkFeatureAction(ctx, userID, "mcp", permission.ActionWrite); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "mcp", permission.ActionWrite); err != nil {
_, normalized := permissionresponse.Normalize(err)
return nil, normalized
}
@@ -837,7 +837,7 @@ func (s *MCPService) ImportServers(ctx context.Context, userID string, servers m
if err := s.mcpServerDAO.CreateMCPServer(ctx, tx, server); err != nil {
return err
}
- return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindMCPServer, server.ID)
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindMCPServer, ID: server.ID})
}); err != nil {
results = append(results, ImportResult{Server: serverName, Success: false, Message: "Failed to create MCP server."})
continue
@@ -877,8 +877,8 @@ func (s *MCPService) TestServer(ctx context.Context, userID, mcpID string, req *
return nil, ErrMCPInvalidType
}
if mcpID != mcpServerPreviewID {
- if err := checkMCPServerPermission(ctx, userID, mcpID, permission.OperationUpdate); err != nil {
- _, normalized := normalizeMCPServerPermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindMCPServer, ID: mcpID}, permission.OperationUpdate); err != nil {
+ _, normalized := permissionresponse.NormalizeHidden(err)
return nil, normalized
}
}
diff --git a/internal/service/mcp_permission.go b/internal/service/mcp_permission.go
deleted file mode 100644
index 7dbc2d7919..0000000000
--- a/internal/service/mcp_permission.go
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// 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"
- "ragflow/internal/dao"
- "ragflow/internal/permission"
- permissionresponse "ragflow/internal/permission/response"
-)
-
-func checkMCPServerPermission(ctx context.Context, userID, mcpID string, operation permission.Operation) error {
- return permission.NewDatabaseChecker(dao.DB).CheckResource(
- ctx,
- permission.Subject{UserID: userID},
- permission.ResourceRef{Kind: permission.ResourceKindMCPServer, ID: mcpID},
- operation,
- )
-}
-
-func normalizeMCPServerPermissionError(err error) (common.ErrorCode, error) {
- return permissionresponse.NormalizeHidden(err)
-}
diff --git a/internal/service/memory.go b/internal/service/memory.go
index cf60e9605e..7bdf9baba9 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -412,10 +412,17 @@ type MemoryFiltersResponse struct {
}
func (s *MemoryService) ListMemoryFilters(ctx context.Context, userID string) (*MemoryFiltersResponse, error) {
- memoryIDs, err := s.accessibleMemoryIDs(ctx, userID, permission.OperationRead)
+ memoryScope, err := permission.NewDatabaseChecker(s.db).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindMemory,
+ Operation: permission.OperationRead,
+ })
if err != nil {
return nil, err
}
+ memoryIDs := memoryScope.ResourceIDs
+ if memoryScope.Mode != permission.ScopeIDs {
+ memoryIDs = []string{}
+ }
if len(memoryIDs) == 0 {
return &MemoryFiltersResponse{}, nil
}
@@ -495,7 +502,7 @@ func (s *MemoryService) CreateMemory(ctx context.Context, userID string, req *Cr
if err != nil {
return nil, err
}
- if err := checkFeatureAction(ctx, userID, "memory", permission.ActionWrite); err != nil {
+ if err := permission.NewDatabaseChecker(s.db).CheckFeature(ctx, permission.Subject{UserID: userID}, "memory", permission.ActionWrite); err != nil {
return nil, err
}
// Resolve tenant model IDs, mirroring Python's ensure_tenant_model_ids_for_params.
@@ -588,7 +595,7 @@ func (s *MemoryService) CreateMemory(ctx context.Context, userID string, req *Cr
if err := s.memoryDAO.Create(ctx, tx, memory); err != nil {
return err
}
- return grantCreatedResourceOwner(ctx, tx, userID, tenantID, permission.ResourceKindMemory, memory.ID)
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: userID, TenantID: tenantID}, permission.ResourceRef{Kind: permission.ResourceKindMemory, ID: memory.ID})
}); err != nil {
return nil, errors.New("could not create new memory")
}
@@ -619,7 +626,7 @@ func (s *MemoryService) CreateMemory(ctx context.Context, userID string, req *Cr
// resp, err := service.UpdateMemory("tenant123", "memory456", req)
func (s *MemoryService) UpdateMemory(ctx context.Context, userID string, memoryID string, req *UpdateMemoryRequest) (*CreateMemoryResponse, error) {
updateDict := make(map[string]interface{})
- if err := s.checkMemoryPermission(ctx, userID, memoryID, permission.OperationUpdate); err != nil {
+ if err := permission.NewDatabaseChecker(s.db).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindMemory, ID: memoryID}, permission.OperationUpdate); err != nil {
return nil, err
}
@@ -656,7 +663,7 @@ func (s *MemoryService) UpdateMemory(ctx context.Context, userID string, memoryI
return nil, fmt.Errorf("unknown permission '%s'", *req.Permissions)
}
if strings.ToLower(strings.TrimSpace(currentMemory.Permissions)) != string(perm) {
- if err := s.checkMemoryPermission(ctx, userID, memoryID, permission.OperationShare); err != nil {
+ if err := permission.NewDatabaseChecker(s.db).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindMemory, ID: memoryID}, permission.OperationShare); err != nil {
return nil, err
}
}
@@ -1366,10 +1373,18 @@ func (s *MemoryService) filterAccessibleMemories(ctx context.Context, userID str
return []*entity.Memory{}, nil
}
- accessibleIDs, err := s.filterMemoryIDs(ctx, userID, memoryIDs, permission.OperationUse)
+ refs := make([]permission.ResourceRef, 0, len(memoryIDs))
+ for _, memoryID := range memoryIDs {
+ refs = append(refs, permission.ResourceRef{Kind: permission.ResourceKindMemory, ID: memoryID})
+ }
+ accessible, err := permission.NewDatabaseChecker(s.db).FilterResources(ctx, permission.Subject{UserID: userID}, refs, permission.OperationUse)
if err != nil {
return nil, err
}
+ accessibleIDs := make([]string, 0, len(accessible))
+ for _, ref := range accessible {
+ accessibleIDs = append(accessibleIDs, ref.ID)
+ }
if len(accessibleIDs) == 0 {
return []*entity.Memory{}, nil
}
@@ -1648,7 +1663,7 @@ func (s *MemoryService) memoryWithAccess(ctx context.Context, userID, memoryID s
if err := ctx.Err(); err != nil {
return nil, err
}
- if err := s.checkMemoryPermission(ctx, userID, memoryID, operation); err != nil {
+ if err := permission.NewDatabaseChecker(s.db).CheckResource(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{Kind: permission.ResourceKindMemory, ID: memoryID}, operation); err != nil {
return nil, err
}
memory, err := s.memoryDAO.GetByIDWithContext(ctx, s.db, memoryID)
@@ -1681,10 +1696,25 @@ func (s *MemoryService) memoryWithAccess(ctx context.Context, userID, memoryID s
//
// resp, err := service.ListMemories("user123", []string{}, []string{"semantic"}, "table", "test", 1, 10)
func (s *MemoryService) ListMemories(ctx context.Context, userID string, tenantIDs []string, memoryTypes []string, storageType string, keywords string, page int, pageSize int, canvasID string) (*ListMemoryResponse, error) {
- memoryIDs, err := s.accessibleMemoryIDsForCanvas(ctx, userID, canvasID)
+ canvasID = strings.TrimSpace(canvasID)
+ query := permission.ScopeQuery{
+ Kind: permission.ResourceKindMemory,
+ Operation: permission.OperationRead,
+ }
+ if canvasID != "" {
+ canvasRef := permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}
+ query.Operation = permission.OperationUse
+ query.Entry = &canvasRef
+ query.EntryOp = permission.OperationRun
+ }
+ memoryScope, err := permission.NewDatabaseChecker(s.db).Scope(ctx, permission.Subject{UserID: userID}, query)
if err != nil {
return nil, err
}
+ memoryIDs := memoryScope.ResourceIDs
+ if memoryScope.Mode != permission.ScopeIDs {
+ memoryIDs = []string{}
+ }
if len(memoryIDs) == 0 {
return &ListMemoryResponse{MemoryList: []map[string]interface{}{}}, nil
}
diff --git a/internal/service/memory_permission.go b/internal/service/memory_permission.go
deleted file mode 100644
index 1855037e60..0000000000
--- a/internal/service/memory_permission.go
+++ /dev/null
@@ -1,88 +0,0 @@
-//
-// 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"
- "strings"
-
- "ragflow/internal/permission"
-)
-
-func (s *MemoryService) checkMemoryPermission(ctx context.Context, userID, memoryID string, operation permission.Operation) error {
- return permission.NewDatabaseChecker(s.db).CheckResource(
- ctx,
- permission.Subject{UserID: userID},
- permission.ResourceRef{Kind: permission.ResourceKindMemory, ID: memoryID},
- operation,
- )
-}
-
-func (s *MemoryService) accessibleMemoryIDs(ctx context.Context, userID string, operation permission.Operation) ([]string, error) {
- scope, err := permission.NewDatabaseChecker(s.db).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
- Kind: permission.ResourceKindMemory,
- Operation: operation,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode != permission.ScopeIDs {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
-
-func (s *MemoryService) accessibleMemoryIDsForCanvas(ctx context.Context, userID, canvasID string) ([]string, error) {
- canvasID = strings.TrimSpace(canvasID)
- if canvasID == "" {
- return s.accessibleMemoryIDs(ctx, userID, permission.OperationRead)
- }
- scope, err := permission.NewDatabaseChecker(s.db).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
- Kind: permission.ResourceKindMemory,
- Operation: permission.OperationUse,
- Entry: &permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID},
- EntryOp: permission.OperationRun,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode != permission.ScopeIDs {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
-
-func (s *MemoryService) filterMemoryIDs(ctx context.Context, userID string, memoryIDs []string, operation permission.Operation) ([]string, error) {
- refs := make([]permission.ResourceRef, 0, len(memoryIDs))
- for _, memoryID := range memoryIDs {
- refs = append(refs, permission.ResourceRef{Kind: permission.ResourceKindMemory, ID: memoryID})
- }
- accessible, err := permission.NewDatabaseChecker(s.db).FilterResources(
- ctx,
- permission.Subject{UserID: userID},
- refs,
- operation,
- )
- if err != nil {
- return nil, err
- }
- ids := make([]string, 0, len(accessible))
- for _, ref := range accessible {
- ids = append(ids, ref.ID)
- }
- return ids, nil
-}
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index d995212472..c4b5bb5bf7 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -112,7 +112,7 @@ type CheckConnectionRequest struct {
func (m *ModelProviderService) AddModelProvider(ctx context.Context, providerName, userID string) (common.ErrorCode, error) {
providerName = strings.TrimSpace(providerName)
- if err := checkFeatureAction(ctx, userID, "model_provider", permission.ActionEnable); err != nil {
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "model_provider", permission.ActionEnable); err != nil {
code, normalizedErr := permissionresponse.NormalizeHidden(err)
return code, normalizedErr
}
diff --git a/internal/service/operator_permission.go b/internal/service/operator_permission.go
deleted file mode 100644
index 5d291a7c84..0000000000
--- a/internal/service/operator_permission.go
+++ /dev/null
@@ -1,22 +0,0 @@
-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/search.go b/internal/service/search.go
index e8bc2ed2da..39c29aee12 100644
--- a/internal/service/search.go
+++ b/internal/service/search.go
@@ -203,7 +203,7 @@ func (s *SearchService) CreateSearch(ctx context.Context, name string, descripti
if err := s.searchDAO.Create(ctx, tx, search); err != nil {
return err
}
- return grantCreatedResourceOwner(ctx, tx, identity.UserID, identity.TenantID, permission.ResourceKindSearchApp, search.ID)
+ return permission.NewDatabaseChecker(tx).GrantResourceOwner(ctx, permission.Subject{UserID: identity.UserID, TenantID: identity.TenantID}, permission.ResourceRef{Kind: permission.ResourceKindSearchApp, ID: search.ID})
}); err != nil {
return nil, fmt.Errorf("failed to create search: %w", err)
}
diff --git a/internal/service/skill_search.go b/internal/service/skill_search.go
index bdfd1e285b..5b924d8f98 100644
--- a/internal/service/skill_search.go
+++ b/internal/service/skill_search.go
@@ -32,6 +32,7 @@ import (
"strings"
"go.uber.org/zap"
+ permissionresponse "ragflow/internal/permission/response"
)
// SkillSearchService handles business logic for skill search operations
@@ -59,7 +60,7 @@ func (s *SkillSearchService) GetConfig(ctx context.Context, userID, spaceID, emb
spaceID = normalizeSpaceID(spaceID)
tenantID, err := resolveSkillSpaceTenantID(ctx, userID, spaceID, permission.OperationRead)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
var config *entity.SkillSearchConfig
@@ -90,7 +91,7 @@ func (s *SkillSearchService) GetConfig(ctx context.Context, userID, spaceID, emb
if err != nil {
tenantID, err = resolveSkillSpaceTenantID(ctx, userID, spaceID, permission.OperationUpdate)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
// Config not found, create default one
@@ -121,7 +122,7 @@ func (s *SkillSearchService) UpdateConfig(ctx context.Context, userID string, re
req.SpaceID = normalizeSpaceID(req.SpaceID)
tenantID, err := resolveSkillSpaceTenantID(ctx, userID, req.SpaceID, permission.OperationUpdate)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
req.TenantID = tenantID
@@ -226,7 +227,7 @@ func (s *SkillSearchService) Search(ctx context.Context, userID string, req *Sea
req.SpaceID = normalizeSpaceID(req.SpaceID)
tenantID, err := resolveSkillSpaceTenantID(ctx, userID, req.SpaceID, permission.OperationUse)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
req.TenantID = tenantID
diff --git a/internal/service/skill_space.go b/internal/service/skill_space.go
index ac3610443e..e950676b83 100644
--- a/internal/service/skill_space.go
+++ b/internal/service/skill_space.go
@@ -31,8 +31,28 @@ import (
"go.uber.org/zap"
"gorm.io/gorm"
+ permissionresponse "ragflow/internal/permission/response"
)
+func resolveSkillSpaceTenantID(ctx context.Context, userID, spaceID string, operation permission.Operation) (string, error) {
+ spaceID = normalizeSpaceID(spaceID)
+ if spaceID == defaultSkillSpaceID {
+ return requireCurrentTenantID(ctx, userID)
+ }
+
+ checker := permission.NewDatabaseChecker(dao.DB)
+ subject := permission.Subject{UserID: userID}
+ ref := permission.ResourceRef{Kind: permission.ResourceKindSkillSpace, ID: spaceID}
+ if err := checker.CheckResource(ctx, subject, ref, operation); err != nil {
+ return "", err
+ }
+ access, err := checker.ResolveAccess(ctx, subject, ref)
+ if err != nil {
+ return "", err
+ }
+ return access.TenantID, nil
+}
+
// SkillSpaceService handles business logic for skills space operations
type SkillSpaceService struct {
spaceDAO *dao.SkillSpaceDAO
@@ -156,11 +176,11 @@ func (s *SkillSpaceService) CreateSpace(ctx context.Context, userID string, req
}
tenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
- if err := checkFeatureAction(ctx, userID, "file", permission.ActionWrite); err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, permission.Subject{UserID: userID}, "file", permission.ActionWrite); err != nil {
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
defaultEmbdID := req.EmbdID
@@ -305,11 +325,18 @@ func (s *SkillSpaceService) CreateSpace(ctx context.Context, userID string, req
// ListSpaces lists skill spaces the caller can read.
func (s *SkillSpaceService) ListSpaces(ctx context.Context, userID string) (map[string]interface{}, common.ErrorCode, error) {
- spaceIDs, err := accessibleSkillSpaceIDs(ctx, userID, permission.OperationRead)
+ spaceScope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
+ Kind: permission.ResourceKindSkillSpace,
+ Operation: permission.OperationRead,
+ })
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
+ spaceIDs := spaceScope.ResourceIDs
+ if spaceScope.Mode != permission.ScopeIDs {
+ spaceIDs = []string{}
+ }
spaces, err := s.spaceDAO.GetByIDs(ctx, dao.DB, spaceIDs)
if err != nil {
return nil, common.CodeOperatingError, fmt.Errorf("failed to list spaces: %w", err)
@@ -330,18 +357,18 @@ func (s *SkillSpaceService) ListSpaces(ctx context.Context, userID string) (map[
// GetSpace retrieves a skills space by ID (includes deleting status for visibility)
func (s *SkillSpaceService) GetSpace(ctx context.Context, userID, spaceID string) (map[string]interface{}, common.ErrorCode, error) {
if _, err := resolveSkillSpaceTenantID(ctx, userID, spaceID, permission.OperationRead); err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
space, err := s.spaceDAO.GetByIDAnyStatus(ctx, dao.DB, spaceID)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalized
}
// Return deleted spaces as not found
if space.Status == entity.SpaceStatusDeleted {
- code, normalized := normalizeSkillSpacePermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalized
}
@@ -352,12 +379,12 @@ func (s *SkillSpaceService) GetSpace(ctx context.Context, userID, spaceID string
func (s *SkillSpaceService) UpdateSpace(ctx context.Context, userID, spaceID string, req *UpdateSpaceRequest) (map[string]interface{}, common.ErrorCode, error) {
tenantID, err := resolveSkillSpaceTenantID(ctx, userID, spaceID, permission.OperationUpdate)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
space, err := s.spaceDAO.GetByID(ctx, dao.DB, spaceID)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalized
}
@@ -435,13 +462,13 @@ func (s *SkillSpaceService) UpdateSpace(ctx context.Context, userID, spaceID str
func (s *SkillSpaceService) DeleteSpace(ctx context.Context, userID, spaceID string, docEngine engine.DocEngine) (common.ErrorCode, error) {
tenantID, err := resolveSkillSpaceTenantID(ctx, userID, spaceID, permission.OperationDelete)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return code, normalized
}
// Get space regardless of status (could be retrying a failed delete)
space, err := s.spaceDAO.GetByIDAnyStatus(ctx, dao.DB, spaceID)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return code, normalized
}
@@ -643,11 +670,11 @@ func (s *SkillSpaceService) deleteFolderRecursive(ctx context.Context, folderID
func (s *SkillSpaceService) GetSpaceByFolderID(ctx context.Context, userID, folderID string) (map[string]interface{}, common.ErrorCode, error) {
space, err := s.spaceDAO.GetByFolderID(ctx, dao.DB, folderID)
if err != nil {
- code, normalized := normalizeSkillSpacePermissionError(permission.ErrResourceNotFound)
+ code, normalized := permissionresponse.NormalizeHidden(permission.ErrResourceNotFound)
return nil, code, normalized
}
if _, err := resolveSkillSpaceTenantID(ctx, userID, space.ID, permission.OperationRead); err != nil {
- code, normalized := normalizeSkillSpacePermissionError(err)
+ code, normalized := permissionresponse.NormalizeHidden(err)
return nil, code, normalized
}
diff --git a/internal/service/skill_space_permission.go b/internal/service/skill_space_permission.go
deleted file mode 100644
index 671f45ad27..0000000000
--- a/internal/service/skill_space_permission.go
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// 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"
- "ragflow/internal/dao"
- "ragflow/internal/permission"
- permissionresponse "ragflow/internal/permission/response"
-)
-
-func resolveSkillSpaceTenantID(ctx context.Context, userID, spaceID string, operation permission.Operation) (string, error) {
- spaceID = normalizeSpaceID(spaceID)
- if spaceID == defaultSkillSpaceID {
- return requireCurrentTenantID(ctx, userID)
- }
-
- checker := permission.NewDatabaseChecker(dao.DB)
- subject := permission.Subject{UserID: userID}
- ref := permission.ResourceRef{Kind: permission.ResourceKindSkillSpace, ID: spaceID}
- if err := checker.CheckResource(ctx, subject, ref, operation); err != nil {
- return "", err
- }
- access, err := checker.ResolveAccess(ctx, subject, ref)
- if err != nil {
- return "", err
- }
- return access.TenantID, nil
-}
-
-func accessibleSkillSpaceIDs(ctx context.Context, userID string, operation permission.Operation) ([]string, error) {
- scope, err := permission.NewDatabaseChecker(dao.DB).Scope(ctx, permission.Subject{UserID: userID}, permission.ScopeQuery{
- Kind: permission.ResourceKindSkillSpace,
- Operation: operation,
- })
- if err != nil {
- return nil, err
- }
- if scope.Mode != permission.ScopeIDs {
- return []string{}, nil
- }
- return scope.ResourceIDs, nil
-}
-
-func normalizeSkillSpacePermissionError(err error) (common.ErrorCode, error) {
- return permissionresponse.NormalizeHidden(err)
-}
diff --git a/internal/service/tenant_permission.go b/internal/service/tenant_context.go
similarity index 72%
rename from internal/service/tenant_permission.go
rename to internal/service/tenant_context.go
index fcb6c1e1fd..31750e8d9b 100644
--- a/internal/service/tenant_permission.go
+++ b/internal/service/tenant_context.go
@@ -19,7 +19,6 @@ import (
"context"
"strings"
- "gorm.io/gorm"
"ragflow/internal/dao"
"ragflow/internal/permission"
)
@@ -48,11 +47,3 @@ func requireCurrentTenantID(ctx context.Context, userID string) (string, error)
}
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})
-}