ae7cd02cd6
Self-review of PR 3's TenantMembers.vue surfaced a handful of real bugs
and a few rough edges. This commit fixes them and adds the self-leave
endpoint that PR 3's design called out as a follow-up.
Frontend bug fixes
- Read err.status (not err.response.status). The axios interceptor in
utils/request.ts already flattens errors into { status, message,
... }, so the original branch-by-status code never matched and every
4xx fell through to the generic toast. Fixes 404/409 surfacing as
"userNotFound" / "alreadyMember" / "lastOwner" instead of "Something
went wrong".
- t-dialog @confirm replaces :on-confirm so the dialog stays open on
validation failure and on API error. Users can fix and retry without
retyping the email.
- Drop the t-select revert hack; with :model-value the rendered value
is already source-of-truth-on-row.role, so no setTimeout dance is
needed.
- Don't toast "no active tenant" on cold mount; watch the activeTenantId
ref and load once the auth store hydrates.
Frontend UX additions
- Empty state via t-empty (also covers the search-no-results case).
- Compact role-permissions matrix above the table, mirroring
OrganizationSettingsModal so Owners can see what each role grants
before promoting/inviting.
- Search box filtering by username/email (client-side, sufficient for
expected per-tenant member counts).
- "Leave Tenant" button — visible to any active member except the
last-Owner case (server still enforces).
Backend
- New POST /tenants/:id/leave route. Calls TenantMemberService.RemoveMember
with the caller's own user id so non-Owners can quit on their own.
Gated Viewer+ in the matrix; the existing last-Owner invariant in the
service still rejects last-Owner self-leave with 409.
- 3 new handler tests cover the happy path, the last-Owner 409 path,
and the missing-caller-id 401 path (defensive — auth middleware
always attaches a user, but the test pins the contract).
i18n
- Add tenantMember.permissions / search / leave / empty strings in all
four locales (en/zh/ko/ru).
1175 lines
49 KiB
Go
1175 lines
49 KiB
Go
package router
|
||
|
||
import (
|
||
"context"
|
||
"io"
|
||
"net/http"
|
||
"os"
|
||
"path/filepath"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
filesvc "github.com/Tencent/WeKnora/internal/application/service/file"
|
||
"github.com/gin-contrib/cors"
|
||
"github.com/gin-gonic/gin"
|
||
swaggerFiles "github.com/swaggo/files"
|
||
ginSwagger "github.com/swaggo/gin-swagger"
|
||
"go.uber.org/dig"
|
||
|
||
"github.com/Tencent/WeKnora/internal/config"
|
||
"github.com/Tencent/WeKnora/internal/handler"
|
||
"github.com/Tencent/WeKnora/internal/handler/session"
|
||
"github.com/Tencent/WeKnora/internal/logger"
|
||
"github.com/Tencent/WeKnora/internal/middleware"
|
||
"github.com/Tencent/WeKnora/internal/tracing/langfuse"
|
||
"github.com/Tencent/WeKnora/internal/types"
|
||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||
secutils "github.com/Tencent/WeKnora/internal/utils"
|
||
|
||
_ "github.com/Tencent/WeKnora/docs" // swagger docs
|
||
)
|
||
|
||
// RouterParams 路由参数
|
||
type RouterParams struct {
|
||
dig.In
|
||
|
||
Config *config.Config
|
||
FileService interfaces.FileService
|
||
UserService interfaces.UserService
|
||
KBService interfaces.KnowledgeBaseService
|
||
KnowledgeService interfaces.KnowledgeService
|
||
ChunkService interfaces.ChunkService
|
||
SessionService interfaces.SessionService
|
||
MessageService interfaces.MessageService
|
||
ModelService interfaces.ModelService
|
||
EvaluationService interfaces.EvaluationService
|
||
KBHandler *handler.KnowledgeBaseHandler
|
||
KnowledgeHandler *handler.KnowledgeHandler
|
||
TenantHandler *handler.TenantHandler
|
||
TenantService interfaces.TenantService
|
||
TenantMemberService interfaces.TenantMemberService
|
||
TenantMemberHandler *handler.TenantMemberHandler
|
||
ChunkHandler *handler.ChunkHandler
|
||
SessionHandler *session.Handler
|
||
MessageHandler *handler.MessageHandler
|
||
ModelHandler *handler.ModelHandler
|
||
ModelCredentialsHandler *handler.ModelCredentialsHandler
|
||
EvaluationHandler *handler.EvaluationHandler
|
||
AuthHandler *handler.AuthHandler
|
||
InitializationHandler *handler.InitializationHandler
|
||
SystemHandler *handler.SystemHandler
|
||
MCPServiceHandler *handler.MCPServiceHandler
|
||
MCPCredentialsHandler *handler.MCPCredentialsHandler
|
||
WebSearchHandler *handler.WebSearchHandler
|
||
WebSearchProviderHandler *handler.WebSearchProviderHandler
|
||
WebSearchCredentialsHandler *handler.WebSearchProviderCredentialsHandler
|
||
VectorStoreHandler *handler.VectorStoreHandler
|
||
FAQHandler *handler.FAQHandler
|
||
TagHandler *handler.TagHandler
|
||
CustomAgentHandler *handler.CustomAgentHandler
|
||
SkillHandler *handler.SkillHandler
|
||
OrganizationHandler *handler.OrganizationHandler
|
||
IMHandler *handler.IMHandler
|
||
DataSourceHandler *handler.DataSourceHandler
|
||
DataSourceCredentialsHandler *handler.DataSourceCredentialsHandler
|
||
WeKnoraCloudHandler *handler.WeKnoraCloudHandler
|
||
WikiPageHandler *handler.WikiPageHandler
|
||
}
|
||
|
||
// NewRouter 创建新的路由
|
||
func NewRouter(params RouterParams) *gin.Engine {
|
||
r := gin.New()
|
||
r.ContextWithFallback = true
|
||
|
||
// CORS 中间件应放在最前面
|
||
r.Use(cors.New(cors.Config{
|
||
AllowOrigins: []string{"*"},
|
||
AllowMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
|
||
AllowHeaders: []string{"Origin", "Content-Type", "Accept", "Authorization", "X-API-Key", "X-Request-ID"},
|
||
ExposeHeaders: []string{"Content-Length", "Access-Control-Allow-Origin"},
|
||
AllowCredentials: true,
|
||
MaxAge: 12 * time.Hour,
|
||
}))
|
||
|
||
// 基础中间件(不需要认证)
|
||
r.Use(middleware.RequestID())
|
||
r.Use(middleware.Language())
|
||
r.Use(middleware.Logger())
|
||
r.Use(middleware.Recovery())
|
||
r.Use(middleware.ErrorHandler())
|
||
|
||
// 健康检查(不需要认证)
|
||
r.GET("/health", func(c *gin.Context) {
|
||
c.JSON(200, gin.H{"status": "ok"})
|
||
})
|
||
|
||
// Swagger API 文档(仅在非生产环境下启用)
|
||
// 通过 GIN_MODE 环境变量判断:release 模式下禁用 Swagger
|
||
if gin.Mode() != gin.ReleaseMode {
|
||
r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler,
|
||
ginSwagger.DefaultModelsExpandDepth(-1), // 默认折叠 Models
|
||
ginSwagger.DocExpansion("list"), // 展开模式: "list"(展开标签), "full"(全部展开), "none"(全部折叠)
|
||
ginSwagger.DeepLinking(true), // 启用深度链接
|
||
ginSwagger.PersistAuthorization(true), // 持久化认证信息
|
||
))
|
||
}
|
||
|
||
// 前端静态文件(仅 Lite 版本内嵌前端)
|
||
if handler.Edition == "lite" {
|
||
serveFrontendStatic(r)
|
||
}
|
||
|
||
// IM 回调路由(在认证中间件之前注册,使用各平台自身的签名验证)
|
||
RegisterIMRoutes(r, params.IMHandler)
|
||
|
||
// 认证中间件
|
||
r.Use(middleware.Auth(params.TenantService, params.UserService, params.TenantMemberService, params.Config))
|
||
|
||
// 文件服务:统一代理本地/MinIO/COS/TOS存储后端(需要认证)
|
||
serveFiles(r, params.FileService)
|
||
|
||
// Presigned file access: no auth required, signature-verified.
|
||
servePresignedFiles(r, params.TenantService)
|
||
|
||
// 添加OpenTelemetry追踪中间件
|
||
// r.Use(middleware.TracingMiddleware())
|
||
|
||
// Langfuse observability — only active when LANGFUSE_* env vars are set.
|
||
// The middleware is registered unconditionally; when disabled it's a no-op.
|
||
r.Use(langfuse.GinMiddleware())
|
||
|
||
// 需要认证的API路由
|
||
v1 := r.Group("/api/v1")
|
||
{
|
||
// rbacGuards bundles the role-gating middleware factories so each
|
||
// Register* function below can attach the right guard without
|
||
// taking a *config.Config dependency directly. The guards honour
|
||
// cfg.Tenant.EnableRBAC: when false, they log but pass through,
|
||
// preserving today's behaviour during the rollout window.
|
||
rbacGuards := newRBACGuards(params.Config, params.KBHandler, params.CustomAgentHandler)
|
||
|
||
RegisterAuthRoutes(v1, params.AuthHandler)
|
||
RegisterTenantRoutes(v1, params.TenantHandler, params.TenantMemberHandler, rbacGuards)
|
||
RegisterKnowledgeBaseRoutes(v1, params.KBHandler, rbacGuards)
|
||
RegisterKnowledgeTagRoutes(v1, params.TagHandler, rbacGuards)
|
||
RegisterKnowledgeRoutes(v1, params.KnowledgeHandler, rbacGuards)
|
||
RegisterFAQRoutes(v1, params.FAQHandler, rbacGuards)
|
||
RegisterChunkRoutes(v1, params.ChunkHandler, rbacGuards)
|
||
RegisterSessionRoutes(v1, params.SessionHandler, rbacGuards)
|
||
RegisterChatRoutes(v1, params.SessionHandler, rbacGuards)
|
||
RegisterMessageRoutes(v1, params.MessageHandler, rbacGuards)
|
||
RegisterModelRoutes(v1, params.ModelHandler, params.ModelCredentialsHandler, rbacGuards)
|
||
RegisterEvaluationRoutes(v1, params.EvaluationHandler)
|
||
RegisterInitializationRoutes(v1, params.InitializationHandler)
|
||
RegisterSystemRoutes(v1, params.SystemHandler)
|
||
RegisterMCPServiceRoutes(v1, params.MCPServiceHandler, params.MCPCredentialsHandler, rbacGuards)
|
||
RegisterWebSearchRoutes(v1, params.WebSearchHandler, rbacGuards)
|
||
RegisterWebSearchProviderRoutes(v1, params.WebSearchProviderHandler, params.WebSearchCredentialsHandler, rbacGuards)
|
||
RegisterVectorStoreRoutes(v1, params.VectorStoreHandler, rbacGuards)
|
||
RegisterCustomAgentRoutes(v1, params.CustomAgentHandler, rbacGuards)
|
||
RegisterSkillRoutes(v1, params.SkillHandler, rbacGuards)
|
||
RegisterOrganizationRoutes(v1, params.OrganizationHandler)
|
||
RegisterIMChannelRoutes(v1, params.IMHandler, rbacGuards)
|
||
RegisterDataSourceRoutes(v1, params.DataSourceHandler, params.DataSourceCredentialsHandler, rbacGuards)
|
||
RegisterWeKnoraCloudRoutes(v1, params.WeKnoraCloudHandler, rbacGuards)
|
||
RegisterWikiPageRoutes(v1, params.WikiPageHandler, rbacGuards)
|
||
RegisterChunkerDebugRoutes(v1)
|
||
}
|
||
|
||
return r
|
||
}
|
||
|
||
// RegisterChunkerDebugRoutes wires the read-only chunker preview endpoint
|
||
// used by the KB editor's debug panel. Stateless — uses no service deps.
|
||
func RegisterChunkerDebugRoutes(r *gin.RouterGroup) {
|
||
r.POST("/chunker/preview", handler.PreviewChunking)
|
||
}
|
||
|
||
// RegisterChunkRoutes 注册分块相关的路由
|
||
func RegisterChunkRoutes(r *gin.RouterGroup, handler *handler.ChunkHandler, g *rbacGuards) {
|
||
// 分块路由组
|
||
chunks := r.Group("/chunks")
|
||
{
|
||
// 获取分块列表 — Viewer+
|
||
chunks.GET("/:knowledge_id", g.Viewer(), handler.ListKnowledgeChunks)
|
||
// 通过chunk_id获取单个chunk(不需要knowledge_id) — Viewer+
|
||
chunks.GET("/by-id/:id", g.Viewer(), handler.GetChunkByIDOnly)
|
||
// 删除分块 — Contributor+ (per-KB ownership granularity is a follow-up; PR 2 v1 keeps tenant-wide edit for chunks)
|
||
chunks.DELETE("/:knowledge_id/:id", g.Contributor(), handler.DeleteChunk)
|
||
// 删除知识下的所有分块 — Contributor+
|
||
chunks.DELETE("/:knowledge_id", g.Contributor(), handler.DeleteChunksByKnowledgeID)
|
||
// 更新分块信息 — Contributor+
|
||
chunks.PUT("/:knowledge_id/:id", g.Contributor(), handler.UpdateChunk)
|
||
// 删除单个生成的问题(通过问题ID) — Contributor+
|
||
chunks.DELETE("/by-id/:id/questions", g.Contributor(), handler.DeleteGeneratedQuestion)
|
||
}
|
||
}
|
||
|
||
// RegisterKnowledgeRoutes 注册知识相关的路由
|
||
//
|
||
// PR 2 attaches role-only guards here (Viewer for reads, Contributor for
|
||
// writes). Per-KB-ownership granularity for knowledge entries (so that
|
||
// Contributor X cannot edit Contributor Y's documents within the same
|
||
// KB) is a follow-up — it requires a knowledge-id -> KB chain lookup
|
||
// that's noisy enough to be worth its own PR.
|
||
func RegisterKnowledgeRoutes(r *gin.RouterGroup, handler *handler.KnowledgeHandler, g *rbacGuards) {
|
||
// 知识库下的知识路由组
|
||
kb := r.Group("/knowledge-bases/:id/knowledge")
|
||
{
|
||
kb.POST("/file", g.Contributor(), handler.CreateKnowledgeFromFile)
|
||
kb.POST("/url", g.Contributor(), handler.CreateKnowledgeFromURL)
|
||
kb.POST("/manual", g.Contributor(), handler.CreateManualKnowledge)
|
||
kb.GET("", g.Viewer(), handler.ListKnowledge)
|
||
// Clearing all contents under a KB is a destructive op; gate
|
||
// behind Admin instead of Contributor.
|
||
kb.DELETE("", g.Admin(), handler.ClearKnowledgeBaseContents)
|
||
}
|
||
|
||
// 知识路由组
|
||
k := r.Group("/knowledge")
|
||
{
|
||
k.GET("/batch", g.Viewer(), handler.GetKnowledgeBatch)
|
||
k.GET("/:id", g.Viewer(), handler.GetKnowledge)
|
||
k.DELETE("/:id", g.Contributor(), handler.DeleteKnowledge)
|
||
k.PUT("/:id", g.Contributor(), handler.UpdateKnowledge)
|
||
k.PUT("/manual/:id", g.Contributor(), handler.UpdateManualKnowledge)
|
||
k.POST("/:id/reparse", g.Contributor(), handler.ReparseKnowledge)
|
||
k.GET("/:id/download", g.Viewer(), handler.DownloadKnowledgeFile)
|
||
k.GET("/:id/preview", g.Viewer(), handler.PreviewKnowledgeFile)
|
||
k.PUT("/image/:id/:chunk_id", g.Contributor(), handler.UpdateImageInfo)
|
||
k.PUT("/tags", g.Contributor(), handler.UpdateKnowledgeTagBatch)
|
||
k.GET("/search", g.Viewer(), handler.SearchKnowledge)
|
||
k.POST("/batch-delete", g.Contributor(), handler.BatchDeleteKnowledge)
|
||
k.POST("/move", g.Contributor(), handler.MoveKnowledge)
|
||
k.GET("/move/progress/:task_id", g.Viewer(), handler.GetKnowledgeMoveProgress)
|
||
}
|
||
}
|
||
|
||
// RegisterFAQRoutes 注册 FAQ 相关路由
|
||
//
|
||
// FAQ entries are KB content: reads are Viewer+, all mutations
|
||
// (create / update / upsert / delete / batch field+tag updates,
|
||
// import display flag) are Contributor+. Search is read-only.
|
||
func RegisterFAQRoutes(r *gin.RouterGroup, handler *handler.FAQHandler, g *rbacGuards) {
|
||
if handler == nil {
|
||
return
|
||
}
|
||
faq := r.Group("/knowledge-bases/:id/faq")
|
||
{
|
||
faq.GET("/entries", g.Viewer(), handler.ListEntries)
|
||
faq.GET("/entries/export", g.Viewer(), handler.ExportEntries)
|
||
faq.GET("/entries/:entry_id", g.Viewer(), handler.GetEntry)
|
||
faq.POST("/entries", g.Contributor(), handler.UpsertEntries)
|
||
faq.POST("/entry", g.Contributor(), handler.CreateEntry)
|
||
faq.PUT("/entries/:entry_id", g.Contributor(), handler.UpdateEntry)
|
||
faq.POST("/entries/:entry_id/similar-questions", g.Contributor(), handler.AddSimilarQuestions)
|
||
// Unified batch update API - supports is_enabled, is_recommended, tag_id
|
||
faq.PUT("/entries/fields", g.Contributor(), handler.UpdateEntryFieldsBatch)
|
||
faq.PUT("/entries/tags", g.Contributor(), handler.UpdateEntryTagBatch)
|
||
faq.DELETE("/entries", g.Contributor(), handler.DeleteEntries)
|
||
faq.POST("/search", g.Viewer(), handler.SearchFAQ)
|
||
// FAQ import result display status
|
||
faq.PUT("/import/last-result/display", g.Contributor(), handler.UpdateLastImportResultDisplayStatus)
|
||
}
|
||
// FAQ import progress route (outside of knowledge-base scope) — Viewer+
|
||
faqImport := r.Group("/faq/import")
|
||
{
|
||
faqImport.GET("/progress/:task_id", g.Viewer(), handler.GetImportProgress)
|
||
}
|
||
}
|
||
|
||
// RegisterKnowledgeBaseRoutes 注册知识库相关的路由
|
||
func RegisterKnowledgeBaseRoutes(r *gin.RouterGroup, handler *handler.KnowledgeBaseHandler, g *rbacGuards) {
|
||
// 知识库路由组
|
||
kb := r.Group("/knowledge-bases")
|
||
{
|
||
// 创建知识库 — Contributor+
|
||
kb.POST("", g.Contributor(), handler.CreateKnowledgeBase)
|
||
// 获取知识库列表 — Viewer+
|
||
kb.GET("", g.Viewer(), handler.ListKnowledgeBases)
|
||
// 获取知识库详情 — Viewer+
|
||
kb.GET("/:id", g.Viewer(), handler.GetKnowledgeBase)
|
||
// 更新知识库 — 创建者本人 OR Admin+
|
||
kb.PUT("/:id", g.OwnedKBOrAdmin(), handler.UpdateKnowledgeBase)
|
||
// 删除知识库 — 创建者本人 OR Admin+
|
||
kb.DELETE("/:id", g.OwnedKBOrAdmin(), handler.DeleteKnowledgeBase)
|
||
// 置顶/取消置顶知识库 — 创建者本人 OR Admin+
|
||
kb.PUT("/:id/pin", g.OwnedKBOrAdmin(), handler.TogglePinKnowledgeBase)
|
||
// 混合搜索 — Viewer+ (read-only)
|
||
kb.GET("/:id/hybrid-search", g.Viewer(), handler.HybridSearch)
|
||
// 拷贝知识库 — Contributor+ (副本归调用者所有;不需要原 KB 的所有权)
|
||
kb.POST("/copy", g.Contributor(), handler.CopyKnowledgeBase)
|
||
// 获取知识库复制进度 — Viewer+
|
||
kb.GET("/copy/progress/:task_id", g.Viewer(), handler.GetKBCloneProgress)
|
||
// 获取可移动目标知识库列表 — Viewer+
|
||
kb.GET("/:id/move-targets", g.Viewer(), handler.ListMoveTargets)
|
||
}
|
||
}
|
||
|
||
// RegisterKnowledgeTagRoutes 注册知识库标签相关路由。
|
||
//
|
||
// Tags are KB metadata: Viewer reads, Contributor writes. Per-KB
|
||
// ownership granularity for tags is out of scope for PR 2; this is
|
||
// purely role-based.
|
||
func RegisterKnowledgeTagRoutes(r *gin.RouterGroup, tagHandler *handler.TagHandler, g *rbacGuards) {
|
||
if tagHandler == nil {
|
||
return
|
||
}
|
||
kbTags := r.Group("/knowledge-bases/:id/tags")
|
||
{
|
||
kbTags.GET("", g.Viewer(), tagHandler.ListTags)
|
||
kbTags.POST("", g.Contributor(), tagHandler.CreateTag)
|
||
kbTags.PUT("/:tag_id", g.Contributor(), tagHandler.UpdateTag)
|
||
kbTags.DELETE("/:tag_id", g.Contributor(), tagHandler.DeleteTag)
|
||
}
|
||
}
|
||
|
||
// RegisterMessageRoutes 注册消息相关的路由。
|
||
//
|
||
// Per-session ownership is already enforced inside each handler (the
|
||
// user must own the session). We add Viewer+ here so non-members
|
||
// (e.g. revoked accounts retained in the tenant for audit) cannot
|
||
// reach the endpoints at all once RBAC is on.
|
||
func RegisterMessageRoutes(r *gin.RouterGroup, handler *handler.MessageHandler, g *rbacGuards) {
|
||
messages := r.Group("/messages")
|
||
{
|
||
messages.POST("/search", g.Viewer(), handler.SearchMessages)
|
||
messages.GET("/chat-history-stats", g.Viewer(), handler.GetChatHistoryKBStats)
|
||
messages.GET("/:session_id/load", g.Viewer(), handler.LoadMessages)
|
||
messages.DELETE("/:session_id/:id", g.Viewer(), handler.DeleteMessage)
|
||
}
|
||
}
|
||
|
||
// RegisterSessionRoutes 注册路由。
|
||
//
|
||
// Sessions are per-user resources; the handler enforces user ownership.
|
||
// We gate at Viewer+ to keep non-members out once RBAC is on, matching
|
||
// the message routes above. A future refactor can introduce
|
||
// per-session ownership in the middleware layer the same way KB/agent
|
||
// routes do today.
|
||
func RegisterSessionRoutes(r *gin.RouterGroup, handler *session.Handler, g *rbacGuards) {
|
||
sessions := r.Group("/sessions", g.Viewer())
|
||
{
|
||
sessions.POST("", handler.CreateSession)
|
||
sessions.DELETE("/batch", handler.BatchDeleteSessions)
|
||
sessions.GET("/:id", handler.GetSession)
|
||
sessions.GET("", handler.GetSessionsByTenant)
|
||
sessions.PUT("/:id", handler.UpdateSession)
|
||
sessions.DELETE("/:id", handler.DeleteSession)
|
||
sessions.DELETE("/:id/messages", handler.ClearSessionMessages)
|
||
sessions.POST("/:session_id/generate_title", handler.GenerateTitle)
|
||
sessions.POST("/:session_id/stop", handler.StopSession)
|
||
// POST and DELETE share this path but gin maintains a separate radix tree
|
||
// per HTTP verb, and the existing trees use different wildcard names
|
||
// (POST uses :session_id, DELETE uses :id). Use whatever matches each
|
||
// tree to avoid "wildcard conflicts" panic at route registration.
|
||
sessions.POST("/:session_id/pin", handler.PinSession)
|
||
sessions.DELETE("/:id/pin", handler.UnpinSession)
|
||
// 继续接收活跃流
|
||
sessions.GET("/continue-stream/:session_id", handler.ContinueStream)
|
||
}
|
||
}
|
||
|
||
// RegisterChatRoutes 注册路由。Chat endpoints are tenant-member usage
|
||
// surfaces; Viewer+ is sufficient because per-session/per-agent
|
||
// authorisation is enforced inside the handlers.
|
||
func RegisterChatRoutes(r *gin.RouterGroup, handler *session.Handler, g *rbacGuards) {
|
||
knowledgeChat := r.Group("/knowledge-chat", g.Viewer())
|
||
{
|
||
knowledgeChat.POST("/:session_id", handler.KnowledgeQA)
|
||
}
|
||
|
||
// Agent-based chat
|
||
agentChat := r.Group("/agent-chat", g.Viewer())
|
||
{
|
||
agentChat.POST("/:session_id", handler.AgentQA)
|
||
}
|
||
|
||
// 新增知识检索接口,不需要session_id
|
||
knowledgeSearch := r.Group("/knowledge-search", g.Viewer())
|
||
{
|
||
knowledgeSearch.POST("", handler.SearchKnowledge)
|
||
}
|
||
}
|
||
|
||
// RegisterTenantRoutes 注册租户相关的路由
|
||
//
|
||
// Tenant-internal RBAC for /tenants/:id:
|
||
// - GET /:id Viewer+ (read tenant settings)
|
||
// - PUT /:id Owner+ (mutate tenant config)
|
||
// - DELETE /:id Owner+ (also normally a CanAccessAllTenants op)
|
||
// - POST /:id/api-key Owner+ (rotating the tenant API key is sensitive)
|
||
// - GET /:id/members Viewer+ (any member can see who else is in)
|
||
// - POST /:id/members Owner+ (only Owner can add new members)
|
||
// - PUT /:id/members/:user_id Owner+ (only Owner can change roles)
|
||
// - DELETE /:id/members/:user_id Owner+ (only Owner can remove members)
|
||
// - POST /:id/leave Viewer+ (any member can quit on their own)
|
||
//
|
||
// Cross-tenant superuser endpoints (/tenants/all, /tenants/search, POST
|
||
// /tenants, GET /tenants, /tenants/kv/*) keep their existing handler-level
|
||
// CanAccessAllTenants check — they're not gated by tenant role here
|
||
// because the caller is operating *across* tenants, not within one.
|
||
func RegisterTenantRoutes(
|
||
r *gin.RouterGroup,
|
||
handler *handler.TenantHandler,
|
||
memberHandler *handler.TenantMemberHandler,
|
||
g *rbacGuards,
|
||
) {
|
||
// 添加获取所有租户的路由(需要跨租户权限)
|
||
r.GET("/tenants/all", handler.ListAllTenants)
|
||
// 添加搜索租户的路由(需要跨租户权限,支持分页和搜索)
|
||
r.GET("/tenants/search", handler.SearchTenants)
|
||
// 租户路由组
|
||
tenantRoutes := r.Group("/tenants")
|
||
{
|
||
tenantRoutes.POST("", handler.CreateTenant) // CanAccessAllTenants gate is in the handler
|
||
tenantRoutes.GET("/:id", g.Viewer(), handler.GetTenant)
|
||
tenantRoutes.PUT("/:id", g.Owner(), handler.UpdateTenant)
|
||
tenantRoutes.DELETE("/:id", g.Owner(), handler.DeleteTenant)
|
||
tenantRoutes.POST("/:id/api-key", g.Owner(), handler.ResetAPIKey)
|
||
tenantRoutes.GET("", handler.ListTenants) // existing handler gates by CanAccessAllTenants
|
||
|
||
// Generic KV configuration management (tenant-level)
|
||
// Tenant ID is obtained from authentication context
|
||
tenantRoutes.GET("/kv/:key", g.Viewer(), handler.GetTenantKV)
|
||
tenantRoutes.PUT("/kv/:key", g.Admin(), handler.UpdateTenantKV)
|
||
|
||
// Tenant member management (PR 3 of #1303). Listing is Viewer+
|
||
// so any active member can see the roster; mutation is Owner+
|
||
// because membership changes are the highest-impact tenant op.
|
||
// /:id/leave is Viewer+ — any member can quit on their own; the
|
||
// service still rejects when it would leave the tenant without
|
||
// an Owner.
|
||
if memberHandler != nil {
|
||
tenantRoutes.GET("/:id/members", g.Viewer(), memberHandler.ListMembers)
|
||
tenantRoutes.POST("/:id/members", g.Owner(), memberHandler.AddMember)
|
||
tenantRoutes.PUT("/:id/members/:user_id", g.Owner(), memberHandler.UpdateMemberRole)
|
||
tenantRoutes.DELETE("/:id/members/:user_id", g.Owner(), memberHandler.RemoveMember)
|
||
tenantRoutes.POST("/:id/leave", g.Viewer(), memberHandler.LeaveTenant)
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// Models are tenant-wide infrastructure (LLM credentials, embeddings,
|
||
// rerankers); Viewer+ for reads, Admin+ for any mutation. Credential
|
||
// subresource writes are also Admin+ since secrets are tenant-scoped.
|
||
func RegisterModelRoutes(
|
||
r *gin.RouterGroup,
|
||
handler *handler.ModelHandler,
|
||
credHandler *handler.ModelCredentialsHandler,
|
||
g *rbacGuards,
|
||
) {
|
||
// 模型路由组
|
||
models := r.Group("/models")
|
||
{
|
||
// 获取模型厂商列表 — Viewer+
|
||
models.GET("/providers", g.Viewer(), handler.ListModelProviders)
|
||
// 创建模型 — Admin+
|
||
models.POST("", g.Admin(), handler.CreateModel)
|
||
// 获取模型列表 — Viewer+
|
||
models.GET("", g.Viewer(), handler.ListModels)
|
||
// 获取单个模型 — Viewer+
|
||
models.GET("/:id", g.Viewer(), handler.GetModel)
|
||
// 更新模型 — Admin+
|
||
models.PUT("/:id", g.Admin(), handler.UpdateModel)
|
||
// 删除模型 — Admin+
|
||
models.DELETE("/:id", g.Admin(), handler.DeleteModel)
|
||
// Per-field credential subresource (see internal/handler/model_credentials.go) — Admin+
|
||
models.PUT("/:id/credentials", g.Admin(), credHandler.Put)
|
||
models.DELETE("/:id/credentials/:field", g.Admin(), credHandler.DeleteField)
|
||
}
|
||
}
|
||
|
||
func RegisterEvaluationRoutes(r *gin.RouterGroup, handler *handler.EvaluationHandler) {
|
||
evaluationRoutes := r.Group("/evaluation")
|
||
{
|
||
evaluationRoutes.POST("/", handler.Evaluation)
|
||
evaluationRoutes.GET("/", handler.GetEvaluationResult)
|
||
}
|
||
}
|
||
|
||
// RegisterAuthRoutes registers authentication routes
|
||
func RegisterAuthRoutes(r *gin.RouterGroup, handler *handler.AuthHandler) {
|
||
r.POST("/auth/register", handler.Register)
|
||
r.POST("/auth/login", handler.Login)
|
||
r.POST("/auth/auto-setup", handler.AutoSetup)
|
||
r.GET("/auth/config", handler.GetAuthConfig)
|
||
r.POST("/auth/switch-tenant", handler.SwitchTenant)
|
||
r.GET("/auth/oidc/config", handler.GetOIDCConfig)
|
||
r.GET("/auth/oidc/url", handler.GetOIDCAuthorizationURL)
|
||
r.GET("/auth/oidc/callback", handler.OIDCRedirectCallback)
|
||
r.POST("/auth/refresh", handler.RefreshToken)
|
||
r.GET("/auth/validate", handler.ValidateToken)
|
||
r.POST("/auth/logout", handler.Logout)
|
||
r.GET("/auth/me", handler.GetCurrentUser)
|
||
r.POST("/auth/change-password", handler.ChangePassword)
|
||
}
|
||
|
||
func RegisterInitializationRoutes(r *gin.RouterGroup, handler *handler.InitializationHandler) {
|
||
// 初始化接口
|
||
r.GET("/initialization/config/:kbId", handler.GetCurrentConfigByKB)
|
||
r.POST("/initialization/initialize/:kbId", handler.InitializeByKB)
|
||
r.PUT("/initialization/config/:kbId", handler.UpdateKBConfig) // 新的简化版接口,只传模型ID
|
||
|
||
// Ollama相关接口
|
||
r.GET("/initialization/ollama/status", handler.CheckOllamaStatus)
|
||
r.GET("/initialization/ollama/models", handler.ListOllamaModels)
|
||
r.POST("/initialization/ollama/models/check", handler.CheckOllamaModels)
|
||
r.POST("/initialization/ollama/models/download", handler.DownloadOllamaModel)
|
||
r.GET("/initialization/ollama/download/progress/:taskId", handler.GetDownloadProgress)
|
||
r.GET("/initialization/ollama/download/tasks", handler.ListDownloadTasks)
|
||
|
||
// 远程API相关接口
|
||
r.POST("/initialization/remote/check", handler.CheckRemoteModel)
|
||
r.POST("/initialization/embedding/test", handler.TestEmbeddingModel)
|
||
r.POST("/initialization/rerank/check", handler.CheckRerankModel)
|
||
r.POST("/initialization/asr/check", handler.CheckASRModel)
|
||
r.POST("/initialization/multimodal/test", handler.TestMultimodalFunction)
|
||
|
||
r.POST("/initialization/extract/text-relation", handler.ExtractTextRelations)
|
||
r.POST("/initialization/extract/fabri-tag", handler.FabriTag)
|
||
r.POST("/initialization/extract/fabri-text", handler.FabriText)
|
||
}
|
||
|
||
// RegisterSystemRoutes registers system information routes
|
||
func RegisterSystemRoutes(r *gin.RouterGroup, handler *handler.SystemHandler) {
|
||
systemRoutes := r.Group("/system")
|
||
{
|
||
systemRoutes.GET("/info", handler.GetSystemInfo)
|
||
systemRoutes.GET("/parser-engines", handler.ListParserEngines)
|
||
systemRoutes.POST("/parser-engines/check", handler.CheckParserEngines)
|
||
systemRoutes.POST("/docreader/reconnect", handler.ReconnectDocReader)
|
||
systemRoutes.GET("/storage-engine-status", handler.GetStorageEngineStatus)
|
||
systemRoutes.POST("/storage-engine-check", handler.CheckStorageEngine)
|
||
}
|
||
}
|
||
|
||
// RegisterMCPServiceRoutes registers MCP service routes.
|
||
//
|
||
// MCP services are tenant-level integrations (external tool servers); we
|
||
// gate reads to Viewer+ and any mutation/test to Admin+. Tool-approval
|
||
// resolution is also Admin+ since approving a pending tool call grants
|
||
// the agent permission to execute side-effecting external commands.
|
||
// Credential subresource writes are Admin+ as well since secrets are
|
||
// tenant-scoped.
|
||
func RegisterMCPServiceRoutes(
|
||
r *gin.RouterGroup,
|
||
handler *handler.MCPServiceHandler,
|
||
credHandler *handler.MCPCredentialsHandler,
|
||
g *rbacGuards,
|
||
) {
|
||
mcpServices := r.Group("/mcp-services")
|
||
{
|
||
// Create MCP service — Admin+
|
||
mcpServices.POST("", g.Admin(), handler.CreateMCPService)
|
||
// List MCP services — Viewer+
|
||
mcpServices.GET("", g.Viewer(), handler.ListMCPServices)
|
||
// Get MCP service by ID — Viewer+
|
||
mcpServices.GET("/:id", g.Viewer(), handler.GetMCPService)
|
||
// Update MCP service — Admin+
|
||
mcpServices.PUT("/:id", g.Admin(), handler.UpdateMCPService)
|
||
// Delete MCP service — Admin+
|
||
mcpServices.DELETE("/:id", g.Admin(), handler.DeleteMCPService)
|
||
// Test MCP service connection — Admin+ (probes external infra)
|
||
mcpServices.POST("/:id/test", g.Admin(), handler.TestMCPService)
|
||
// Get MCP service tools — Viewer+
|
||
mcpServices.GET("/:id/tools", g.Viewer(), handler.GetMCPServiceTools)
|
||
// Get MCP service resources — Viewer+
|
||
mcpServices.GET("/:id/resources", g.Viewer(), handler.GetMCPServiceResources)
|
||
// Per-field credential subresource: secrets never travel via the main
|
||
// PUT body. See internal/handler/mcp_credentials.go for the contract. — Admin+
|
||
mcpServices.PUT("/:id/credentials", g.Admin(), credHandler.Put)
|
||
mcpServices.DELETE("/:id/credentials/:field", g.Admin(), credHandler.DeleteField)
|
||
// MCP tool human approval (issue #1173) — Viewer+ to read, Admin+ to set policy
|
||
mcpServices.GET("/:id/tool-approvals", g.Viewer(), handler.ListMCPToolApprovals)
|
||
mcpServices.PUT("/:id/tool-approvals/:tool_name", g.Admin(), handler.SetMCPToolApproval)
|
||
}
|
||
|
||
agentTool := r.Group("/agent")
|
||
{
|
||
// Resolving a pending tool-approval lets the agent run a sensitive
|
||
// external command on this tenant's behalf — Admin+.
|
||
agentTool.POST("/tool-approvals/:pending_id", g.Admin(), handler.ResolveToolApproval)
|
||
}
|
||
}
|
||
|
||
// RegisterWebSearchRoutes registers web search routes
|
||
func RegisterWebSearchRoutes(r *gin.RouterGroup, webSearchHandler *handler.WebSearchHandler, g *rbacGuards) {
|
||
// Web search providers — Viewer+ (read-only listing of provider catalog).
|
||
webSearch := r.Group("/web-search")
|
||
{
|
||
webSearch.GET("/providers", g.Viewer(), webSearchHandler.GetProviders)
|
||
}
|
||
}
|
||
|
||
// RegisterWebSearchProviderRoutes registers CRUD routes for web search
|
||
// provider configurations.
|
||
//
|
||
// Provider rows hold external service credentials (Bing, Tavily, Google,
|
||
// etc.); reads are Viewer+, all mutations / connection tests (which
|
||
// probe external systems with stored credentials) and the per-field
|
||
// credential subresource are Admin+.
|
||
func RegisterWebSearchProviderRoutes(
|
||
r *gin.RouterGroup,
|
||
h *handler.WebSearchProviderHandler,
|
||
credHandler *handler.WebSearchProviderCredentialsHandler,
|
||
g *rbacGuards,
|
||
) {
|
||
providers := r.Group("/web-search-providers")
|
||
{
|
||
// List available provider types (metadata for UI forms) — Viewer+
|
||
providers.GET("/types", g.Viewer(), h.ListProviderTypes)
|
||
// Test with raw credentials (no persistence) — Admin+
|
||
providers.POST("/test", g.Admin(), h.TestProviderRaw)
|
||
// CRUD
|
||
providers.POST("", g.Admin(), h.CreateProvider)
|
||
providers.GET("", g.Viewer(), h.ListProviders)
|
||
providers.GET("/:id", g.Viewer(), h.GetProvider)
|
||
providers.PUT("/:id", g.Admin(), h.UpdateProvider)
|
||
providers.DELETE("/:id", g.Admin(), h.DeleteProvider)
|
||
// Per-field credential subresource — Admin+
|
||
providers.PUT("/:id/credentials", g.Admin(), credHandler.Put)
|
||
providers.DELETE("/:id/credentials/:field", g.Admin(), credHandler.DeleteField)
|
||
// Test existing saved provider — Admin+
|
||
providers.POST("/:id/test", g.Admin(), h.TestProviderByID)
|
||
}
|
||
}
|
||
|
||
// RegisterVectorStoreRoutes registers CRUD routes for vector store configurations.
|
||
//
|
||
// Vector stores are tenant-level infrastructure; reads are Viewer+, all
|
||
// writes (and connection tests, which probe external systems with stored
|
||
// credentials) are Admin+.
|
||
func RegisterVectorStoreRoutes(r *gin.RouterGroup, h *handler.VectorStoreHandler, g *rbacGuards) {
|
||
stores := r.Group("/vector-stores")
|
||
{
|
||
// List available engine types (metadata for UI forms) — Viewer+
|
||
stores.GET("/types", g.Viewer(), h.ListStoreTypes)
|
||
// Test with raw credentials (no persistence) — Admin+
|
||
stores.POST("/test", g.Admin(), h.TestStoreRaw)
|
||
// CRUD
|
||
stores.POST("", g.Admin(), h.CreateStore)
|
||
stores.GET("", g.Viewer(), h.ListStores)
|
||
stores.GET("/:id", g.Viewer(), h.GetStore)
|
||
stores.PUT("/:id", g.Admin(), h.UpdateStore)
|
||
stores.DELETE("/:id", g.Admin(), h.DeleteStore)
|
||
// Test existing saved or env store — Admin+
|
||
stores.POST("/:id/test", g.Admin(), h.TestStoreByID)
|
||
}
|
||
}
|
||
|
||
// RegisterCustomAgentRoutes registers custom agent routes.
|
||
//
|
||
// Mutating routes use OwnedAgentOrAdmin: the original creator can edit
|
||
// their agent, otherwise Admin+ is required. Built-in agents
|
||
// (IsBuiltin=true) have an empty creator and are always Admin+. Reads
|
||
// are Viewer+, copy is Contributor+ (the copy is owned by the caller).
|
||
func RegisterCustomAgentRoutes(r *gin.RouterGroup, agentHandler *handler.CustomAgentHandler, g *rbacGuards) {
|
||
agents := r.Group("/agents")
|
||
{
|
||
// Get placeholder definitions (must be before /:id to avoid conflict) — Viewer+
|
||
agents.GET("/placeholders", g.Viewer(), agentHandler.GetPlaceholders)
|
||
// List smart-reasoning agent type presets (rag-qa / wiki-qa / hybrid / custom) — Viewer+
|
||
agents.GET("/type-presets", g.Viewer(), agentHandler.GetAgentTypePresets)
|
||
// Create custom agent — Contributor+
|
||
agents.POST("", g.Contributor(), agentHandler.CreateAgent)
|
||
// List all agents (including built-in) — Viewer+
|
||
agents.GET("", g.Viewer(), agentHandler.ListAgents)
|
||
// Get agent by ID — Viewer+
|
||
agents.GET("/:id", g.Viewer(), agentHandler.GetAgent)
|
||
// Update agent — creator OR Admin+
|
||
agents.PUT("/:id", g.OwnedAgentOrAdmin(), agentHandler.UpdateAgent)
|
||
// Delete agent — creator OR Admin+
|
||
agents.DELETE("/:id", g.OwnedAgentOrAdmin(), agentHandler.DeleteAgent)
|
||
// Copy agent — Contributor+ (copy is owned by the caller)
|
||
agents.POST("/:id/copy", g.Contributor(), agentHandler.CopyAgent)
|
||
}
|
||
// Registered outside the group to avoid Gin route conflict with /agents/:id/shares in organization routes
|
||
r.GET("/agents/:id/suggested-questions", g.Viewer(), agentHandler.GetSuggestedQuestions)
|
||
}
|
||
|
||
// RegisterSkillRoutes registers skill routes.
|
||
//
|
||
// PR 2 currently only exposes a read-only `ListSkills`; gated to
|
||
// Viewer+. Future skill upload / enable endpoints must use Admin+ since
|
||
// skills run sandboxed code on tenant resources.
|
||
func RegisterSkillRoutes(r *gin.RouterGroup, skillHandler *handler.SkillHandler, g *rbacGuards) {
|
||
skills := r.Group("/skills")
|
||
{
|
||
// List all preloaded skills — Viewer+
|
||
skills.GET("", g.Viewer(), skillHandler.ListSkills)
|
||
}
|
||
}
|
||
|
||
// RegisterOrganizationRoutes registers organization and sharing routes
|
||
func RegisterOrganizationRoutes(r *gin.RouterGroup, orgHandler *handler.OrganizationHandler) {
|
||
// Organization routes
|
||
orgs := r.Group("/organizations")
|
||
{
|
||
// Create organization
|
||
orgs.POST("", orgHandler.CreateOrganization)
|
||
// List my organizations
|
||
orgs.GET("", orgHandler.ListMyOrganizations)
|
||
// Preview organization by invite code (without joining)
|
||
orgs.GET("/preview/:code", orgHandler.PreviewByInviteCode)
|
||
// Join organization by invite code
|
||
orgs.POST("/join", orgHandler.JoinByInviteCode)
|
||
// Submit join request (for organizations that require approval)
|
||
orgs.POST("/join-request", orgHandler.SubmitJoinRequest)
|
||
// Search searchable (discoverable) organizations
|
||
orgs.GET("/search", orgHandler.SearchOrganizations)
|
||
// Join searchable organization by ID (no invite code)
|
||
orgs.POST("/join-by-id", orgHandler.JoinByOrganizationID)
|
||
// Get organization by ID
|
||
orgs.GET("/:id", orgHandler.GetOrganization)
|
||
// Update organization
|
||
orgs.PUT("/:id", orgHandler.UpdateOrganization)
|
||
// Delete organization
|
||
orgs.DELETE("/:id", orgHandler.DeleteOrganization)
|
||
// Leave organization
|
||
orgs.POST("/:id/leave", orgHandler.LeaveOrganization)
|
||
// Request role upgrade (for existing members)
|
||
orgs.POST("/:id/request-upgrade", orgHandler.RequestRoleUpgrade)
|
||
// Generate invite code
|
||
orgs.POST("/:id/invite-code", orgHandler.GenerateInviteCode)
|
||
// Search users for invite (admin only)
|
||
orgs.GET("/:id/search-users", orgHandler.SearchUsersForInvite)
|
||
// Invite member directly (admin only)
|
||
orgs.POST("/:id/invite", orgHandler.InviteMember)
|
||
// List members
|
||
orgs.GET("/:id/members", orgHandler.ListMembers)
|
||
// Update member role
|
||
orgs.PUT("/:id/members/:user_id", orgHandler.UpdateMemberRole)
|
||
// Remove member
|
||
orgs.DELETE("/:id/members/:user_id", orgHandler.RemoveMember)
|
||
// List join requests (admin only)
|
||
orgs.GET("/:id/join-requests", orgHandler.ListJoinRequests)
|
||
// Review join request (admin only)
|
||
orgs.PUT("/:id/join-requests/:request_id/review", orgHandler.ReviewJoinRequest)
|
||
// List knowledge bases shared to this organization
|
||
orgs.GET("/:id/shares", orgHandler.ListOrgShares)
|
||
// List agents shared to this organization
|
||
orgs.GET("/:id/agent-shares", orgHandler.ListOrgAgentShares)
|
||
// List all knowledge bases in this organization (including mine) for list-page space view
|
||
orgs.GET("/:id/shared-knowledge-bases", orgHandler.ListOrganizationSharedKnowledgeBases)
|
||
// List all agents in this organization (including mine) for list-page space view
|
||
orgs.GET("/:id/shared-agents", orgHandler.ListOrganizationSharedAgents)
|
||
}
|
||
|
||
// Knowledge base sharing routes (add to existing kb routes)
|
||
kbShares := r.Group("/knowledge-bases/:id/shares")
|
||
{
|
||
// Share knowledge base
|
||
kbShares.POST("", orgHandler.ShareKnowledgeBase)
|
||
// List shares
|
||
kbShares.GET("", orgHandler.ListKBShares)
|
||
// Update share permission
|
||
kbShares.PUT("/:share_id", orgHandler.UpdateSharePermission)
|
||
// Remove share
|
||
kbShares.DELETE("/:share_id", orgHandler.RemoveShare)
|
||
}
|
||
|
||
// Agent sharing routes
|
||
agentShares := r.Group("/agents/:id/shares")
|
||
{
|
||
agentShares.POST("", orgHandler.ShareAgent)
|
||
agentShares.GET("", orgHandler.ListAgentShares)
|
||
agentShares.DELETE("/:share_id", orgHandler.RemoveAgentShare)
|
||
}
|
||
|
||
// Shared knowledge bases route
|
||
r.GET("/shared-knowledge-bases", orgHandler.ListSharedKnowledgeBases)
|
||
// Shared agents route
|
||
r.GET("/shared-agents", orgHandler.ListSharedAgents)
|
||
r.POST("/shared-agents/disabled", orgHandler.SetSharedAgentDisabledByMe)
|
||
}
|
||
|
||
// RegisterIMRoutes registers IM callback routes.
|
||
// These are registered BEFORE auth middleware since IM platforms use their own signature verification.
|
||
func RegisterIMRoutes(r *gin.Engine, imHandler *handler.IMHandler) {
|
||
im := r.Group("/api/v1/im")
|
||
{
|
||
im.GET("/callback/:channel_id", imHandler.IMCallback)
|
||
im.POST("/callback/:channel_id", imHandler.IMCallback)
|
||
}
|
||
}
|
||
|
||
// RegisterIMChannelRoutes registers IM channel CRUD routes (requires authentication).
|
||
//
|
||
// IM channels carry external bot credentials (WeChat/Feishu/Slack/...);
|
||
// listing is Viewer+ but any mutation, toggle, or QR-code login flow
|
||
// (which can hijack a personal WeChat session) is Admin+.
|
||
func RegisterIMChannelRoutes(r *gin.RouterGroup, imHandler *handler.IMHandler, g *rbacGuards) {
|
||
// Channel CRUD under agents
|
||
agentChannels := r.Group("/agents/:id/im-channels")
|
||
{
|
||
agentChannels.POST("", g.Admin(), imHandler.CreateIMChannel)
|
||
agentChannels.GET("", g.Viewer(), imHandler.ListIMChannels)
|
||
}
|
||
|
||
// Channel operations by channel ID
|
||
channels := r.Group("/im-channels")
|
||
{
|
||
channels.GET("", g.Viewer(), imHandler.ListAllIMChannels)
|
||
channels.PUT("/:id", g.Admin(), imHandler.UpdateIMChannel)
|
||
channels.DELETE("/:id", g.Admin(), imHandler.DeleteIMChannel)
|
||
channels.POST("/:id/toggle", g.Admin(), imHandler.ToggleIMChannel)
|
||
}
|
||
|
||
// WeChat QR code login (requires authentication) — Admin+: a successful
|
||
// scan binds a personal WeChat account to the tenant.
|
||
wechatGroup := r.Group("/wechat")
|
||
{
|
||
wechatGroup.POST("/qrcode", g.Admin(), imHandler.WeChatGetQRCode)
|
||
wechatGroup.POST("/qrcode/status", g.Admin(), imHandler.WeChatPollQRCodeStatus)
|
||
}
|
||
}
|
||
|
||
// serveFrontendStatic registers a middleware that serves the frontend SPA
|
||
// from the ./web directory if it exists. Must be called BEFORE auth middleware
|
||
// so static files are served without authentication.
|
||
func serveFrontendStatic(r *gin.Engine) {
|
||
webDir := os.Getenv("WEKNORA_WEB_DIR")
|
||
if webDir == "" {
|
||
webDir = "./web"
|
||
}
|
||
absDir, _ := filepath.Abs(webDir)
|
||
indexPath := filepath.Join(absDir, "index.html")
|
||
if _, err := os.Stat(indexPath); err != nil {
|
||
return
|
||
}
|
||
|
||
logger.Infof(context.Background(), "[Router] Serving frontend static files from %s", absDir)
|
||
|
||
fs := http.Dir(absDir)
|
||
fileServer := http.FileServer(fs)
|
||
|
||
r.Use(func(c *gin.Context) {
|
||
if c.Request.Method != http.MethodGet && c.Request.Method != http.MethodHead {
|
||
c.Next()
|
||
return
|
||
}
|
||
path := c.Request.URL.Path
|
||
if strings.HasPrefix(path, "/api/") || strings.HasPrefix(path, "/health") || strings.HasPrefix(path, "/swagger/") {
|
||
c.Next()
|
||
return
|
||
}
|
||
fullPath := filepath.Join(absDir, path)
|
||
if info, err := os.Stat(fullPath); err == nil && !info.IsDir() {
|
||
setFrontendCacheHeaders(c.Writer, path)
|
||
fileServer.ServeHTTP(c.Writer, c.Request)
|
||
c.Abort()
|
||
return
|
||
}
|
||
setFrontendCacheHeaders(c.Writer, "/index.html")
|
||
c.File(indexPath)
|
||
c.Abort()
|
||
})
|
||
}
|
||
|
||
// setFrontendCacheHeaders sets Cache-Control headers for frontend static resources.
|
||
// Vite 构建产物中 /assets/* 的文件名带 hash,可长期缓存;其余(index.html、config.js、favicon 等)
|
||
// 每次都需 revalidate,避免前端升级后用户看到旧版本。
|
||
func setFrontendCacheHeaders(w http.ResponseWriter, path string) {
|
||
if strings.HasPrefix(path, "/assets/") {
|
||
w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
|
||
return
|
||
}
|
||
w.Header().Set("Cache-Control", "no-cache, must-revalidate")
|
||
}
|
||
|
||
// serveFiles serves files via query parameters and tenant storage settings.
|
||
// It is registered after auth middleware, so tenant context comes from authentication.
|
||
//
|
||
// Route:
|
||
// - /files?file_path=<provider://...>
|
||
type getRouteRegistrar interface {
|
||
GET(string, ...gin.HandlerFunc) gin.IRoutes
|
||
}
|
||
|
||
func serveFiles(r getRouteRegistrar, globalFileService interfaces.FileService) {
|
||
baseDir := os.Getenv("LOCAL_STORAGE_BASE_DIR")
|
||
if baseDir == "" {
|
||
baseDir = "/data/files"
|
||
}
|
||
absDir, _ := filepath.Abs(baseDir)
|
||
if info, err := os.Stat(absDir); err != nil || !info.IsDir() {
|
||
if err := os.MkdirAll(absDir, 0o755); err != nil {
|
||
logger.Warnf(context.Background(), "[Router] Cannot create local storage dir %s: %v", absDir, err)
|
||
}
|
||
}
|
||
|
||
logger.Infof(context.Background(), "[Router] Serving files from /files (local base: %s)", absDir)
|
||
|
||
r.GET("/files", func(c *gin.Context) {
|
||
filePath := strings.TrimSpace(c.Query("file_path"))
|
||
if filePath == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"error": "missing required parameter: file_path"})
|
||
return
|
||
}
|
||
if strings.Contains(filePath, "..") {
|
||
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file path"})
|
||
return
|
||
}
|
||
|
||
provider := types.ParseProviderScheme(filePath)
|
||
|
||
tenant, _ := c.Request.Context().Value(types.TenantInfoContextKey).(*types.Tenant)
|
||
if tenant == nil {
|
||
c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized: tenant context missing"})
|
||
return
|
||
}
|
||
|
||
var (
|
||
fileSvc interfaces.FileService
|
||
resolvedProvider string
|
||
err error
|
||
)
|
||
|
||
if tenant.StorageEngineConfig != nil {
|
||
fileSvc, resolvedProvider, err = filesvc.NewFileServiceFromStorageConfig(provider, tenant.StorageEngineConfig, absDir)
|
||
} else {
|
||
err = http.ErrMissingFile
|
||
}
|
||
if err != nil {
|
||
globalStorageType := strings.ToLower(strings.TrimSpace(os.Getenv("STORAGE_TYPE")))
|
||
if globalStorageType == "" {
|
||
globalStorageType = "local"
|
||
}
|
||
if provider == globalStorageType && globalFileService != nil {
|
||
logger.Warnf(context.Background(), "[Router] /files tenant storage config missing or invalid, fallback to global file service: tenant_id=%d provider=%s err=%v", tenant.ID, provider, err)
|
||
fileSvc = globalFileService
|
||
resolvedProvider = globalStorageType
|
||
} else {
|
||
logger.Warnf(context.Background(), "[Router] /files resolve file service failed without fallback: tenant_id=%d provider=%s global_storage_type=%s err=%v", tenant.ID, provider, globalStorageType, err)
|
||
c.Status(http.StatusBadRequest)
|
||
return
|
||
}
|
||
}
|
||
|
||
reader, err := fileSvc.GetFile(c.Request.Context(), filePath)
|
||
if err != nil {
|
||
logger.Warnf(context.Background(), "[Router] /files get file failed: tenant_id=%d provider=%s path=%q err=%v", tenant.ID, resolvedProvider, filePath, err)
|
||
c.Status(http.StatusNotFound)
|
||
return
|
||
}
|
||
defer reader.Close()
|
||
|
||
ext := filepath.Ext(filePath)
|
||
contentType := "application/octet-stream"
|
||
switch strings.ToLower(ext) {
|
||
case ".png":
|
||
contentType = "image/png"
|
||
case ".jpg", ".jpeg":
|
||
contentType = "image/jpeg"
|
||
case ".gif":
|
||
contentType = "image/gif"
|
||
case ".webp":
|
||
contentType = "image/webp"
|
||
case ".bmp":
|
||
contentType = "image/bmp"
|
||
case ".svg":
|
||
contentType = "image/svg+xml"
|
||
case ".pdf":
|
||
contentType = "application/pdf"
|
||
case ".csv":
|
||
contentType = "text/csv; charset=utf-8"
|
||
}
|
||
|
||
c.Header("Content-Type", contentType)
|
||
c.Header("Cache-Control", "public, max-age=86400")
|
||
c.Status(http.StatusOK)
|
||
if _, err := io.Copy(c.Writer, reader); err != nil {
|
||
logger.Warnf(context.Background(), "[Router] /files write response failed: %v", err)
|
||
}
|
||
})
|
||
}
|
||
|
||
// servePresignedFiles serves files via HMAC-signed URLs without requiring authentication.
|
||
// This is used by IM channels to serve images that are embedded in bot replies.
|
||
//
|
||
// Route:
|
||
// - /api/v1/files/presigned?file_path=<provider://...>&tenant_id=<id>&expires=<unix>&sig=<hmac>
|
||
func servePresignedFiles(r *gin.Engine, tenantService interfaces.TenantService) {
|
||
baseDir := os.Getenv("LOCAL_STORAGE_BASE_DIR")
|
||
if baseDir == "" {
|
||
baseDir = "/data/files"
|
||
}
|
||
absDir, _ := filepath.Abs(baseDir)
|
||
|
||
r.GET("/api/v1/files/presigned", func(c *gin.Context) {
|
||
filePath := strings.TrimSpace(c.Query("file_path"))
|
||
tenantIDStr := strings.TrimSpace(c.Query("tenant_id"))
|
||
expiresStr := strings.TrimSpace(c.Query("expires"))
|
||
sig := strings.TrimSpace(c.Query("sig"))
|
||
|
||
if filePath == "" || tenantIDStr == "" || expiresStr == "" || sig == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"error": "missing required parameters"})
|
||
return
|
||
}
|
||
if strings.Contains(filePath, "..") {
|
||
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file path"})
|
||
return
|
||
}
|
||
|
||
tenantID, err := strconv.ParseUint(tenantIDStr, 10, 64)
|
||
if err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid tenant_id"})
|
||
return
|
||
}
|
||
|
||
// Verify HMAC signature and expiry.
|
||
if !secutils.VerifyFileURLSig(filePath, tenantID, expiresStr, sig) {
|
||
c.JSON(http.StatusForbidden, gin.H{"error": "invalid or expired signature"})
|
||
return
|
||
}
|
||
|
||
// Resolve the file service for this tenant.
|
||
provider := types.ParseProviderScheme(filePath)
|
||
tenant, err := tenantService.GetTenantByID(c.Request.Context(), tenantID)
|
||
if err != nil {
|
||
logger.Warnf(context.Background(), "[Router] /files/presigned tenant lookup failed: tenant_id=%d err=%v", tenantID, err)
|
||
c.Status(http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
fileSvc, resolvedProvider, err := filesvc.NewFileServiceFromStorageConfig(provider, tenant.StorageEngineConfig, absDir)
|
||
if err != nil {
|
||
logger.Warnf(context.Background(), "[Router] /files/presigned resolve file service failed: tenant_id=%d provider=%s err=%v", tenantID, provider, err)
|
||
c.Status(http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
reader, err := fileSvc.GetFile(c.Request.Context(), filePath)
|
||
if err != nil {
|
||
logger.Warnf(context.Background(), "[Router] /files/presigned get file failed: tenant_id=%d provider=%s path=%q err=%v", tenantID, resolvedProvider, filePath, err)
|
||
c.Status(http.StatusNotFound)
|
||
return
|
||
}
|
||
defer reader.Close()
|
||
|
||
ext := filepath.Ext(filePath)
|
||
contentType := "application/octet-stream"
|
||
switch strings.ToLower(ext) {
|
||
case ".png":
|
||
contentType = "image/png"
|
||
case ".jpg", ".jpeg":
|
||
contentType = "image/jpeg"
|
||
case ".gif":
|
||
contentType = "image/gif"
|
||
case ".webp":
|
||
contentType = "image/webp"
|
||
case ".bmp":
|
||
contentType = "image/bmp"
|
||
case ".svg":
|
||
contentType = "image/svg+xml"
|
||
case ".pdf":
|
||
contentType = "application/pdf"
|
||
}
|
||
|
||
c.Header("Content-Type", contentType)
|
||
c.Header("Cache-Control", "public, max-age=86400")
|
||
c.Status(http.StatusOK)
|
||
if _, err := io.Copy(c.Writer, reader); err != nil {
|
||
logger.Warnf(context.Background(), "[Router] /files/presigned write response failed: %v", err)
|
||
}
|
||
})
|
||
}
|
||
|
||
// RegisterDataSourceRoutes 注册数据源相关的路由
|
||
//
|
||
// Data sources hold external service credentials (Feishu/Notion/Yuque)
|
||
// and trigger sync jobs that mutate KB content tenant-wide. Reads are
|
||
// Viewer+; everything else (CRUD, validation, sync control, credential
|
||
// subresource) is Admin+.
|
||
func RegisterDataSourceRoutes(
|
||
r *gin.RouterGroup,
|
||
handler *handler.DataSourceHandler,
|
||
credHandler *handler.DataSourceCredentialsHandler,
|
||
g *rbacGuards,
|
||
) {
|
||
// Data source routes
|
||
ds := r.Group("/datasource")
|
||
{
|
||
// Get available connector types — Viewer+
|
||
ds.GET("/types", g.Viewer(), handler.GetAvailableConnectors)
|
||
|
||
// Validate credentials without persistence (for "Test Connection" button) — Admin+
|
||
ds.POST("/validate-credentials", g.Admin(), handler.ValidateCredentials)
|
||
|
||
// CRUD operations
|
||
ds.POST("", g.Admin(), handler.CreateDataSource)
|
||
ds.GET("", g.Viewer(), handler.ListDataSources)
|
||
ds.GET("/:id", g.Viewer(), handler.GetDataSource)
|
||
ds.PUT("/:id", g.Admin(), handler.UpdateDataSource)
|
||
ds.DELETE("/:id", g.Admin(), handler.DeleteDataSource)
|
||
|
||
// Credential subresource. Single logical field "credentials" because
|
||
// connector credentials are a per-connector atomic map (see
|
||
// internal/handler/datasource_credentials.go). — Admin+
|
||
ds.PUT("/:id/credentials", g.Admin(), credHandler.Put)
|
||
ds.DELETE("/:id/credentials/:field", g.Admin(), credHandler.DeleteField)
|
||
|
||
// Connection and resource management — Admin+
|
||
ds.POST("/:id/validate", g.Admin(), handler.ValidateConnection)
|
||
ds.GET("/:id/resources", g.Admin(), handler.ListAvailableResources)
|
||
|
||
// Sync management — Admin+
|
||
ds.POST("/:id/sync", g.Admin(), handler.ManualSync)
|
||
ds.POST("/:id/pause", g.Admin(), handler.PauseDataSource)
|
||
ds.POST("/:id/resume", g.Admin(), handler.ResumeDataSource)
|
||
|
||
// Sync logs — Viewer+ (read-only audit trail)
|
||
ds.GET("/:id/logs", g.Viewer(), handler.GetSyncLogs)
|
||
ds.GET("/logs/:log_id", g.Viewer(), handler.GetSyncLog)
|
||
}
|
||
}
|
||
|
||
// RegisterWeKnoraCloudRoutes 注册 WeKnoraCloud 初始化路由
|
||
// RegisterWeKnoraCloudRoutes registers the WeKnoraCloud credential
|
||
// management endpoints. SaveCredentials persists external SaaS keys
|
||
// for the tenant (Admin+), Status is a low-risk readiness probe (Viewer+).
|
||
func RegisterWeKnoraCloudRoutes(r *gin.RouterGroup, handler *handler.WeKnoraCloudHandler, g *rbacGuards) {
|
||
r.POST("/weknoracloud/credentials", g.Admin(), handler.SaveCredentials)
|
||
r.GET("/models/weknoracloud/status", g.Viewer(), handler.Status)
|
||
}
|
||
|
||
// RegisterWikiPageRoutes registers wiki page related routes.
|
||
//
|
||
// Wiki pages are KB content (wiki mode): reads are Viewer+, content
|
||
// mutations (create/update/delete) and maintenance actions
|
||
// (rebuild-links, auto-fix, change issue status) are Contributor+.
|
||
// Per-KB ownership granularity for individual pages is a follow-up,
|
||
// same as plain knowledge entries.
|
||
func RegisterWikiPageRoutes(r *gin.RouterGroup, wikiHandler *handler.WikiPageHandler, g *rbacGuards) {
|
||
wiki := r.Group("/knowledgebase/:kb_id/wiki")
|
||
{
|
||
// Page CRUD
|
||
wiki.GET("/pages", g.Viewer(), wikiHandler.ListPages)
|
||
wiki.POST("/pages", g.Contributor(), wikiHandler.CreatePage)
|
||
wiki.GET("/pages/*slug", g.Viewer(), wikiHandler.GetPage)
|
||
wiki.PUT("/pages/*slug", g.Contributor(), wikiHandler.UpdatePage)
|
||
wiki.DELETE("/pages/*slug", g.Contributor(), wikiHandler.DeletePage)
|
||
|
||
// Special pages
|
||
wiki.GET("/index", g.Viewer(), wikiHandler.GetIndex)
|
||
wiki.GET("/log", g.Viewer(), wikiHandler.GetLog)
|
||
|
||
// Graph and stats
|
||
wiki.GET("/graph", g.Viewer(), wikiHandler.GetGraph)
|
||
wiki.GET("/stats", g.Viewer(), wikiHandler.GetStats)
|
||
|
||
// Search and maintenance
|
||
wiki.GET("/search", g.Viewer(), wikiHandler.SearchPages)
|
||
wiki.POST("/rebuild-links", g.Contributor(), wikiHandler.RebuildLinks)
|
||
wiki.GET("/lint", g.Viewer(), wikiHandler.Lint)
|
||
wiki.POST("/auto-fix", g.Contributor(), wikiHandler.AutoFix)
|
||
|
||
// Issues
|
||
wiki.GET("/issues", g.Viewer(), wikiHandler.ListIssues)
|
||
wiki.PUT("/issues/:issue_id/status", g.Contributor(), wikiHandler.UpdateIssueStatus)
|
||
}
|
||
}
|