feat: add organization management features

- Introduced a new API for organization management, including creation, updating, and deletion of organizations.
- Implemented organization sharing functionality for knowledge bases, allowing users to share knowledge bases with specific organizations and set permissions.
- Added UI components for organization selection and sharing dialogs.
- Enhanced existing components to support organization-related features, including shared knowledge base handling and organization role management.

This update enhances collaboration capabilities within the application by allowing users to manage and share knowledge bases across different organizations.
This commit is contained in:
wizardchen
2026-01-30 16:28:01 +08:00
committed by lyingbug
parent 548450c170
commit 4158773849
72 changed files with 14685 additions and 1419 deletions
+80 -78
View File
@@ -1,6 +1,7 @@
package handler
import (
"context"
"net/http"
"github.com/Tencent/WeKnora/internal/application/service"
@@ -14,17 +15,48 @@ import (
// ChunkHandler defines HTTP handlers for chunk operations
type ChunkHandler struct {
service interfaces.ChunkService
service interfaces.ChunkService
kgService interfaces.KnowledgeService
kbShareService interfaces.KBShareService
}
// NewChunkHandler creates a new chunk handler
func NewChunkHandler(service interfaces.ChunkService) *ChunkHandler {
return &ChunkHandler{service: service}
func NewChunkHandler(service interfaces.ChunkService, kgService interfaces.KnowledgeService, kbShareService interfaces.KBShareService) *ChunkHandler {
return &ChunkHandler{service: service, kgService: kgService, kbShareService: kbShareService}
}
// effectiveCtxForKnowledge resolves knowledge by ID, validates KB access (owner or shared with required role), and returns context with effectiveTenantID for downstream service calls.
func (h *ChunkHandler) effectiveCtxForKnowledge(c *gin.Context, knowledgeID string, requiredPermission types.OrgMemberRole) (context.Context, error) {
ctx := c.Request.Context()
tenantID := c.GetUint64(types.TenantIDContextKey.String())
if tenantID == 0 {
return nil, errors.NewUnauthorizedError("Unauthorized")
}
userID, userExists := c.Get(types.UserIDContextKey.String())
knowledge, err := h.kgService.GetKnowledgeByIDOnly(ctx, knowledgeID)
if err != nil {
return nil, errors.NewNotFoundError("Knowledge not found")
}
if knowledge.TenantID == tenantID {
return context.WithValue(ctx, types.TenantIDContextKey, tenantID), nil
}
if !userExists || h.kbShareService == nil {
return nil, errors.NewForbiddenError("Permission denied to access this knowledge")
}
permission, isShared, permErr := h.kbShareService.CheckUserKBPermission(ctx, knowledge.KnowledgeBaseID, userID.(string))
if permErr != nil || !isShared {
return nil, errors.NewForbiddenError("Permission denied to access this knowledge")
}
if !permission.HasPermission(requiredPermission) {
return nil, errors.NewForbiddenError("Insufficient permission for this operation")
}
return context.WithValue(ctx, types.TenantIDContextKey, knowledge.TenantID), nil
}
// GetChunkByIDOnly godoc
// @Summary 通过ID获取分块
// @Description 仅通过分块ID获取分块详情(不需要knowledge_id)
// @Description 仅通过分块ID获取分块详情(不需要knowledge_id);支持共享知识库下的分块访问
// @Tags 分块管理
// @Accept json
// @Produce json
@@ -46,18 +78,8 @@ func (h *ChunkHandler) GetChunkByIDOnly(c *gin.Context) {
return
}
// Get tenant ID from context
tenantID, exists := c.Get(types.TenantIDContextKey.String())
if !exists {
logger.Error(ctx, "Failed to get tenant ID")
c.Error(errors.NewUnauthorizedError("Unauthorized"))
return
}
logger.Infof(ctx, "Retrieving chunk by ID, chunk ID: %s, tenant ID: %d", chunkID, tenantID)
// Get chunk by ID
chunk, err := h.service.GetChunkByID(ctx, chunkID)
// Get chunk by ID without tenant filter (chunk may belong to shared KB)
chunk, err := h.service.GetChunkByIDOnly(ctx, chunkID)
if err != nil {
if err == service.ErrChunkNotFound {
logger.Warnf(ctx, "Chunk not found, chunk ID: %s", chunkID)
@@ -69,14 +91,9 @@ func (h *ChunkHandler) GetChunkByIDOnly(c *gin.Context) {
return
}
// Validate tenant ID
if chunk.TenantID != tenantID.(uint64) {
logger.Warnf(
ctx,
"Tenant has no permission to access chunk, chunk ID: %s, req tenant: %d, chunk tenant: %d",
chunkID, tenantID.(uint64), chunk.TenantID,
)
c.Error(errors.NewForbiddenError("No permission to access this chunk"))
_, err = h.effectiveCtxForKnowledge(c, chunk.KnowledgeID, types.OrgRoleViewer)
if err != nil {
c.Error(err)
return
}
@@ -116,6 +133,12 @@ func (h *ChunkHandler) ListKnowledgeChunks(c *gin.Context) {
return
}
effCtx, err := h.effectiveCtxForKnowledge(c, knowledgeID, types.OrgRoleViewer)
if err != nil {
c.Error(err)
return
}
// Parse pagination parameters
var pagination types.Pagination
if err := c.ShouldBindQuery(&pagination); err != nil {
@@ -135,8 +158,8 @@ func (h *ChunkHandler) ListKnowledgeChunks(c *gin.Context) {
chunkType := []types.ChunkType{types.ChunkTypeText}
// Use pagination for query
result, err := h.service.ListPagedChunksByKnowledgeID(ctx, knowledgeID, &pagination, chunkType)
// Use pagination for query (effCtx has effectiveTenantID for shared KB)
result, err := h.service.ListPagedChunksByKnowledgeID(effCtx, knowledgeID, &pagination, chunkType)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
@@ -170,59 +193,46 @@ type UpdateChunkRequest struct {
ImageInfo string `json:"image_info"`
}
// validateAndGetChunk validates request parameters and retrieves the chunk
// Returns chunk information, knowledge ID, and error
func (h *ChunkHandler) validateAndGetChunk(c *gin.Context) (*types.Chunk, string, error) {
// validateAndGetChunk validates request parameters and retrieves the chunk (supports shared KB via effectiveTenantID).
// Returns chunk, knowledge ID, context with effectiveTenantID for downstream calls, and error.
func (h *ChunkHandler) validateAndGetChunk(c *gin.Context) (*types.Chunk, string, context.Context, error) {
ctx := c.Request.Context()
// Validate knowledge ID
knowledgeID := secutils.SanitizeForLog(c.Param("knowledge_id"))
if knowledgeID == "" {
logger.Error(ctx, "Knowledge ID is empty")
return nil, "", errors.NewBadRequestError("Knowledge ID cannot be empty")
return nil, "", nil, errors.NewBadRequestError("Knowledge ID cannot be empty")
}
// Validate chunk ID
id := secutils.SanitizeForLog(c.Param("id"))
if id == "" {
logger.Error(ctx, "Chunk ID is empty")
return nil, knowledgeID, errors.NewBadRequestError("Chunk ID cannot be empty")
return nil, knowledgeID, nil, errors.NewBadRequestError("Chunk ID cannot be empty")
}
// Get tenant ID from context
tenantID, exists := c.Get(types.TenantIDContextKey.String())
if !exists {
logger.Error(ctx, "Failed to get tenant ID")
return nil, knowledgeID, errors.NewUnauthorizedError("Unauthorized")
effCtx, err := h.effectiveCtxForKnowledge(c, knowledgeID, types.OrgRoleEditor)
if err != nil {
return nil, knowledgeID, nil, err
}
logger.Infof(ctx, "Retrieving knowledge chunk information, knowledge ID: %s, chunk ID: %s", knowledgeID, id)
// Get existing chunk
chunk, err := h.service.GetChunkByID(ctx, id)
chunk, err := h.service.GetChunkByID(effCtx, id)
if err != nil {
if err == service.ErrChunkNotFound {
logger.Warnf(ctx, "Chunk not found, knowledge ID: %s, chunk ID: %s", knowledgeID, id)
return nil, knowledgeID, errors.NewNotFoundError("Chunk not found")
return nil, knowledgeID, nil, errors.NewNotFoundError("Chunk not found")
}
logger.ErrorWithFields(ctx, err, nil)
return nil, knowledgeID, errors.NewInternalServerError(err.Error())
return nil, knowledgeID, nil, errors.NewInternalServerError(err.Error())
}
// Validate tenant ID
if chunk.TenantID != tenantID.(uint64) || chunk.KnowledgeID != knowledgeID {
logger.Warnf(
ctx,
"Tenant has no permission to access chunk, knowledge ID: %s, chunk ID: %s, req tenant: %d, chunk tenant: %d",
knowledgeID,
id,
tenantID,
chunk.TenantID,
)
return nil, knowledgeID, errors.NewForbiddenError("No permission to access this chunk")
if chunk.KnowledgeID != knowledgeID {
logger.Warnf(ctx, "Chunk does not belong to knowledge, knowledge ID: %s, chunk ID: %s", knowledgeID, id)
return nil, knowledgeID, nil, errors.NewForbiddenError("No permission to access this chunk")
}
return chunk, knowledgeID, nil
return chunk, knowledgeID, effCtx, nil
}
// UpdateChunk godoc
@@ -244,8 +254,7 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start updating knowledge chunk")
// Validate parameters and get chunk
chunk, knowledgeID, err := h.validateAndGetChunk(c)
chunk, knowledgeID, effCtx, err := h.validateAndGetChunk(c)
if err != nil {
c.Error(err)
return
@@ -257,14 +266,13 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
return
}
// Update chunk properties
if req.Content != "" {
chunk.Content = req.Content
}
chunk.IsEnabled = req.IsEnabled
if err := h.service.UpdateChunk(ctx, chunk); err != nil {
if err := h.service.UpdateChunk(effCtx, chunk); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
@@ -296,14 +304,13 @@ func (h *ChunkHandler) DeleteChunk(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting knowledge chunk")
// Validate parameters and get chunk
chunk, _, err := h.validateAndGetChunk(c)
chunk, _, effCtx, err := h.validateAndGetChunk(c)
if err != nil {
c.Error(err)
return
}
if err := h.service.DeleteChunk(ctx, chunk.ID); err != nil {
if err := h.service.DeleteChunk(effCtx, chunk.ID); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
@@ -338,8 +345,13 @@ func (h *ChunkHandler) DeleteChunksByKnowledgeID(c *gin.Context) {
return
}
// Delete all chunks under the knowledge
err := h.service.DeleteChunksByKnowledgeID(ctx, knowledgeID)
effCtx, err := h.effectiveCtxForKnowledge(c, knowledgeID, types.OrgRoleEditor)
if err != nil {
c.Error(err)
return
}
err = h.service.DeleteChunksByKnowledgeID(effCtx, knowledgeID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
@@ -386,16 +398,7 @@ func (h *ChunkHandler) DeleteGeneratedQuestion(c *gin.Context) {
return
}
// Get tenant ID from context
tenantID, exists := c.Get(types.TenantIDContextKey.String())
if !exists {
logger.Error(ctx, "Failed to get tenant ID")
c.Error(errors.NewUnauthorizedError("Unauthorized"))
return
}
// Verify chunk exists and belongs to tenant
chunk, err := h.service.GetChunkByID(ctx, chunkID)
chunk, err := h.service.GetChunkByIDOnly(ctx, chunkID)
if err != nil {
if err == service.ErrChunkNotFound {
logger.Warnf(ctx, "Chunk not found, chunk ID: %s", chunkID)
@@ -407,14 +410,13 @@ func (h *ChunkHandler) DeleteGeneratedQuestion(c *gin.Context) {
return
}
if chunk.TenantID != tenantID.(uint64) {
logger.Warnf(ctx, "Tenant has no permission to access chunk, chunk ID: %s", chunkID)
c.Error(errors.NewForbiddenError("No permission to access this chunk"))
effCtx, err := h.effectiveCtxForKnowledge(c, chunk.KnowledgeID, types.OrgRoleEditor)
if err != nil {
c.Error(err)
return
}
// Delete the generated question by ID
if err := h.service.DeleteGeneratedQuestion(ctx, chunkID, req.QuestionID); err != nil {
if err := h.service.DeleteGeneratedQuestion(effCtx, chunkID, req.QuestionID); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewBadRequestError(err.Error()))
return
+280 -74
View File
@@ -1,6 +1,7 @@
package handler
import (
"context"
"encoding/json"
"fmt"
"io"
@@ -18,50 +19,156 @@ import (
// KnowledgeHandler processes HTTP requests related to knowledge resources
type KnowledgeHandler struct {
kgService interfaces.KnowledgeService
kbService interfaces.KnowledgeBaseService
kgService interfaces.KnowledgeService
kbService interfaces.KnowledgeBaseService
kbShareService interfaces.KBShareService
}
// NewKnowledgeHandler creates a new knowledge handler instance
func NewKnowledgeHandler(
kgService interfaces.KnowledgeService,
kbService interfaces.KnowledgeBaseService,
kbShareService interfaces.KBShareService,
) *KnowledgeHandler {
return &KnowledgeHandler{kgService: kgService, kbService: kbService}
return &KnowledgeHandler{
kgService: kgService,
kbService: kbService,
kbShareService: kbShareService,
}
}
// validateKnowledgeBaseAccess validates access permissions to a knowledge base
// Returns the knowledge base, the knowledge base ID, and any errors encountered
func (h *KnowledgeHandler) validateKnowledgeBaseAccess(c *gin.Context) (*types.KnowledgeBase, string, error) {
// Returns the knowledge base, the knowledge base ID, effective tenant ID, permission level, and any errors encountered
// For owned KBs, effectiveTenantID is the caller's tenant ID
// For shared KBs, effectiveTenantID is the source tenant ID (owner's tenant)
func (h *KnowledgeHandler) validateKnowledgeBaseAccess(c *gin.Context) (*types.KnowledgeBase, string, uint64, types.OrgMemberRole, error) {
ctx := c.Request.Context()
// Get tenant ID from context
tenantID := c.GetUint64(types.TenantIDContextKey.String())
if tenantID == 0 {
logger.Error(ctx, "Failed to get tenant ID")
return nil, "", 0, "", errors.NewUnauthorizedError("Unauthorized")
}
// Get user ID from context (needed for shared KB permission check)
userID, userExists := c.Get(types.UserIDContextKey.String())
// Get knowledge base ID from URL path parameter
kbID := secutils.SanitizeForLog(c.Param("id"))
if kbID == "" {
logger.Error(ctx, "Knowledge base ID is empty")
return nil, "", errors.NewBadRequestError("Knowledge base ID cannot be empty")
return nil, "", 0, "", errors.NewBadRequestError("Knowledge base ID cannot be empty")
}
// Get knowledge base details
kb, err := h.kbService.GetKnowledgeBaseByID(ctx, kbID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
return nil, kbID, errors.NewInternalServerError(err.Error())
return nil, kbID, 0, "", errors.NewInternalServerError(err.Error())
}
// Verify tenant permissions
if kb.TenantID != c.GetUint64(types.TenantIDContextKey.String()) {
logger.Warnf(
ctx,
"Permission denied to access this knowledge base, tenant ID mismatch, "+
"requested tenant ID: %d, knowledge base tenant ID: %d",
c.GetUint64(types.TenantIDContextKey.String()),
kb.TenantID,
)
return nil, kbID, errors.NewForbiddenError("Permission denied to access this knowledge base")
// Check 1: Verify tenant ownership (owner has full access)
if kb.TenantID == tenantID {
return kb, kbID, tenantID, types.OrgRoleAdmin, nil
}
return kb, kbID, nil
// Check 2: If not owner, check organization shared access
if userExists && h.kbShareService != nil {
// Check if user has shared access through organization
permission, isShared, permErr := h.kbShareService.CheckUserKBPermission(ctx, kbID, userID.(string))
if permErr == nil && isShared {
// User has shared access, get the source tenant ID for queries
sourceTenantID, srcErr := h.kbShareService.GetKBSourceTenant(ctx, kbID)
if srcErr == nil {
logger.Infof(ctx, "User %s accessing shared KB %s with permission %s, source tenant: %d",
userID.(string), kbID, permission, sourceTenantID)
return kb, kbID, sourceTenantID, permission, nil
}
}
}
// No permission: not owner and no shared access
logger.Warnf(
ctx,
"Permission denied to access this knowledge base, tenant ID mismatch, "+
"requested tenant ID: %d, knowledge base tenant ID: %d",
tenantID,
kb.TenantID,
)
return nil, kbID, 0, "", errors.NewForbiddenError("Permission denied to access this knowledge base")
}
// validateKnowledgeBaseAccessWithKBID validates access to the given knowledge base ID (e.g. from query or body).
// Returns the knowledge base, kbID, effective tenant ID, permission, and error.
func (h *KnowledgeHandler) validateKnowledgeBaseAccessWithKBID(c *gin.Context, kbID string) (*types.KnowledgeBase, string, uint64, types.OrgMemberRole, error) {
ctx := c.Request.Context()
tenantID := c.GetUint64(types.TenantIDContextKey.String())
if tenantID == 0 {
logger.Error(ctx, "Failed to get tenant ID")
return nil, "", 0, "", errors.NewUnauthorizedError("Unauthorized")
}
userID, userExists := c.Get(types.UserIDContextKey.String())
kbID = secutils.SanitizeForLog(kbID)
if kbID == "" {
return nil, "", 0, "", errors.NewBadRequestError("Knowledge base ID cannot be empty")
}
kb, err := h.kbService.GetKnowledgeBaseByID(ctx, kbID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
return nil, kbID, 0, "", errors.NewInternalServerError(err.Error())
}
if kb.TenantID == tenantID {
return kb, kbID, tenantID, types.OrgRoleAdmin, nil
}
if userExists && h.kbShareService != nil {
permission, isShared, permErr := h.kbShareService.CheckUserKBPermission(ctx, kbID, userID.(string))
if permErr == nil && isShared {
sourceTenantID, srcErr := h.kbShareService.GetKBSourceTenant(ctx, kbID)
if srcErr == nil {
logger.Infof(ctx, "User %s accessing shared KB %s with permission %s, source tenant: %d",
userID.(string), kbID, permission, sourceTenantID)
return kb, kbID, sourceTenantID, permission, nil
}
}
}
logger.Warnf(ctx, "Permission denied to access KB %s, tenant ID: %d, KB tenant: %d", kbID, tenantID, kb.TenantID)
return nil, kbID, 0, "", errors.NewForbiddenError("Permission denied to access this knowledge base")
}
// resolveKnowledgeAndValidateKBAccess resolves knowledge by ID and validates KB access (owner or shared with required permission).
// Returns the knowledge, context with effectiveTenantID set for downstream service calls, and error.
func (h *KnowledgeHandler) resolveKnowledgeAndValidateKBAccess(c *gin.Context, knowledgeID string, requiredPermission types.OrgMemberRole) (*types.Knowledge, context.Context, error) {
ctx := c.Request.Context()
tenantID := c.GetUint64(types.TenantIDContextKey.String())
if tenantID == 0 {
return nil, ctx, errors.NewUnauthorizedError("Unauthorized")
}
userID, userExists := c.Get(types.UserIDContextKey.String())
knowledge, err := h.kgService.GetKnowledgeByIDOnly(ctx, knowledgeID)
if err != nil {
return nil, ctx, errors.NewNotFoundError("Knowledge not found")
}
// Owner: knowledge belongs to caller's tenant
if knowledge.TenantID == tenantID {
return knowledge, context.WithValue(ctx, types.TenantIDContextKey, tenantID), nil
}
// Shared KB: check organization permission
if !userExists || h.kbShareService == nil {
return nil, ctx, errors.NewForbiddenError("Permission denied to access this knowledge")
}
permission, isShared, permErr := h.kbShareService.CheckUserKBPermission(ctx, knowledge.KnowledgeBaseID, userID.(string))
if permErr != nil || !isShared {
return nil, ctx, errors.NewForbiddenError("Permission denied to access this knowledge")
}
if !permission.HasPermission(requiredPermission) {
return nil, ctx, errors.NewForbiddenError("Insufficient permission for this operation")
}
effectiveTenantID := knowledge.TenantID
return knowledge, context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID), nil
}
// handleDuplicateKnowledgeError handles cases where duplicate knowledge is detected
@@ -104,12 +211,19 @@ func (h *KnowledgeHandler) CreateKnowledgeFromFile(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start creating knowledge from file")
// Validate access to the knowledge base
_, kbID, err := h.validateKnowledgeBaseAccess(c)
// Validate access to the knowledge base (only owner or admin/editor can create)
_, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseAccess(c)
if err != nil {
c.Error(err)
return
}
ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)
// Check write permission
if permission != types.OrgRoleAdmin && permission != types.OrgRoleEditor {
c.Error(errors.NewForbiddenError("No permission to create knowledge"))
return
}
// Get the uploaded file
file, err := c.FormFile("file")
@@ -217,12 +331,19 @@ func (h *KnowledgeHandler) CreateKnowledgeFromURL(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start creating knowledge from URL")
// Validate access to the knowledge base
_, kbID, err := h.validateKnowledgeBaseAccess(c)
// Validate access to the knowledge base (only owner or admin/editor can create)
_, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseAccess(c)
if err != nil {
c.Error(err)
return
}
ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)
// Check write permission
if permission != types.OrgRoleAdmin && permission != types.OrgRoleEditor {
c.Error(errors.NewForbiddenError("No permission to create knowledge"))
return
}
// Parse URL from request body
var req struct {
@@ -286,11 +407,19 @@ func (h *KnowledgeHandler) CreateManualKnowledge(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start creating manual knowledge")
_, kbID, err := h.validateKnowledgeBaseAccess(c)
// Validate access to the knowledge base (only owner or admin/editor can create)
_, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseAccess(c)
if err != nil {
c.Error(err)
return
}
ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)
// Check write permission
if permission != types.OrgRoleAdmin && permission != types.OrgRoleEditor {
c.Error(errors.NewForbiddenError("No permission to create knowledge"))
return
}
var req types.ManualKnowledgePayload
if err := c.ShouldBindJSON(&req); err != nil {
@@ -338,7 +467,6 @@ func (h *KnowledgeHandler) GetKnowledge(c *gin.Context) {
logger.Info(ctx, "Start retrieving knowledge")
// Get knowledge ID from URL path parameter
id := secutils.SanitizeForLog(c.Param("id"))
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
@@ -346,20 +474,15 @@ func (h *KnowledgeHandler) GetKnowledge(c *gin.Context) {
return
}
logger.Infof(ctx, "Retrieving knowledge, ID: %s", secutils.SanitizeForLog(id))
knowledge, err := h.kgService.GetKnowledgeByID(ctx, id)
// Resolve knowledge and validate KB access (at least viewer)
knowledge, _, err := h.resolveKnowledgeAndValidateKBAccess(c, id, types.OrgRoleViewer)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
c.Error(err)
return
}
logger.Infof(
ctx,
"Knowledge retrieved successfully, ID: %s, title: %s",
secutils.SanitizeForLog(knowledge.ID),
secutils.SanitizeForLog(knowledge.Title),
)
logger.Infof(ctx, "Knowledge retrieved successfully, ID: %s, title: %s",
secutils.SanitizeForLog(knowledge.ID), secutils.SanitizeForLog(knowledge.Title))
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": knowledge,
@@ -388,14 +511,16 @@ func (h *KnowledgeHandler) ListKnowledge(c *gin.Context) {
logger.Info(ctx, "Start retrieving knowledge list")
// Get knowledge base ID from URL path parameter
kbID := secutils.SanitizeForLog(c.Param("id"))
if kbID == "" {
logger.Error(ctx, "Knowledge base ID is empty")
c.Error(errors.NewBadRequestError("Knowledge base ID cannot be empty"))
// Validate access to the knowledge base (read access - any permission level)
_, kbID, effectiveTenantID, _, err := h.validateKnowledgeBaseAccess(c)
if err != nil {
c.Error(err)
return
}
// Update context with effective tenant ID for shared KB access
ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)
// Parse pagination parameters from query string
var pagination types.Pagination
if err := c.ShouldBindQuery(&pagination); err != nil {
@@ -410,13 +535,14 @@ func (h *KnowledgeHandler) ListKnowledge(c *gin.Context) {
logger.Infof(
ctx,
"Retrieving knowledge list under knowledge base, knowledge base ID: %s, tag_id: %s, keyword: %s, file_type: %s, page: %d, page size: %d",
"Retrieving knowledge list under knowledge base, knowledge base ID: %s, tag_id: %s, keyword: %s, file_type: %s, page: %d, page size: %d, effectiveTenantID: %d",
secutils.SanitizeForLog(kbID),
secutils.SanitizeForLog(tagID),
secutils.SanitizeForLog(keyword),
secutils.SanitizeForLog(fileType),
pagination.Page,
pagination.PageSize,
effectiveTenantID,
)
// Retrieve paginated knowledge entries
@@ -459,7 +585,6 @@ func (h *KnowledgeHandler) DeleteKnowledge(c *gin.Context) {
logger.Info(ctx, "Start deleting knowledge")
// Get knowledge ID from URL path parameter
id := secutils.SanitizeForLog(c.Param("id"))
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
@@ -467,8 +592,13 @@ func (h *KnowledgeHandler) DeleteKnowledge(c *gin.Context) {
return
}
_, effCtx, err := h.resolveKnowledgeAndValidateKBAccess(c, id, types.OrgRoleEditor)
if err != nil {
c.Error(err)
return
}
logger.Infof(ctx, "Deleting knowledge, ID: %s", secutils.SanitizeForLog(id))
err := h.kgService.DeleteKnowledge(ctx, id)
err = h.kgService.DeleteKnowledge(effCtx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
@@ -499,7 +629,6 @@ func (h *KnowledgeHandler) DownloadKnowledgeFile(c *gin.Context) {
logger.Info(ctx, "Start downloading knowledge file")
// Get knowledge ID from URL path parameter
id := secutils.SanitizeForLog(c.Param("id"))
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
@@ -507,10 +636,14 @@ func (h *KnowledgeHandler) DownloadKnowledgeFile(c *gin.Context) {
return
}
_, effCtx, err := h.resolveKnowledgeAndValidateKBAccess(c, id, types.OrgRoleViewer)
if err != nil {
c.Error(err)
return
}
logger.Infof(ctx, "Retrieving knowledge file, ID: %s", secutils.SanitizeForLog(id))
// Get file content and filename
file, filename, err := h.kgService.GetKnowledgeFile(ctx, id)
file, filename, err := h.kgService.GetKnowledgeFile(effCtx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Failed to retrieve file").WithDetails(err.Error()))
@@ -547,33 +680,34 @@ func (h *KnowledgeHandler) DownloadKnowledgeFile(c *gin.Context) {
// GetKnowledgeBatchRequest defines parameters for batch knowledge retrieval
type GetKnowledgeBatchRequest struct {
IDs []string `form:"ids" binding:"required"` // List of knowledge IDs
IDs []string `form:"ids" binding:"required"` // List of knowledge IDs
KBID string `form:"kb_id"` // Optional: scope to this KB (validates access and uses effective tenant for shared KB)
}
// GetKnowledgeBatch godoc
// @Summary 批量获取知识
// @Description 根据ID列表批量获取知识条目
// @Description 根据ID列表批量获取知识条目。可选 kb_id:指定时按该知识库校验权限并用于共享知识库的租户解析
// @Tags 知识管理
// @Accept json
// @Produce json
// @Param ids query []string true "知识ID列表"
// @Success 200 {object} map[string]interface{} "知识列表"
// @Failure 400 {object} errors.AppError "请求参数错误"
// @Param ids query []string true "知识ID列表"
// @Param kb_id query string false "可选,知识库ID(用于共享知识库时指定范围)"
// @Success 200 {object} map[string]interface{} "知识列表"
// @Failure 400 {object} errors.AppError "请求参数错误"
// @Security Bearer
// @Security ApiKeyAuth
// @Router /knowledge/batch [get]
func (h *KnowledgeHandler) GetKnowledgeBatch(c *gin.Context) {
ctx := c.Request.Context()
// Get tenant ID from context
tenantID, ok := c.Get(types.TenantIDContextKey.String())
if !ok {
logger.Error(ctx, "Failed to get tenant ID")
c.Error(errors.NewUnauthorizedError("Unauthorized"))
return
}
effectiveTenantID := tenantID.(uint64)
// Parse request parameters from query string
var req GetKnowledgeBatchRequest
if err := c.ShouldBindQuery(&req); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
@@ -581,27 +715,41 @@ func (h *KnowledgeHandler) GetKnowledgeBatch(c *gin.Context) {
return
}
logger.Infof(
ctx,
"Batch retrieving knowledge, tenant ID: %d, number of knowledge IDs: %d",
tenantID, len(req.IDs),
)
var knowledges []*types.Knowledge
var err error
// Optional kb_id: validate KB access and use effective tenant for shared KB
if kbID := secutils.SanitizeForLog(req.KBID); kbID != "" {
_, _, effID, _, err := h.validateKnowledgeBaseAccessWithKBID(c, kbID)
if err != nil {
c.Error(err)
return
}
effectiveTenantID = effID
ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)
logger.Infof(ctx, "Batch retrieving knowledge with kb_id, effective tenant ID: %d, IDs count: %d",
effectiveTenantID, len(req.IDs))
knowledges, err = h.kgService.GetKnowledgeBatch(ctx, effectiveTenantID, req.IDs)
} else {
// No kb_id provided: use GetKnowledgeBatchWithSharedAccess to support cross-tenant shared files
// This is needed when page is refreshed and frontend doesn't have kb_id mapping
logger.Infof(ctx, "Batch retrieving knowledge without kb_id (using shared access), tenant ID: %d, IDs count: %d",
effectiveTenantID, len(req.IDs))
knowledges, err = h.kgService.GetKnowledgeBatchWithSharedAccess(ctx, effectiveTenantID, req.IDs)
}
// Retrieve knowledge entries in batch
knowledges, err := h.kgService.GetKnowledgeBatch(ctx, tenantID.(uint64), req.IDs)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Failed to retrieve knowledge list").WithDetails(err.Error()))
return
}
logger.Infof(
ctx,
"Batch knowledge retrieval successful, requested count: %d, returned count: %d",
len(req.IDs), len(knowledges),
)
logger.Infof(ctx, "Batch knowledge retrieval successful, requested count: %d, returned count: %d",
len(req.IDs), len(knowledges))
// Return results
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": knowledges,
@@ -623,7 +771,7 @@ func (h *KnowledgeHandler) GetKnowledgeBatch(c *gin.Context) {
// @Router /knowledge/{id} [put]
func (h *KnowledgeHandler) UpdateKnowledge(c *gin.Context) {
ctx := c.Request.Context()
// Get knowledge ID from URL path parameter
id := secutils.SanitizeForLog(c.Param("id"))
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
@@ -631,14 +779,21 @@ func (h *KnowledgeHandler) UpdateKnowledge(c *gin.Context) {
return
}
_, effCtx, err := h.resolveKnowledgeAndValidateKBAccess(c, id, types.OrgRoleEditor)
if err != nil {
c.Error(err)
return
}
var knowledge types.Knowledge
if err := c.ShouldBindJSON(&knowledge); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
knowledge.ID = id
if err := h.kgService.UpdateKnowledge(ctx, &knowledge); err != nil {
if err := h.kgService.UpdateKnowledge(effCtx, &knowledge); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
@@ -675,6 +830,12 @@ func (h *KnowledgeHandler) UpdateManualKnowledge(c *gin.Context) {
return
}
_, effCtx, err := h.resolveKnowledgeAndValidateKBAccess(c, id, types.OrgRoleEditor)
if err != nil {
c.Error(err)
return
}
var req types.ManualKnowledgePayload
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse manual knowledge update request", err)
@@ -682,7 +843,7 @@ func (h *KnowledgeHandler) UpdateManualKnowledge(c *gin.Context) {
return
}
knowledge, err := h.kgService.UpdateManualKnowledge(ctx, id, &req)
knowledge, err := h.kgService.UpdateManualKnowledge(effCtx, id, &req)
if err != nil {
if appErr, ok := errors.IsAppError(err); ok {
c.Error(appErr)
@@ -704,15 +865,16 @@ func (h *KnowledgeHandler) UpdateManualKnowledge(c *gin.Context) {
type knowledgeTagBatchRequest struct {
Updates map[string]*string `json:"updates" binding:"required,min=1"`
KBID string `json:"kb_id"` // Optional: scope to this KB (validates editor access and uses effective tenant for shared KB)
}
// UpdateKnowledgeTagBatch godoc
// @Summary 批量更新知识标签
// @Description 批量更新知识条目的标签
// @Description 批量更新知识条目的标签。可选 kb_id:指定时按该知识库校验编辑权限并用于共享知识库的租户解析
// @Tags 知识管理
// @Accept json
// @Produce json
// @Param request body object true "标签更新请求"
// @Param request body object true "标签更新请求(updates 必填,kb_id 可选)"
// @Success 200 {object} map[string]interface{} "更新成功"
// @Failure 400 {object} errors.AppError "请求参数错误"
// @Security Bearer
@@ -720,12 +882,49 @@ type knowledgeTagBatchRequest struct {
// @Router /knowledge/tags [put]
func (h *KnowledgeHandler) UpdateKnowledgeTagBatch(c *gin.Context) {
ctx := c.Request.Context()
// Ensure tenant ID is in context (service reads it; may be missing if request context was not set by auth)
tenantID := c.GetUint64(types.TenantIDContextKey.String())
if tenantID == 0 {
c.Error(errors.NewUnauthorizedError("Unauthorized"))
return
}
ctx = context.WithValue(ctx, types.TenantIDContextKey, tenantID)
var req knowledgeTagBatchRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse knowledge tag batch request", err)
c.Error(errors.NewBadRequestError("请求参数不合法").WithDetails(err.Error()))
return
}
// Resolve effective tenant: explicit kb_id, or infer from first knowledge ID (for shared KB when frontend doesn't send kb_id)
if kbID := secutils.SanitizeForLog(req.KBID); kbID != "" {
_, _, effID, permission, err := h.validateKnowledgeBaseAccessWithKBID(c, kbID)
if err != nil {
c.Error(err)
return
}
if permission != types.OrgRoleAdmin && permission != types.OrgRoleEditor {
c.Error(errors.NewForbiddenError("No permission to update knowledge tags"))
return
}
ctx = context.WithValue(ctx, types.TenantIDContextKey, effID)
} else if len(req.Updates) > 0 {
// No kb_id: infer from first knowledge ID so shared-KB updates work without client sending kb_id
var firstKnowledgeID string
for id := range req.Updates {
firstKnowledgeID = id
break
}
if firstKnowledgeID != "" {
_, effCtx, err := h.resolveKnowledgeAndValidateKBAccess(c, firstKnowledgeID, types.OrgRoleEditor)
if err != nil {
c.Error(err)
return
}
ctx = effCtx
}
}
if err := h.kgService.UpdateKnowledgeTagBatch(ctx, req.Updates); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(err)
@@ -754,7 +953,6 @@ func (h *KnowledgeHandler) UpdateImageInfo(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start updating image info")
// Get knowledge ID from URL path parameter
id := secutils.SanitizeForLog(c.Param("id"))
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
@@ -768,6 +966,12 @@ func (h *KnowledgeHandler) UpdateImageInfo(c *gin.Context) {
return
}
_, effCtx, err := h.resolveKnowledgeAndValidateKBAccess(c, id, types.OrgRoleEditor)
if err != nil {
c.Error(err)
return
}
var request struct {
ImageInfo string `json:"image_info"`
}
@@ -778,9 +982,8 @@ func (h *KnowledgeHandler) UpdateImageInfo(c *gin.Context) {
return
}
// Update chunk properties
logger.Infof(ctx, "Updating knowledge chunk, knowledge ID: %s, chunk ID: %s", id, chunkID)
err := h.kgService.UpdateImageInfo(ctx, id, chunkID, secutils.SanitizeForLog(request.ImageInfo))
err = h.kgService.UpdateImageInfo(effCtx, id, chunkID, secutils.SanitizeForLog(request.ImageInfo))
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
@@ -811,6 +1014,9 @@ func (h *KnowledgeHandler) UpdateImageInfo(c *gin.Context) {
// @Router /knowledge/search [get]
func (h *KnowledgeHandler) SearchKnowledge(c *gin.Context) {
ctx := c.Request.Context()
if userID, ok := c.Get(types.UserIDContextKey.String()); ok {
ctx = context.WithValue(ctx, types.UserIDContextKey, userID)
}
keyword := c.Query("keyword")
offset, _ := strconv.Atoi(c.DefaultQuery("offset", "0"))
limit, _ := strconv.Atoi(c.DefaultQuery("limit", "20"))
@@ -826,7 +1032,7 @@ func (h *KnowledgeHandler) SearchKnowledge(c *gin.Context) {
}
}
// Retrieve knowledge entries (empty keyword returns recent files)
// Retrieve knowledge entries (own + shared KBs; empty keyword returns recent files)
knowledges, hasMore, err := h.kgService.SearchKnowledge(ctx, keyword, offset, limit, fileTypes)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
+81 -25
View File
@@ -22,6 +22,7 @@ import (
type KnowledgeBaseHandler struct {
service interfaces.KnowledgeBaseService
knowledgeService interfaces.KnowledgeService
kbShareService interfaces.KBShareService
asynqClient *asynq.Client
}
@@ -29,11 +30,13 @@ type KnowledgeBaseHandler struct {
func NewKnowledgeBaseHandler(
service interfaces.KnowledgeBaseService,
knowledgeService interfaces.KnowledgeService,
kbShareService interfaces.KBShareService,
asynqClient *asynq.Client,
) *KnowledgeBaseHandler {
return &KnowledgeBaseHandler{
service: service,
knowledgeService: knowledgeService,
kbShareService: kbShareService,
asynqClient: asynqClient,
}
}
@@ -56,11 +59,10 @@ func (h *KnowledgeBaseHandler) HybridSearch(c *gin.Context) {
logger.Info(ctx, "Start hybrid search")
// Validate knowledge base ID
id := secutils.SanitizeForLog(c.Param("id"))
if id == "" {
logger.Error(ctx, "Knowledge base ID is empty")
c.Error(errors.NewBadRequestError("Knowledge base ID cannot be empty"))
// Validate and check permission for knowledge base access
_, id, effectiveTenantID, _, err := h.validateAndGetKnowledgeBase(c)
if err != nil {
c.Error(err)
return
}
@@ -72,10 +74,11 @@ func (h *KnowledgeBaseHandler) HybridSearch(c *gin.Context) {
return
}
logger.Infof(ctx, "Executing hybrid search, knowledge base ID: %s, query: %s",
secutils.SanitizeForLog(id), secutils.SanitizeForLog(req.QueryText))
logger.Infof(ctx, "Executing hybrid search, knowledge base ID: %s, query: %s, effectiveTenantID: %d",
secutils.SanitizeForLog(id), secutils.SanitizeForLog(req.QueryText), effectiveTenantID)
// Execute hybrid search with default search parameters
// Note: For shared KBs, the service uses effectiveTenantID internally via context
results, err := h.service.HybridSearch(ctx, id, req)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
@@ -139,43 +142,64 @@ func (h *KnowledgeBaseHandler) CreateKnowledgeBase(c *gin.Context) {
}
// validateAndGetKnowledgeBase validates request parameters and retrieves the knowledge base
// Returns the knowledge base, knowledge base ID, and any errors encountered
func (h *KnowledgeBaseHandler) validateAndGetKnowledgeBase(c *gin.Context) (*types.KnowledgeBase, string, error) {
// Returns the knowledge base, knowledge base ID, effective tenant ID for embedding, permission level, and any errors encountered
// For owned KBs, effectiveTenantID is the caller's tenant ID
// For shared KBs, effectiveTenantID is the source tenant ID (owner's tenant)
func (h *KnowledgeBaseHandler) validateAndGetKnowledgeBase(c *gin.Context) (*types.KnowledgeBase, string, uint64, types.OrgMemberRole, error) {
ctx := c.Request.Context()
// Get tenant ID from context
tenantID, exists := c.Get(types.TenantIDContextKey.String())
if !exists {
logger.Error(ctx, "Failed to get tenant ID")
return nil, "", errors.NewUnauthorizedError("Unauthorized")
return nil, "", 0, "", errors.NewUnauthorizedError("Unauthorized")
}
// Get user ID from context (needed for shared KB permission check)
userID, userExists := c.Get(types.UserIDContextKey.String())
// Get knowledge base ID from URL parameter
id := secutils.SanitizeForLog(c.Param("id"))
if id == "" {
logger.Error(ctx, "Knowledge base ID is empty")
return nil, "", errors.NewBadRequestError("Knowledge base ID cannot be empty")
return nil, "", 0, "", errors.NewBadRequestError("Knowledge base ID cannot be empty")
}
// Verify tenant has permission to access this knowledge base
kb, err := h.service.GetKnowledgeBaseByID(ctx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
return nil, id, errors.NewInternalServerError(err.Error())
return nil, id, 0, "", errors.NewInternalServerError(err.Error())
}
// Verify tenant ownership
if kb.TenantID != tenantID.(uint64) {
logger.Warnf(
ctx,
"Tenant has no permission to access this knowledge base, knowledge base ID: %s, "+
"request tenant ID: %d, knowledge base tenant ID: %d",
id, tenantID.(uint64), kb.TenantID,
)
return nil, id, errors.NewForbiddenError("No permission to operate")
// Check 1: Verify tenant ownership (owner has full access)
if kb.TenantID == tenantID.(uint64) {
return kb, id, tenantID.(uint64), types.OrgRoleAdmin, nil
}
return kb, id, nil
// Check 2: If not owner, check organization shared access
if userExists && h.kbShareService != nil {
// Check if user has shared access through organization
permission, isShared, permErr := h.kbShareService.CheckUserKBPermission(ctx, id, userID.(string))
if permErr == nil && isShared {
// User has shared access, get the source tenant ID for embedding queries
sourceTenantID, srcErr := h.kbShareService.GetKBSourceTenant(ctx, id)
if srcErr == nil {
logger.Infof(ctx, "User %s accessing shared KB %s with permission %s, source tenant: %d",
userID.(string), id, permission, sourceTenantID)
return kb, id, sourceTenantID, permission, nil
}
}
}
// No permission: not owner and no shared access
logger.Warnf(
ctx,
"Tenant has no permission to access this knowledge base, knowledge base ID: %s, "+
"request tenant ID: %d, knowledge base tenant ID: %d",
id, tenantID.(uint64), kb.TenantID,
)
return nil, id, 0, "", errors.NewForbiddenError("No permission to operate")
}
// GetKnowledgeBase godoc
@@ -193,7 +217,7 @@ func (h *KnowledgeBaseHandler) validateAndGetKnowledgeBase(c *gin.Context) (*typ
// @Router /knowledge-bases/{id} [get]
func (h *KnowledgeBaseHandler) GetKnowledgeBase(c *gin.Context) {
// Validate and get the knowledge base
kb, _, err := h.validateAndGetKnowledgeBase(c)
kb, _, _, _, err := h.validateAndGetKnowledgeBase(c)
if err != nil {
c.Error(err)
return
@@ -226,6 +250,25 @@ func (h *KnowledgeBaseHandler) ListKnowledgeBases(c *gin.Context) {
return
}
// Get share counts for all knowledge bases
if len(kbs) > 0 && h.kbShareService != nil {
kbIDs := make([]string, len(kbs))
for i, kb := range kbs {
kbIDs[i] = kb.ID
}
shareCounts, err := h.kbShareService.CountSharesByKnowledgeBaseIDs(ctx, kbIDs)
if err != nil {
logger.Warnf(ctx, "Failed to get share counts: %v", err)
} else {
for _, kb := range kbs {
if count, ok := shareCounts[kb.ID]; ok {
kb.ShareCount = count
}
}
}
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": kbs,
@@ -257,12 +300,18 @@ func (h *KnowledgeBaseHandler) UpdateKnowledgeBase(c *gin.Context) {
logger.Info(ctx, "Start updating knowledge base")
// Validate and get the knowledge base
_, id, err := h.validateAndGetKnowledgeBase(c)
_, id, _, permission, err := h.validateAndGetKnowledgeBase(c)
if err != nil {
c.Error(err)
return
}
// Only admin/editor can update knowledge base
if permission != types.OrgRoleAdmin && permission != types.OrgRoleEditor {
c.Error(errors.NewForbiddenError("No permission to update knowledge base"))
return
}
// Parse request body
var req UpdateKnowledgeBaseRequest
if err := c.ShouldBindJSON(&req); err != nil {
@@ -307,12 +356,19 @@ func (h *KnowledgeBaseHandler) DeleteKnowledgeBase(c *gin.Context) {
logger.Info(ctx, "Start deleting knowledge base")
// Validate and get the knowledge base
kb, id, err := h.validateAndGetKnowledgeBase(c)
kb, id, _, permission, err := h.validateAndGetKnowledgeBase(c)
if err != nil {
c.Error(err)
return
}
// Only owner (admin with matching tenant) can delete knowledge base
tenantID, _ := c.Get(types.TenantIDContextKey.String())
if kb.TenantID != tenantID.(uint64) || permission != types.OrgRoleAdmin {
c.Error(errors.NewForbiddenError("Only knowledge base owner can delete"))
return
}
logger.Infof(ctx, "Deleting knowledge base, ID: %s, name: %s",
secutils.SanitizeForLog(id), secutils.SanitizeForLog(kb.Name))
File diff suppressed because it is too large Load Diff
+44 -2
View File
@@ -86,6 +86,48 @@ func (h *Handler) parseQARequest(c *gin.Context, logPrefix string) (*qaRequestCo
}
}
// Merge @mentioned items into knowledge_base_ids and knowledge_ids so that
// retrieval (quick-answer and agent mode) uses the same targets the user @mentioned.
// This fixes the case where user only @mentions a (shared) KB in the input but
// does not select it in the sidebar — without this merge, retrieval would not search those KBs.
kbIDs := make([]string, 0, len(request.KnowledgeBaseIDs)+len(request.MentionedItems))
kbIDSet := make(map[string]bool)
for _, id := range request.KnowledgeBaseIDs {
if id != "" && !kbIDSet[id] {
kbIDs = append(kbIDs, id)
kbIDSet[id] = true
}
}
knowledgeIDs := make([]string, 0, len(request.KnowledgeIds)+len(request.MentionedItems))
knowledgeIDSet := make(map[string]bool)
for _, id := range request.KnowledgeIds {
if id != "" && !knowledgeIDSet[id] {
knowledgeIDs = append(knowledgeIDs, id)
knowledgeIDSet[id] = true
}
}
for _, item := range request.MentionedItems {
if item.ID == "" {
continue
}
switch item.Type {
case "kb":
if !kbIDSet[item.ID] {
kbIDs = append(kbIDs, item.ID)
kbIDSet[item.ID] = true
}
case "file":
if !knowledgeIDSet[item.ID] {
knowledgeIDs = append(knowledgeIDs, item.ID)
knowledgeIDSet[item.ID] = true
}
}
}
// Log merge results for debugging
logger.Infof(ctx, "[%s] @mention merge: request.KnowledgeBaseIDs=%v, request.MentionedItems=%d, merged kbIDs=%v, merged knowledgeIDs=%v",
logPrefix, request.KnowledgeBaseIDs, len(request.MentionedItems), kbIDs, knowledgeIDs)
// Build request context
reqCtx := &qaRequestContext{
ctx: ctx,
@@ -101,8 +143,8 @@ func (h *Handler) parseQARequest(c *gin.Context, logPrefix string) (*qaRequestCo
RequestID: c.GetString(types.RequestIDContextKey.String()),
IsCompleted: false,
},
knowledgeBaseIDs: secutils.SanitizeForLogArray(request.KnowledgeBaseIDs),
knowledgeIDs: secutils.SanitizeForLogArray(request.KnowledgeIds),
knowledgeBaseIDs: secutils.SanitizeForLogArray(kbIDs),
knowledgeIDs: secutils.SanitizeForLogArray(knowledgeIDs),
summaryModelID: secutils.SanitizeForLog(request.SummaryModelID),
webSearchEnabled: request.WebSearchEnabled,
mentionedItems: convertMentionedItems(request.MentionedItems),
+88 -21
View File
@@ -16,9 +16,11 @@ import (
// TagHandler handles knowledge base tag operations.
type TagHandler struct {
tagService interfaces.KnowledgeTagService
tagRepo interfaces.KnowledgeTagRepository
chunkRepo interfaces.ChunkRepository
tagService interfaces.KnowledgeTagService
tagRepo interfaces.KnowledgeTagRepository
chunkRepo interfaces.ChunkRepository
kbService interfaces.KnowledgeBaseService
kbShareService interfaces.KBShareService
}
// DeleteTagRequest represents the request body for deleting a tag
@@ -27,19 +29,62 @@ type DeleteTagRequest struct {
}
// NewTagHandler creates a new TagHandler.
func NewTagHandler(tagService interfaces.KnowledgeTagService, tagRepo interfaces.KnowledgeTagRepository, chunkRepo interfaces.ChunkRepository) *TagHandler {
return &TagHandler{tagService: tagService, tagRepo: tagRepo, chunkRepo: chunkRepo}
func NewTagHandler(
tagService interfaces.KnowledgeTagService,
tagRepo interfaces.KnowledgeTagRepository,
chunkRepo interfaces.ChunkRepository,
kbService interfaces.KnowledgeBaseService,
kbShareService interfaces.KBShareService,
) *TagHandler {
return &TagHandler{tagService: tagService, tagRepo: tagRepo, chunkRepo: chunkRepo, kbService: kbService, kbShareService: kbShareService}
}
// effectiveCtxForKB validates KB access (owner or shared) and returns context with effectiveTenantID for downstream service calls.
func (h *TagHandler) effectiveCtxForKB(c *gin.Context, kbID string) (context.Context, error) {
ctx := c.Request.Context()
tenantID := c.GetUint64(types.TenantIDContextKey.String())
if tenantID == 0 {
return nil, errors.NewUnauthorizedError("Unauthorized")
}
userID, userExists := c.Get(types.UserIDContextKey.String())
kbID = secutils.SanitizeForLog(kbID)
if kbID == "" {
return nil, errors.NewBadRequestError("Knowledge base ID cannot be empty")
}
kb, err := h.kbService.GetKnowledgeBaseByID(ctx, kbID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
return nil, errors.NewInternalServerError(err.Error())
}
if kb.TenantID == tenantID {
return context.WithValue(ctx, types.TenantIDContextKey, tenantID), nil
}
if userExists && h.kbShareService != nil {
permission, isShared, permErr := h.kbShareService.CheckUserKBPermission(ctx, kbID, userID.(string))
if permErr == nil && isShared {
sourceTenantID, srcErr := h.kbShareService.GetKBSourceTenant(ctx, kbID)
if srcErr == nil {
logger.Infof(ctx, "User %s accessing shared KB %s with permission %s, source tenant: %d",
userID.(string), kbID, permission, sourceTenantID)
return context.WithValue(ctx, types.TenantIDContextKey, sourceTenantID), nil
}
}
}
logger.Warnf(ctx, "Permission denied to access KB %s", kbID)
return nil, errors.NewForbiddenError("Permission denied to access this knowledge base")
}
// resolveTagID resolves tag_id parameter which can be either UUID or seq_id (integer).
// Returns the UUID of the tag.
// Uses tenant from c's context. Use resolveTagIDWithCtx when effectiveTenantID is set (e.g. shared KB).
func (h *TagHandler) resolveTagID(c *gin.Context) (string, error) {
ctx := c.Request.Context()
return h.resolveTagIDWithCtx(c, c.Request.Context())
}
// resolveTagIDWithCtx resolves tag_id using the given context for tenant (e.g. effCtx for shared KB).
func (h *TagHandler) resolveTagIDWithCtx(c *gin.Context, ctx context.Context) (string, error) {
tagIDParam := secutils.SanitizeForLog(c.Param("tag_id"))
// Try to parse as integer (seq_id)
if seqID, err := strconv.ParseInt(tagIDParam, 10, 64); err == nil {
// It's an integer, look up by seq_id
tenantID := ctx.Value(types.TenantIDContextKey).(uint64)
tag, err := h.tagRepo.GetBySeqID(ctx, tenantID, seqID)
if err != nil {
@@ -47,8 +92,6 @@ func (h *TagHandler) resolveTagID(c *gin.Context) (string, error) {
}
return tag.ID, nil
}
// It's a UUID string
return tagIDParam, nil
}
@@ -76,6 +119,12 @@ func (h *TagHandler) ListTags(c *gin.Context) {
ctx := c.Request.Context()
kbID := secutils.SanitizeForLog(c.Param("id"))
effCtx, err := h.effectiveCtxForKB(c, kbID)
if err != nil {
c.Error(err)
return
}
var page types.Pagination
if err := c.ShouldBindQuery(&page); err != nil {
logger.Error(ctx, "Failed to bind pagination query", err)
@@ -85,7 +134,7 @@ func (h *TagHandler) ListTags(c *gin.Context) {
keyword := secutils.SanitizeForLog(c.Query("keyword"))
tags, err := h.tagService.ListTags(ctx, kbID, &page, keyword)
tags, err := h.tagService.ListTags(effCtx, kbID, &page, keyword)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(err)
@@ -121,6 +170,12 @@ func (h *TagHandler) CreateTag(c *gin.Context) {
ctx := c.Request.Context()
kbID := secutils.SanitizeForLog(c.Param("id"))
effCtx, err := h.effectiveCtxForKB(c, kbID)
if err != nil {
c.Error(err)
return
}
var req createTagRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to bind create tag payload", err)
@@ -128,7 +183,7 @@ func (h *TagHandler) CreateTag(c *gin.Context) {
return
}
tag, err := h.tagService.CreateTag(ctx, kbID,
tag, err := h.tagService.CreateTag(effCtx, kbID,
secutils.SanitizeForLog(req.Name), secutils.SanitizeForLog(req.Color), req.SortOrder)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
@@ -166,8 +221,15 @@ type updateTagRequest struct {
// @Router /knowledge-bases/{id}/tags/{tag_id} [put]
func (h *TagHandler) UpdateTag(c *gin.Context) {
ctx := c.Request.Context()
kbID := secutils.SanitizeForLog(c.Param("id"))
tagID, err := h.resolveTagID(c)
effCtx, err := h.effectiveCtxForKB(c, kbID)
if err != nil {
c.Error(err)
return
}
tagID, err := h.resolveTagIDWithCtx(c, effCtx)
if err != nil {
c.Error(err)
return
@@ -180,7 +242,7 @@ func (h *TagHandler) UpdateTag(c *gin.Context) {
return
}
tag, err := h.tagService.UpdateTag(ctx, tagID, req.Name, req.Color, req.SortOrder)
tag, err := h.tagService.UpdateTag(effCtx, tagID, req.Name, req.Color, req.SortOrder)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tag_id": tagID,
@@ -213,8 +275,15 @@ func (h *TagHandler) UpdateTag(c *gin.Context) {
// @Router /knowledge-bases/{id}/tags/{tag_id} [delete]
func (h *TagHandler) DeleteTag(c *gin.Context) {
ctx := c.Request.Context()
kbID := secutils.SanitizeForLog(c.Param("id"))
tagID, err := h.resolveTagID(c)
effCtx, err := h.effectiveCtxForKB(c, kbID)
if err != nil {
c.Error(err)
return
}
tagID, err := h.resolveTagIDWithCtx(c, effCtx)
if err != nil {
c.Error(err)
return
@@ -224,14 +293,12 @@ func (h *TagHandler) DeleteTag(c *gin.Context) {
contentOnly := c.Query("content_only") == "true"
var req DeleteTagRequest
// Ignore bind error since body is optional
_ = c.ShouldBindJSON(&req)
// Convert seq_ids to UUIDs for excludeIDs
var excludeUUIDs []string
if len(req.ExcludeIDs) > 0 {
tenantID := ctx.Value(types.TenantIDContextKey).(uint64)
chunks, err := h.getChunksBySeqIDs(ctx, tenantID, req.ExcludeIDs)
tenantID := effCtx.Value(types.TenantIDContextKey).(uint64)
chunks, err := h.getChunksBySeqIDs(effCtx, tenantID, req.ExcludeIDs)
if err != nil {
logger.Warnf(ctx, "Failed to resolve exclude_ids: %v", err)
} else {
@@ -242,7 +309,7 @@ func (h *TagHandler) DeleteTag(c *gin.Context) {
}
}
if err := h.tagService.DeleteTag(ctx, tagID, force, contentOnly, excludeUUIDs); err != nil {
if err := h.tagService.DeleteTag(effCtx, tagID, force, contentOnly, excludeUUIDs); err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"tag_id": tagID,
})