init commit

This commit is contained in:
wizardchen
2025-08-05 15:08:07 +08:00
commit 56eb2bce33
282 changed files with 49077 additions and 0 deletions
+233
View File
@@ -0,0 +1,233 @@
package handler
import (
"net/http"
"github.com/Tencent/WeKnora/internal/application/service"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// ChunkHandler defines HTTP handlers for chunk operations
type ChunkHandler struct {
service interfaces.ChunkService
}
// NewChunkHandler creates a new chunk handler
func NewChunkHandler(service interfaces.ChunkService) *ChunkHandler {
return &ChunkHandler{service: service}
}
// ListKnowledgeChunks lists all chunks for a given knowledge ID
func (h *ChunkHandler) ListKnowledgeChunks(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving knowledge chunks list")
knowledgeID := c.Param("knowledge_id")
if knowledgeID == "" {
logger.Error(ctx, "Knowledge ID is empty")
c.Error(errors.NewBadRequestError("Knowledge ID cannot be empty"))
return
}
// Parse pagination parameters
var pagination types.Pagination
if err := c.ShouldBindQuery(&pagination); err != nil {
logger.Error(ctx, "Failed to parse pagination parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
logger.Infof(ctx, "Retrieving knowledge chunks list, knowledge ID: %s, page: %d, page size: %d",
knowledgeID, pagination.Page, pagination.PageSize)
// Use pagination for query
result, err := h.service.ListPagedChunksByKnowledgeID(ctx, knowledgeID, &pagination)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(
ctx, "Successfully retrieved knowledge chunks list, knowledge ID: %s, total: %d",
knowledgeID, result.Total,
)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": result.Data,
"total": result.Total,
"page": result.Page,
"page_size": result.PageSize,
})
}
// UpdateChunkRequest defines the request structure for updating a chunk
type UpdateChunkRequest struct {
Content string `json:"content"`
Embedding []float32 `json:"embedding"`
ChunkIndex int `json:"chunk_index"`
IsEnabled bool `json:"is_enabled"`
StartAt int `json:"start_at"`
EndAt int `json:"end_at"`
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) {
ctx := c.Request.Context()
// Validate knowledge ID
knowledgeID := c.Param("knowledge_id")
if knowledgeID == "" {
logger.Error(ctx, "Knowledge ID is empty")
return nil, "", errors.NewBadRequestError("Knowledge ID cannot be empty")
}
// Validate chunk ID
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Chunk ID is empty")
return nil, knowledgeID, 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")
}
logger.Infof(ctx, "Retrieving knowledge chunk information, knowledge ID: %s, chunk ID: %s", knowledgeID, id)
// Get existing chunk
chunk, err := h.service.GetChunkByID(ctx, knowledgeID, 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")
}
logger.ErrorWithFields(ctx, err, nil)
return nil, knowledgeID, errors.NewInternalServerError(err.Error())
}
// Validate tenant ID
if chunk.TenantID != tenantID.(uint) || 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.(uint), chunk.TenantID,
)
return nil, knowledgeID, errors.NewForbiddenError("No permission to access this chunk")
}
return chunk, knowledgeID, nil
}
// UpdateChunk updates a chunk's properties
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)
if err != nil {
c.Error(err)
return
}
var req UpdateChunkRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// Update chunk properties
if req.Content != "" {
chunk.Content = req.Content
}
chunk.IsEnabled = req.IsEnabled
logger.Infof(ctx, "Updating knowledge chunk, knowledge ID: %s, chunk ID: %s", knowledgeID, chunk.ID)
if err := h.service.UpdateChunk(ctx, chunk); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge chunk updated successfully, knowledge ID: %s, chunk ID: %s", knowledgeID, chunk.ID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": chunk,
})
}
// DeleteChunk deletes a specific chunk
func (h *ChunkHandler) DeleteChunk(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting knowledge chunk")
// Validate parameters and get chunk
chunk, knowledgeID, err := h.validateAndGetChunk(c)
if err != nil {
c.Error(err)
return
}
logger.Infof(ctx, "Deleting knowledge chunk, knowledge ID: %s, chunk ID: %s", knowledgeID, chunk.ID)
if err := h.service.DeleteChunk(ctx, chunk.ID); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge chunk deleted successfully, knowledge ID: %s, chunk ID: %s", knowledgeID, chunk.ID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Chunk deleted",
})
}
// DeleteChunksByKnowledgeID deletes all chunks for a given knowledge ID
func (h *ChunkHandler) DeleteChunksByKnowledgeID(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting all chunks under knowledge")
knowledgeID := c.Param("knowledge_id")
if knowledgeID == "" {
logger.Error(ctx, "Knowledge ID is empty")
c.Error(errors.NewBadRequestError("Knowledge ID cannot be empty"))
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, "Deleting all chunks under knowledge, knowledge ID: %s, tenant ID: %d", knowledgeID, tenantID.(uint))
// Delete all chunks under the knowledge
err := h.service.DeleteChunksByKnowledgeID(ctx, knowledgeID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "All chunks under knowledge deleted successfully, knowledge ID: %s", knowledgeID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "All chunks under knowledge deleted",
})
}
+105
View File
@@ -0,0 +1,105 @@
package handler
import (
"net/http"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// EvaluationHandler handles evaluation related HTTP requests
type EvaluationHandler struct {
evaluationService interfaces.EvaluationService // Service for evaluation operations
}
// NewEvaluationHandler creates a new EvaluationHandler instance
func NewEvaluationHandler(evaluationService interfaces.EvaluationService) *EvaluationHandler {
return &EvaluationHandler{evaluationService: evaluationService}
}
// EvaluationRequest contains parameters for evaluation request
type EvaluationRequest struct {
DatasetID string `json:"dataset_id"` // ID of dataset to evaluate
EmbeddingModelID string `json:"embedding_id"` // ID of embedding model to use
ChatModelID string `json:"chat_id"` // ID of chat model to use
RerankModelID string `json:"rerank_id"` // ID of rerank model to use
}
// Evaluation handles evaluation request
func (e *EvaluationHandler) Evaluation(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start processing evaluation request")
var request *EvaluationRequest
if err := c.ShouldBind(&request); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError("Invalid request parameters").WithDetails(err.Error()))
return
}
tenantID, exists := c.Get(string(types.TenantIDContextKey))
if !exists {
logger.Error(ctx, "Failed to get tenant ID")
c.Error(errors.NewUnauthorizedError("Unauthorized"))
return
}
logger.Infof(ctx, "Executing evaluation, tenant: %v, dataset: %s, embedding: %s, chat: %s, rerank: %s",
tenantID, request.DatasetID, request.EmbeddingModelID, request.ChatModelID, request.RerankModelID)
task, err := e.evaluationService.Evaluation(ctx,
request.DatasetID,
request.EmbeddingModelID,
request.ChatModelID,
request.RerankModelID,
)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Evaluation task created successfully")
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": task,
})
}
// GetEvaluationRequest contains parameters for getting evaluation result
type GetEvaluationRequest struct {
TaskID string `form:"task_id" binding:"required"` // ID of evaluation task
}
// GetEvaluationResult retrieves evaluation result by task ID
func (e *EvaluationHandler) GetEvaluationResult(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving evaluation result")
var request *GetEvaluationRequest
if err := c.ShouldBind(&request); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError("Invalid request parameters").WithDetails(err.Error()))
return
}
logger.Infof(ctx, "Retrieving evaluation result, task ID: %s", request.TaskID)
result, err := e.evaluationService.EvaluationResult(ctx, request.TaskID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Retrieved evaluation result successfully, task ID: %s", request.TaskID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": result,
})
}
+458
View File
@@ -0,0 +1,458 @@
package handler
import (
"encoding/json"
"fmt"
"io"
"net/http"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// KnowledgeHandler processes HTTP requests related to knowledge resources
type KnowledgeHandler struct {
kgService interfaces.KnowledgeService
kbService interfaces.KnowledgeBaseService
}
// NewKnowledgeHandler creates a new knowledge handler instance
func NewKnowledgeHandler(
kgService interfaces.KnowledgeService,
kbService interfaces.KnowledgeBaseService,
) *KnowledgeHandler {
return &KnowledgeHandler{kgService: kgService, kbService: kbService}
}
// 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) {
ctx := c.Request.Context()
// Get knowledge base ID from URL path parameter
kbID := c.Param("id")
if kbID == "" {
logger.Error(ctx, "Knowledge base ID is empty")
return nil, "", 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())
}
// Verify tenant permissions
if kb.TenantID != c.GetUint(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.GetUint(types.TenantIDContextKey.String()),
kb.TenantID,
)
return nil, kbID, errors.NewForbiddenError("Permission denied to access this knowledge base")
}
return kb, kbID, nil
}
// handleDuplicateKnowledgeError handles cases where duplicate knowledge is detected
// Returns true if the error was a duplicate error and was handled, false otherwise
func (h *KnowledgeHandler) handleDuplicateKnowledgeError(c *gin.Context,
err error, knowledge *types.Knowledge, duplicateType string,
) bool {
if dupErr, ok := err.(*types.DuplicateKnowledgeError); ok {
ctx := c.Request.Context()
logger.Warnf(ctx, "Detected duplicate %s: %s", duplicateType, dupErr.Error())
c.JSON(http.StatusConflict, gin.H{
"success": false,
"message": dupErr.Error(),
"data": knowledge, // knowledge contains the existing document
"code": fmt.Sprintf("duplicate_%s", duplicateType),
})
return true
}
return false
}
// CreateKnowledgeFromFile handles requests to create knowledge from an uploaded file
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)
if err != nil {
c.Error(err)
return
}
// Get the uploaded file
file, err := c.FormFile("file")
if err != nil {
logger.Error(ctx, "File upload failed", err)
c.Error(errors.NewBadRequestError("File upload failed").WithDetails(err.Error()))
return
}
logger.Infof(ctx, "File upload successful, filename: %s, size: %.2f KB", file.Filename, float64(file.Size)/1024)
logger.Infof(ctx, "Creating knowledge, knowledge base ID: %s, filename: %s", kbID, file.Filename)
// Parse metadata if provided
var metadata map[string]string
metadataStr := c.PostForm("metadata")
if metadataStr != "" {
if err := json.Unmarshal([]byte(metadataStr), &metadata); err != nil {
logger.Error(ctx, "Failed to parse metadata", err)
c.Error(errors.NewBadRequestError("Invalid metadata format").WithDetails(err.Error()))
return
}
logger.Infof(ctx, "Received file metadata: %v", metadata)
}
// Create knowledge entry from the file
knowledge, err := h.kgService.CreateKnowledgeFromFile(ctx, kbID, file, metadata)
// Check for duplicate knowledge error
if err != nil {
if h.handleDuplicateKnowledgeError(c, err, knowledge, "file") {
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge created successfully, ID: %s, title: %s", knowledge.ID, knowledge.Title)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": knowledge,
})
}
// CreateKnowledgeFromURL handles requests to create knowledge from a URL
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)
if err != nil {
c.Error(err)
return
}
// Parse URL from request body
var req struct {
URL string `json:"url" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse URL request", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
logger.Infof(ctx, "Received URL request: %s", req.URL)
logger.Infof(ctx, "Creating knowledge from URL, knowledge base ID: %s, URL: %s", kbID, req.URL)
// Create knowledge entry from the URL
knowledge, err := h.kgService.CreateKnowledgeFromURL(ctx, kbID, req.URL)
// Check for duplicate knowledge error
if err != nil {
if h.handleDuplicateKnowledgeError(c, err, knowledge, "url") {
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge created successfully from URL, ID: %s, title: %s", knowledge.ID, knowledge.Title)
c.JSON(http.StatusCreated, gin.H{
"success": true,
"data": knowledge,
})
}
// GetKnowledge retrieves a knowledge entry by its ID
func (h *KnowledgeHandler) GetKnowledge(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving knowledge")
// Get knowledge ID from URL path parameter
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
c.Error(errors.NewBadRequestError("Knowledge ID cannot be empty"))
return
}
logger.Infof(ctx, "Retrieving knowledge, ID: %s", id)
knowledge, err := h.kgService.GetKnowledgeByID(ctx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge retrieved successfully, ID: %s, title: %s", knowledge.ID, knowledge.Title)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": knowledge,
})
}
// ListKnowledge retrieves a paginated list of knowledge entries from a knowledge base
func (h *KnowledgeHandler) ListKnowledge(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving knowledge list")
// Get knowledge base ID from URL path parameter
kbID := c.Param("id")
if kbID == "" {
logger.Error(ctx, "Knowledge base ID is empty")
c.Error(errors.NewBadRequestError("Knowledge base ID cannot be empty"))
return
}
// Parse pagination parameters from query string
var pagination types.Pagination
if err := c.ShouldBindQuery(&pagination); err != nil {
logger.Error(ctx, "Failed to parse pagination parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
logger.Infof(ctx, "Retrieving knowledge list under knowledge base, knowledge base ID: %s, page: %d, page size: %d",
kbID, pagination.Page, pagination.PageSize)
// Retrieve paginated knowledge entries
result, err := h.kgService.ListPagedKnowledgeByKnowledgeBaseID(ctx, kbID, &pagination)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge list retrieved successfully, knowledge base ID: %s, total: %d", kbID, result.Total)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": result.Data,
"total": result.Total,
"page": result.Page,
"page_size": result.PageSize,
})
}
// DeleteKnowledge handles requests to delete a knowledge entry by its ID
func (h *KnowledgeHandler) DeleteKnowledge(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting knowledge")
// Get knowledge ID from URL path parameter
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
c.Error(errors.NewBadRequestError("Knowledge ID cannot be empty"))
return
}
logger.Infof(ctx, "Deleting knowledge, ID: %s", id)
err := h.kgService.DeleteKnowledge(ctx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge deleted successfully, ID: %s", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Deleted successfully",
})
}
// DownloadKnowledgeFile handles requests to download a file associated with a knowledge entry
func (h *KnowledgeHandler) DownloadKnowledgeFile(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start downloading knowledge file")
// Get knowledge ID from URL path parameter
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
c.Error(errors.NewBadRequestError("Knowledge ID cannot be empty"))
return
}
logger.Infof(ctx, "Retrieving knowledge file, ID: %s", id)
// Get file content and filename
file, filename, err := h.kgService.GetKnowledgeFile(ctx, id)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Failed to retrieve file").WithDetails(err.Error()))
return
}
defer file.Close()
logger.Infof(ctx, "Knowledge file retrieved successfully, ID: %s, filename: %s", id, filename)
// Set response headers for file download
c.Header("Content-Description", "File Transfer")
c.Header("Content-Transfer-Encoding", "binary")
c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
c.Header("Content-Type", "application/octet-stream")
c.Header("Expires", "0")
c.Header("Cache-Control", "must-revalidate")
c.Header("Pragma", "public")
// Stream file content to response
c.Stream(func(w io.Writer) bool {
if _, err := io.Copy(w, file); err != nil {
logger.Errorf(ctx, "Failed to send file: %v", err)
return false
}
logger.Debug(ctx, "File sending completed")
return false
})
}
// GetKnowledgeBatchRequest defines parameters for batch knowledge retrieval
type GetKnowledgeBatchRequest struct {
IDs []string `form:"ids" binding:"required"` // List of knowledge IDs
}
// GetKnowledgeBatch handles requests to retrieve multiple knowledge entries in a batch
func (h *KnowledgeHandler) GetKnowledgeBatch(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start batch retrieving knowledge")
// 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
}
// 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)
c.Error(errors.NewBadRequestError("Invalid request parameters").WithDetails(err.Error()))
return
}
logger.Infof(
ctx,
"Batch retrieving knowledge, tenant ID: %d, number of knowledge IDs: %d",
tenantID.(uint), len(req.IDs),
)
// Retrieve knowledge entries in batch
knowledges, err := h.kgService.GetKnowledgeBatch(ctx, tenantID.(uint), 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),
)
// Return results
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": knowledges,
})
}
func (h *KnowledgeHandler) UpdateKnowledge(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start Update knowledge")
// Get knowledge ID from URL path parameter
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
c.Error(errors.NewBadRequestError("Knowledge ID cannot be empty"))
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
}
if err := h.kgService.UpdateKnowledge(ctx, &knowledge); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge updated successfully, knowledge ID: %s", knowledge.ID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Knowledge chunk updated successfully",
})
}
// UpdateImageInfo updates a chunk's properties
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 := c.Param("id")
if id == "" {
logger.Error(ctx, "Knowledge ID is empty")
c.Error(errors.NewBadRequestError("Knowledge ID cannot be empty"))
return
}
chunkID := c.Param("chunk_id")
if id == "" {
logger.Error(ctx, "Chunk ID is empty")
c.Error(errors.NewBadRequestError("Chunk ID cannot be empty"))
return
}
var request struct {
ImageInfo string `json:"image_info"`
}
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
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, request.ImageInfo)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge chunk updated successfully, knowledge ID: %s, chunk ID: %s", id, chunkID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Knowledge chunk image updated successfully",
})
}
+298
View File
@@ -0,0 +1,298 @@
package handler
import (
"net/http"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// KnowledgeBaseHandler defines the HTTP handler for knowledge base operations
type KnowledgeBaseHandler struct {
service interfaces.KnowledgeBaseService
knowledgeService interfaces.KnowledgeService
}
// NewKnowledgeBaseHandler creates a new knowledge base handler instance
func NewKnowledgeBaseHandler(
service interfaces.KnowledgeBaseService,
knowledgeService interfaces.KnowledgeService,
) *KnowledgeBaseHandler {
return &KnowledgeBaseHandler{service: service, knowledgeService: knowledgeService}
}
// HybridSearch handles requests to perform hybrid vector and keyword search on a knowledge base
func (h *KnowledgeBaseHandler) HybridSearch(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start hybrid search")
// Validate query parameter existence
query := c.Query("query")
if query == "" {
logger.Error(ctx, "Query parameter is empty")
c.Error(errors.NewBadRequestError("Query parameter cannot be empty"))
return
}
// Validate knowledge base ID
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Knowledge base ID is empty")
c.Error(errors.NewBadRequestError("Knowledge base ID cannot be empty"))
return
}
logger.Infof(ctx, "Executing hybrid search, knowledge base ID: %s, query: %s", id, query)
// Execute hybrid search with default search parameters
results, err := h.service.HybridSearch(ctx, id, types.SearchParams{
QueryText: query,
KeywordThreshold: 0.5,
VectorThreshold: 0.3,
MatchCount: 10,
})
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Hybrid search completed, knowledge base ID: %s, result count: %d", id, len(results))
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": results,
})
}
// CreateKnowledgeBase handles requests to create a new knowledge base
func (h *KnowledgeBaseHandler) CreateKnowledgeBase(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start creating knowledge base")
// Parse request body
var req types.KnowledgeBase
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError("Invalid request parameters").WithDetails(err.Error()))
return
}
logger.Infof(ctx, "Creating knowledge base, name: %s", req.Name)
// Create knowledge base using the service
kb, err := h.service.CreateKnowledgeBase(ctx, &req)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge base created successfully, ID: %s, name: %s", kb.ID, kb.Name)
c.JSON(http.StatusCreated, gin.H{
"success": true,
"data": kb,
})
}
// 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) {
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")
}
// Get knowledge base ID from URL parameter
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Knowledge base ID is empty")
return nil, "", errors.NewBadRequestError("Knowledge base ID cannot be empty")
}
logger.Infof(ctx, "Retrieving knowledge base, ID: %s", id)
// 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())
}
// Verify tenant ownership
if kb.TenantID != tenantID.(uint) {
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.(uint), kb.TenantID,
)
return nil, id, errors.NewForbiddenError("No permission to operate")
}
return kb, id, nil
}
// GetKnowledgeBase handles requests to retrieve a knowledge base by ID
func (h *KnowledgeBaseHandler) GetKnowledgeBase(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving knowledge base")
// Validate and get the knowledge base
kb, id, err := h.validateAndGetKnowledgeBase(c)
if err != nil {
c.Error(err)
return
}
logger.Infof(ctx, "Retrieved knowledge base successfully, ID: %s, name: %s", id, kb.Name)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": kb,
})
}
// ListKnowledgeBases handles requests to list all knowledge bases for a tenant
func (h *KnowledgeBaseHandler) ListKnowledgeBases(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving knowledge base list")
// 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 knowledge base list for tenant, tenant ID: %d", tenantID.(uint))
// Get all knowledge bases for this tenant
kbs, err := h.service.ListKnowledgeBases(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(
ctx,
"Retrieved knowledge base list successfully, tenant ID: %d, total: %d knowledge bases",
tenantID.(uint), len(kbs),
)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": kbs,
})
}
// UpdateKnowledgeBaseRequest defines the request body structure for updating a knowledge base
type UpdateKnowledgeBaseRequest struct {
Name string `json:"name" binding:"required"`
Description string `json:"description"`
Config *types.KnowledgeBaseConfig `json:"config" binding:"required"`
}
// UpdateKnowledgeBase handles requests to update an existing knowledge base
func (h *KnowledgeBaseHandler) UpdateKnowledgeBase(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start updating knowledge base")
// Validate and get the knowledge base
_, id, err := h.validateAndGetKnowledgeBase(c)
if err != nil {
c.Error(err)
return
}
// Parse request body
var req UpdateKnowledgeBaseRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError("Invalid request parameters").WithDetails(err.Error()))
return
}
logger.Infof(ctx, "Updating knowledge base, ID: %s, name: %s", id, req.Name)
// Update the knowledge base
kb, err := h.service.UpdateKnowledgeBase(ctx, id, req.Name, req.Description, req.Config)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge base updated successfully, ID: %s", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": kb,
})
}
// DeleteKnowledgeBase handles requests to delete a knowledge base
func (h *KnowledgeBaseHandler) DeleteKnowledgeBase(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting knowledge base")
// Validate and get the knowledge base
kb, id, err := h.validateAndGetKnowledgeBase(c)
if err != nil {
c.Error(err)
return
}
logger.Infof(ctx, "Deleting knowledge base, ID: %s, name: %s", id, kb.Name)
// Delete the knowledge base
if err := h.service.DeleteKnowledgeBase(ctx, id); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge base deleted successfully, ID: %s", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Knowledge base deleted successfully",
})
}
type CopyKnowledgeBaseRequest struct {
SourceID string `json:"source_id" binding:"required"`
TargetID string `json:"target_id"`
}
func (h *KnowledgeBaseHandler) CopyKnowledgeBase(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start copy knowledge base")
var req CopyKnowledgeBaseRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError("Invalid request parameters").WithDetails(err.Error()))
return
}
logger.Infof(ctx, "Copy knowledge base, ID: %s to ID: %s", req.SourceID, req.TargetID)
err := h.knowledgeService.CloneKnowledgeBase(ctx, req.SourceID, req.TargetID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge base copy successfully, ID: %s to ID: %s", req.SourceID, req.TargetID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Knowledge base copy successfully",
})
}
+135
View File
@@ -0,0 +1,135 @@
package handler
import (
"net/http"
"strconv"
"time"
"github.com/gin-gonic/gin"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
// MessageHandler handles HTTP requests related to messages within chat sessions
// It provides endpoints for loading and managing message history
type MessageHandler struct {
MessageService interfaces.MessageService // Service that implements message business logic
}
// NewMessageHandler creates a new message handler instance with the required service
// Parameters:
// - messageService: Service that implements message business logic
//
// Returns a pointer to a new MessageHandler
func NewMessageHandler(messageService interfaces.MessageService) *MessageHandler {
return &MessageHandler{
MessageService: messageService,
}
}
// LoadMessages handles requests to load message history
// It supports both loading recent messages and loading messages before a specific timestamp
// This endpoint is used for scrolling through conversation history
func (h *MessageHandler) LoadMessages(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start loading messages")
// Get path parameters and query parameters
sessionID := c.Param("session_id")
limit := c.DefaultQuery("limit", "20")
beforeTimeStr := c.DefaultQuery("before_time", "")
logger.Infof(ctx, "Loading messages params, session ID: %s, limit: %s, before time: %s",
sessionID, limit, beforeTimeStr)
// Parse limit parameter with fallback to default
limitInt, err := strconv.Atoi(limit)
if err != nil {
logger.Warnf(ctx, "Invalid limit value, using default value 20, input: %s", limit)
limitInt = 20
}
// If no beforeTime is provided, retrieve the most recent messages
if beforeTimeStr == "" {
logger.Infof(ctx, "Getting recent messages for session, session ID: %s, limit: %d", sessionID, limitInt)
messages, err := h.MessageService.GetRecentMessagesBySession(ctx, sessionID, limitInt)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(
ctx,
"Successfully retrieved recent messages, session ID: %s, message count: %d",
sessionID, len(messages),
)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": messages,
})
return
}
// If beforeTime is provided, parse the timestamp
beforeTime, err := time.Parse(time.RFC3339Nano, beforeTimeStr)
if err != nil {
logger.Errorf(
ctx,
"Invalid time format, please use RFC3339Nano format, err: %v, beforeTimeStr: %s",
err, beforeTimeStr,
)
c.Error(errors.NewBadRequestError("Invalid time format, please use RFC3339Nano format"))
return
}
// Retrieve messages before the specified timestamp
logger.Infof(ctx, "Getting messages before specific time, session ID: %s, before time: %s, limit: %d",
sessionID, beforeTime.Format(time.RFC3339Nano), limitInt)
messages, err := h.MessageService.GetMessagesBySessionBeforeTime(ctx, sessionID, beforeTime, limitInt)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(
ctx,
"Successfully retrieved messages before time, session ID: %s, message count: %d",
sessionID, len(messages),
)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": messages,
})
}
// DeleteMessage handles requests to delete a message from a session
// It requires both session ID and message ID to identify the specific message to delete
func (h *MessageHandler) DeleteMessage(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting message")
// Get path parameters for session and message identification
sessionID := c.Param("session_id")
messageID := c.Param("id")
logger.Infof(ctx, "Deleting message, session ID: %s, message ID: %s", sessionID, messageID)
// Delete the message using the message service
if err := h.MessageService.DeleteMessage(ctx, sessionID, messageID); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Message deleted successfully, session ID: %s, message ID: %s", sessionID, messageID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Message deleted successfully",
})
}
+265
View File
@@ -0,0 +1,265 @@
package handler
import (
"net/http"
"github.com/Tencent/WeKnora/internal/application/service"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// ModelHandler handles HTTP requests for model-related operations
// It implements the necessary methods to create, retrieve, update, and delete models
type ModelHandler struct {
service interfaces.ModelService
}
// NewModelHandler creates a new instance of ModelHandler
// It requires a model service implementation that handles business logic
// Parameters:
// - service: An implementation of the ModelService interface
//
// Returns a pointer to the newly created ModelHandler
func NewModelHandler(service interfaces.ModelService) *ModelHandler {
return &ModelHandler{service: service}
}
// CreateModelRequest defines the structure for model creation requests
// Contains all fields required to create a new model in the system
type CreateModelRequest struct {
Name string `json:"name" binding:"required"`
Type types.ModelType `json:"type" binding:"required"`
Source types.ModelSource `json:"source" binding:"required"`
Description string `json:"description"`
Parameters types.ModelParameters `json:"parameters" binding:"required"`
IsDefault bool `json:"is_default"`
}
// CreateModel handles the HTTP request to create a new model
// It validates the request, processes it using the model service,
// and returns the created model to the client
// Parameters:
// - c: Gin context for the HTTP request
func (h *ModelHandler) CreateModel(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start creating model")
var req CreateModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
tenantID := c.GetUint(types.TenantIDContextKey.String())
if tenantID == 0 {
logger.Error(ctx, "Tenant ID is empty")
c.Error(errors.NewBadRequestError("Tenant ID cannot be empty"))
return
}
logger.Infof(ctx, "Creating model, Tenant ID: %d, Model name: %s, Model type: %s",
tenantID, req.Name, req.Type)
model := &types.Model{
TenantID: tenantID,
Name: req.Name,
Type: req.Type,
Source: req.Source,
Description: req.Description,
Parameters: req.Parameters,
IsDefault: req.IsDefault,
}
if err := h.service.CreateModel(ctx, model); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Model created successfully, ID: %s, Name: %s", model.ID, model.Name)
c.JSON(http.StatusCreated, gin.H{
"success": true,
"data": model,
})
}
// GetModel handles the HTTP request to retrieve a model by its ID
// It fetches the model from the service and returns it to the client,
// or returns appropriate error messages if the model cannot be found
// Parameters:
// - c: Gin context for the HTTP request
func (h *ModelHandler) GetModel(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving model")
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Model ID is empty")
c.Error(errors.NewBadRequestError("Model ID cannot be empty"))
return
}
logger.Infof(ctx, "Retrieving model, ID: %s", id)
model, err := h.service.GetModelByID(ctx, id)
if err != nil {
if err == service.ErrModelNotFound {
logger.Warnf(ctx, "Model not found, ID: %s", id)
c.Error(errors.NewNotFoundError("Model not found"))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Retrieved model successfully, ID: %s, Name: %s", model.ID, model.Name)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": model,
})
}
// ListModels handles the HTTP request to retrieve all models for a tenant
// It validates the tenant ID, fetches models from the service, and returns them to the client
// Parameters:
// - c: Gin context for the HTTP request
func (h *ModelHandler) ListModels(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving model list")
tenantID := c.GetUint(types.TenantIDContextKey.String())
if tenantID == 0 {
logger.Error(ctx, "Tenant ID is empty")
c.Error(errors.NewBadRequestError("Tenant ID cannot be empty"))
return
}
logger.Infof(ctx, "Retrieving model list, Tenant ID: %d", tenantID)
models, err := h.service.ListModels(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Retrieved model list successfully, Tenant ID: %d, Total: %d models", tenantID, len(models))
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": models,
})
}
// UpdateModelRequest defines the structure for model update requests
// Contains fields that can be updated for an existing model
type UpdateModelRequest struct {
Name string `json:"name"`
Description string `json:"description"`
Parameters types.ModelParameters `json:"parameters"`
IsDefault bool `json:"is_default"`
}
// UpdateModel handles the HTTP request to update an existing model
// It validates the request, retrieves the current model, applies changes,
// and updates the model in the service
// Parameters:
// - c: Gin context for the HTTP request
func (h *ModelHandler) UpdateModel(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start updating model")
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Model ID is empty")
c.Error(errors.NewBadRequestError("Model ID cannot be empty"))
return
}
var req UpdateModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
logger.Infof(ctx, "Retrieving model information, ID: %s", id)
model, err := h.service.GetModelByID(ctx, id)
if err != nil {
if err == service.ErrModelNotFound {
logger.Warnf(ctx, "Model not found, ID: %s", id)
c.Error(errors.NewNotFoundError("Model not found"))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Update model fields if they are provided in the request
if req.Name != "" {
model.Name = req.Name
}
if req.Description != "" {
model.Description = req.Description
}
if req.Parameters != (types.ModelParameters{}) {
model.Parameters = req.Parameters
}
model.IsDefault = req.IsDefault
logger.Infof(ctx, "Updating model, ID: %s, Name: %s", id, model.Name)
if err := h.service.UpdateModel(ctx, model); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Model updated successfully, ID: %s", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": model,
})
}
// DeleteModel handles the HTTP request to delete a model by its ID
// It validates the model ID, attempts to delete the model through the service,
// and returns appropriate status and messages
// Parameters:
// - c: Gin context for the HTTP request
func (h *ModelHandler) DeleteModel(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting model")
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Model ID is empty")
c.Error(errors.NewBadRequestError("Model ID cannot be empty"))
return
}
logger.Infof(ctx, "Deleting model, ID: %s", id)
if err := h.service.DeleteModel(ctx, id); err != nil {
if err == service.ErrModelNotFound {
logger.Warnf(ctx, "Model not found, ID: %s", id)
c.Error(errors.NewNotFoundError("Model not found"))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Model deleted successfully, ID: %s", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Model deleted",
})
}
+809
View File
@@ -0,0 +1,809 @@
package handler
import (
"context"
"fmt"
"io"
"net/http"
"time"
"github.com/Tencent/WeKnora/internal/application/service"
"github.com/Tencent/WeKnora/internal/config"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// SessionHandler handles all HTTP requests related to conversation sessions
type SessionHandler struct {
messageService interfaces.MessageService // Service for managing messages
sessionService interfaces.SessionService // Service for managing sessions
streamManager interfaces.StreamManager // Manager for handling streaming responses
config *config.Config // Application configuration
testDataService *service.TestDataService // Service for test data (models, etc.)
}
// NewSessionHandler creates a new instance of SessionHandler with all necessary dependencies
func NewSessionHandler(
sessionService interfaces.SessionService,
messageService interfaces.MessageService,
streamManager interfaces.StreamManager,
config *config.Config,
testDataService *service.TestDataService,
) *SessionHandler {
return &SessionHandler{
sessionService: sessionService,
messageService: messageService,
streamManager: streamManager,
config: config,
testDataService: testDataService,
}
}
// SessionStrategy defines the configuration for a conversation session strategy
type SessionStrategy struct {
// Maximum number of conversation rounds to maintain
MaxRounds int `json:"max_rounds"`
// Whether to enable query rewrite for multi-round conversations
EnableRewrite bool `json:"enable_rewrite"`
// Strategy to use when no relevant knowledge is found
FallbackStrategy types.FallbackStrategy `json:"fallback_strategy"`
// Fixed response content for fallback
FallbackResponse string `json:"fallback_response"`
// Number of top results to retrieve from vector search
EmbeddingTopK int `json:"embedding_top_k"`
// Threshold for keyword-based retrieval
KeywordThreshold float64 `json:"keyword_threshold"`
// Threshold for vector-based retrieval
VectorThreshold float64 `json:"vector_threshold"`
// ID of the model used for reranking results
RerankModelID string `json:"rerank_model_id"`
// Number of top results after reranking
RerankTopK int `json:"rerank_top_k"`
// Threshold for reranking results
RerankThreshold float64 `json:"rerank_threshold"`
// ID of the model used for summarization
SummaryModelID string `json:"summary_model_id"`
// Parameters for the summary model
SummaryParameters *types.SummaryConfig `json:"summary_parameters" gorm:"type:json"`
// Prefix for responses when no match is found
NoMatchPrefix string `json:"no_match_prefix"`
}
// CreateSessionRequest represents a request to create a new session
type CreateSessionRequest struct {
// ID of the associated knowledge base
KnowledgeBaseID string `json:"knowledge_base_id" binding:"required"`
// Session strategy configuration
SessionStrategy *SessionStrategy `json:"session_strategy"`
}
// CreateSession handles the creation of a new conversation session
func (h *SessionHandler) CreateSession(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start creating session")
// Parse and validate the request body
var request CreateSessionRequest
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error(ctx, "Failed to validate session creation parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
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
}
// Validate knowledge base ID
if request.KnowledgeBaseID == "" {
logger.Error(ctx, "Knowledge base ID is empty")
c.Error(errors.NewBadRequestError("Knowledge base cannot be empty"))
return
}
logger.Infof(
ctx,
"Processing session creation request, tenant ID: %d, knowledge base ID: %s",
tenantID.(uint),
request.KnowledgeBaseID,
)
// Create session object with base properties
createdSession := &types.Session{
TenantID: tenantID.(uint),
KnowledgeBaseID: request.KnowledgeBaseID,
}
// If summary model parameters are empty, set defaults
if request.SessionStrategy != nil {
createdSession.RerankModelID = request.SessionStrategy.RerankModelID
createdSession.SummaryModelID = request.SessionStrategy.SummaryModelID
createdSession.MaxRounds = request.SessionStrategy.MaxRounds
createdSession.EnableRewrite = request.SessionStrategy.EnableRewrite
createdSession.FallbackStrategy = request.SessionStrategy.FallbackStrategy
createdSession.FallbackResponse = request.SessionStrategy.FallbackResponse
createdSession.EmbeddingTopK = request.SessionStrategy.EmbeddingTopK
createdSession.KeywordThreshold = request.SessionStrategy.KeywordThreshold
createdSession.VectorThreshold = request.SessionStrategy.VectorThreshold
createdSession.RerankTopK = request.SessionStrategy.RerankTopK
createdSession.RerankThreshold = request.SessionStrategy.RerankThreshold
if request.SessionStrategy.SummaryParameters != nil {
createdSession.SummaryParameters = request.SessionStrategy.SummaryParameters
} else {
createdSession.SummaryParameters = &types.SummaryConfig{
MaxTokens: h.config.Conversation.Summary.MaxTokens,
TopP: h.config.Conversation.Summary.TopP,
TopK: h.config.Conversation.Summary.TopK,
FrequencyPenalty: h.config.Conversation.Summary.FrequencyPenalty,
PresencePenalty: h.config.Conversation.Summary.PresencePenalty,
RepeatPenalty: h.config.Conversation.Summary.RepeatPenalty,
NoMatchPrefix: h.config.Conversation.Summary.NoMatchPrefix,
Temperature: h.config.Conversation.Summary.Temperature,
Seed: h.config.Conversation.Summary.Seed,
MaxCompletionTokens: h.config.Conversation.Summary.MaxCompletionTokens,
}
}
if createdSession.SummaryParameters.Prompt == "" {
createdSession.SummaryParameters.Prompt = h.config.Conversation.Summary.Prompt
}
if createdSession.SummaryParameters.ContextTemplate == "" {
createdSession.SummaryParameters.ContextTemplate = h.config.Conversation.Summary.ContextTemplate
}
if createdSession.SummaryParameters.NoMatchPrefix == "" {
createdSession.SummaryParameters.NoMatchPrefix = h.config.Conversation.Summary.NoMatchPrefix
}
logger.Debug(ctx, "Custom session strategy set")
} else {
// Use default configuration from global config
createdSession.MaxRounds = h.config.Conversation.MaxRounds
createdSession.EnableRewrite = h.config.Conversation.EnableRewrite
createdSession.FallbackStrategy = types.FallbackStrategy(h.config.Conversation.FallbackStrategy)
createdSession.FallbackResponse = h.config.Conversation.FallbackResponse
createdSession.EmbeddingTopK = h.config.Conversation.EmbeddingTopK
createdSession.KeywordThreshold = h.config.Conversation.KeywordThreshold
createdSession.VectorThreshold = h.config.Conversation.VectorThreshold
createdSession.RerankThreshold = h.config.Conversation.RerankThreshold
createdSession.RerankTopK = h.config.Conversation.RerankTopK
createdSession.SummaryParameters = &types.SummaryConfig{
MaxTokens: h.config.Conversation.Summary.MaxTokens,
TopP: h.config.Conversation.Summary.TopP,
TopK: h.config.Conversation.Summary.TopK,
FrequencyPenalty: h.config.Conversation.Summary.FrequencyPenalty,
PresencePenalty: h.config.Conversation.Summary.PresencePenalty,
RepeatPenalty: h.config.Conversation.Summary.RepeatPenalty,
Prompt: h.config.Conversation.Summary.Prompt,
ContextTemplate: h.config.Conversation.Summary.ContextTemplate,
NoMatchPrefix: h.config.Conversation.Summary.NoMatchPrefix,
Temperature: h.config.Conversation.Summary.Temperature,
Seed: h.config.Conversation.Summary.Seed,
MaxCompletionTokens: h.config.Conversation.Summary.MaxCompletionTokens,
}
logger.Debug(ctx, "Using default session strategy")
}
// Get model IDs from test data service if not provided
if createdSession.SummaryModelID == "" {
if h.testDataService != nil {
createdSession.SummaryModelID = h.testDataService.LLMModel.GetModelID()
logger.Debug(ctx, "Using summary model ID from test data service")
} else {
logger.Error(ctx, "Summary model ID is empty and cannot get default value")
c.Error(errors.NewBadRequestError("Summary model ID cannot be empty"))
return
}
}
if createdSession.RerankModelID == "" {
if h.testDataService != nil && h.testDataService.RerankModel != nil {
createdSession.RerankModelID = h.testDataService.RerankModel.GetModelID()
logger.Debug(ctx, "Using rerank model ID from test data service")
}
}
// Call service to create session
logger.Infof(ctx, "Calling session service to create session")
createdSession, err := h.sessionService.CreateSession(ctx, createdSession)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Return created session
logger.Infof(ctx, "Session created successfully, ID: %s", createdSession.ID)
c.JSON(http.StatusCreated, gin.H{
"success": true,
"data": createdSession,
})
}
// GetSession retrieves a session by its ID
func (h *SessionHandler) GetSession(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving session")
// Get session ID from URL parameter
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Session ID is empty")
c.Error(errors.NewBadRequestError(errors.ErrInvalidSessionID.Error()))
return
}
// Call service to get session details
logger.Infof(ctx, "Retrieving session, ID: %s", id)
session, err := h.sessionService.GetSession(ctx, id)
if err != nil {
if err == errors.ErrSessionNotFound {
logger.Warnf(ctx, "Session not found, ID: %s", id)
c.Error(errors.NewNotFoundError(err.Error()))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Return session data
logger.Infof(ctx, "Session retrieved successfully, ID: %s", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": session,
})
}
// GetSessionsByTenant retrieves all sessions for the current tenant with pagination
func (h *SessionHandler) GetSessionsByTenant(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving all sessions for tenant")
// Parse pagination parameters from query
var pagination types.Pagination
if err := c.ShouldBindQuery(&pagination); err != nil {
logger.Error(ctx, "Failed to parse pagination parameters", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
logger.Debugf(ctx, "Using pagination parameters: page=%d, page_size=%d", pagination.Page, pagination.PageSize)
// Use paginated query to get sessions
result, err := h.sessionService.GetPagedSessionsByTenant(ctx, &pagination)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Return sessions with pagination data
logger.Infof(ctx, "Successfully retrieved tenant sessions, total: %d", result.Total)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": result.Data,
"total": result.Total,
"page": result.Page,
"page_size": result.PageSize,
})
}
// UpdateSession updates an existing session's properties
func (h *SessionHandler) UpdateSession(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start updating session")
// Get session ID from URL parameter
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Session ID is empty")
c.Error(errors.NewBadRequestError(errors.ErrInvalidSessionID.Error()))
return
}
// Verify tenant ID from context for authorization
tenantID, exists := c.Get(types.TenantIDContextKey.String())
if !exists {
logger.Error(ctx, "Failed to get tenant ID")
c.Error(errors.NewUnauthorizedError("Unauthorized"))
return
}
// Parse request body to session object
var session types.Session
if err := c.ShouldBindJSON(&session); err != nil {
logger.Error(ctx, "Failed to parse session data", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// Set session ID and tenant ID
logger.Infof(ctx, "Updating session, ID: %s, tenant ID: %d", id, tenantID.(uint))
session.ID = id
session.TenantID = tenantID.(uint)
// Call service to update session
if err := h.sessionService.UpdateSession(ctx, &session); err != nil {
if err == errors.ErrSessionNotFound {
logger.Warnf(ctx, "Session not found, ID: %s", id)
c.Error(errors.NewNotFoundError(err.Error()))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Return updated session
logger.Infof(ctx, "Session updated successfully, ID: %s", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": session,
})
}
// DeleteSession deletes a session by its ID
func (h *SessionHandler) DeleteSession(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting session")
// Get session ID from URL parameter
id := c.Param("id")
if id == "" {
logger.Error(ctx, "Session ID is empty")
c.Error(errors.NewBadRequestError(errors.ErrInvalidSessionID.Error()))
return
}
// Call service to delete session
logger.Infof(ctx, "Deleting session, ID: %s", id)
if err := h.sessionService.DeleteSession(ctx, id); err != nil {
if err == errors.ErrSessionNotFound {
logger.Warnf(ctx, "Session not found, ID: %s", id)
c.Error(errors.NewNotFoundError(err.Error()))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Return success message
logger.Infof(ctx, "Session deleted successfully, ID: %s", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Session deleted successfully",
})
}
// GenerateTitleRequest defines the request structure for generating a session title
type GenerateTitleRequest struct {
Messages []types.Message `json:"messages" binding:"required"` // Messages to use as context for title generation
}
// GenerateTitle generates a title for a session based on message content
func (h *SessionHandler) GenerateTitle(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start generating session title")
// Get session ID from URL parameter
sessionID := c.Param("session_id")
if sessionID == "" {
logger.Error(ctx, "Session ID is empty")
c.Error(errors.NewBadRequestError(errors.ErrInvalidSessionID.Error()))
return
}
// Parse request body
var request GenerateTitleRequest
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error(ctx, "Failed to parse request data", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// Call service to generate title
logger.Infof(ctx, "Generating session title, session ID: %s, message count: %d", sessionID, len(request.Messages))
title, err := h.sessionService.GenerateTitle(ctx, sessionID, request.Messages)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Return generated title
logger.Infof(ctx, "Session title generated successfully, session ID: %s, title: %s", sessionID, title)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": title,
})
}
// CreateKnowledgeQARequest defines the request structure for knowledge QA
type CreateKnowledgeQARequest struct {
Query string `json:"query" binding:"required"` // Query text for knowledge base search
}
// SearchKnowledgeRequest defines the request structure for searching knowledge without LLM summarization
type SearchKnowledgeRequest struct {
Query string `json:"query" binding:"required"` // Query text to search for
KnowledgeBaseID string `json:"knowledge_base_id" binding:"required"` // ID of the knowledge base to search
}
// SearchKnowledge performs knowledge base search without LLM summarization
func (h *SessionHandler) SearchKnowledge(c *gin.Context) {
ctx := logger.CloneContext(c.Request.Context())
logger.Info(ctx, "Start processing knowledge search request")
// Parse request body
var request SearchKnowledgeRequest
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error(ctx, "Failed to parse request data", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// Validate request parameters
if request.Query == "" {
logger.Error(ctx, "Query content is empty")
c.Error(errors.NewBadRequestError("Query content cannot be empty"))
return
}
if request.KnowledgeBaseID == "" {
logger.Error(ctx, "Knowledge base ID is empty")
c.Error(errors.NewBadRequestError("Knowledge base ID cannot be empty"))
return
}
logger.Infof(
ctx,
"Knowledge search request, knowledge base ID: %s, query: %s",
request.KnowledgeBaseID,
request.Query,
)
// Directly call knowledge retrieval service without LLM summarization
searchResults, err := h.sessionService.SearchKnowledge(ctx, request.KnowledgeBaseID, request.Query)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge search completed, found %d results", len(searchResults))
// Return search results
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": searchResults,
})
}
// ContinueStream handles continued streaming of an active response stream
func (h *SessionHandler) ContinueStream(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start continuing stream response processing")
// Get session ID from URL parameter
sessionID := c.Param("session_id")
if sessionID == "" {
logger.Error(ctx, "Session ID is empty")
c.Error(errors.NewBadRequestError(errors.ErrInvalidSessionID.Error()))
return
}
// Get message ID from query parameter
messageID := c.Query("message_id")
if messageID == "" {
logger.Error(ctx, "Message ID is empty")
c.Error(errors.NewBadRequestError("Missing message ID"))
return
}
logger.Infof(ctx, "Continuing stream, session ID: %s, message ID: %s", sessionID, messageID)
// Verify that the session exists and belongs to this tenant
_, err := h.sessionService.GetSession(ctx, sessionID)
if err != nil {
if err == errors.ErrSessionNotFound {
logger.Warnf(ctx, "Session not found, ID: %s", sessionID)
c.Error(errors.NewNotFoundError(err.Error()))
} else {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
}
return
}
// Get the incomplete message
message, err := h.messageService.GetMessage(ctx, sessionID, messageID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
if message == nil {
logger.Warnf(ctx, "Incomplete message not found, session ID: %s, message ID: %s", sessionID, messageID)
c.JSON(http.StatusNotFound, gin.H{
"success": false,
"error": "Incomplete message not found",
})
return
}
// Get stream information
streamInfo, err := h.streamManager.GetStream(ctx, sessionID, messageID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(fmt.Sprintf("Failed to get stream data: %s", err.Error())))
return
}
if streamInfo == nil {
logger.Warnf(ctx, "Active stream not found, session ID: %s, message ID: %s", sessionID, messageID)
c.JSON(http.StatusNotFound, gin.H{
"success": false,
"error": "Active stream not found",
})
return
}
// If stream is already completed, return the full message
if streamInfo.IsCompleted {
logger.Infof(
ctx, "Stream already completed, returning directly, session ID: %s, message ID: %s", sessionID, messageID,
)
c.JSON(http.StatusOK, gin.H{
"id": message.ID,
"role": message.Role,
"content": message.Content,
"created_at": message.CreatedAt,
"done": true,
})
return
}
logger.Infof(
ctx, "Preparing to set SSE headers and send stream data, session ID: %s, message ID: %s", sessionID, messageID,
)
// Send knowledge references first if available
if len(streamInfo.KnowledgeReferences) > 0 {
logger.Debug(ctx, "Sending knowledge references")
c.SSEvent("message", &types.StreamResponse{
ID: message.RequestID,
ResponseType: types.ResponseTypeReferences,
Done: false,
KnowledgeReferences: streamInfo.KnowledgeReferences,
})
}
// Send existing content
if streamInfo.Content != "" {
logger.Debug(ctx, "Sending current existing content")
c.SSEvent("message", &types.StreamResponse{
ID: message.RequestID,
ResponseType: types.ResponseTypeAnswer,
Content: streamInfo.Content,
Done: streamInfo.IsCompleted,
})
}
// Create channels to monitor content updates
contentCh := make(chan string, 10)
doneCh := make(chan bool, 1)
logger.Debug(ctx, "Starting content update monitoring")
// Start a goroutine to monitor for content updates
go func() {
ticker := time.NewTicker(100 * time.Millisecond)
defer ticker.Stop()
currentContent := streamInfo.Content
for {
select {
case <-ticker.C:
latestStreamInfo, err := h.streamManager.GetStream(ctx, sessionID, messageID)
if err != nil {
logger.Errorf(ctx, "Failed to get stream data: %v", err)
doneCh <- true
return
}
if latestStreamInfo == nil {
logger.Debug(ctx, "Stream no longer exists")
doneCh <- true
return
}
if latestStreamInfo.IsCompleted {
logger.Debug(ctx, "Stream completed")
doneCh <- true
return
}
// Calculate new content delta
if len(latestStreamInfo.Content) > len(currentContent) {
newContent := latestStreamInfo.Content[len(currentContent):]
contentCh <- newContent
currentContent = latestStreamInfo.Content
logger.Debugf(ctx, "Sending new content: %d bytes", len(newContent))
}
case <-c.Request.Context().Done():
logger.Debug(ctx, "Client connection closed")
return
}
}
}()
logger.Info(ctx, "Starting stream response")
// Stream updated content to client
c.Stream(func(w io.Writer) bool {
select {
case <-c.Request.Context().Done():
logger.Debug(ctx, "Client connection closed")
return false
case <-doneCh:
logger.Debug(ctx, "Stream completed, sending completion notification")
c.SSEvent("message", &types.StreamResponse{
ID: message.RequestID,
ResponseType: types.ResponseTypeAnswer,
Content: "",
Done: true,
})
return false
case content := <-contentCh:
logger.Debugf(ctx, "Sending content fragment: %d bytes", len(content))
c.SSEvent("message", &types.StreamResponse{
ID: message.RequestID,
ResponseType: types.ResponseTypeAnswer,
Content: content,
Done: false,
})
return true
}
})
}
// KnowledgeQA handles knowledge base question answering requests with LLM summarization
func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
ctx := logger.CloneContext(c.Request.Context())
logger.Info(ctx, "Start processing knowledge QA request")
// Get session ID from URL parameter
sessionID := c.Param("session_id")
if sessionID == "" {
logger.Error(ctx, "Session ID is empty")
c.Error(errors.NewBadRequestError(errors.ErrInvalidSessionID.Error()))
return
}
// Parse request body
var request CreateKnowledgeQARequest
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error(ctx, "Failed to parse request data", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// Create assistant message
assistantMessage := &types.Message{
SessionID: sessionID,
Role: "assistant",
RequestID: c.GetString(types.RequestIDContextKey.String()),
IsCompleted: false,
}
defer h.completeAssistantMessage(ctx, assistantMessage)
// Validate query content
if request.Query == "" {
logger.Error(ctx, "Query content is empty")
c.Error(errors.NewBadRequestError("Query content cannot be empty"))
return
}
logger.Infof(ctx, "Knowledge QA request, session ID: %s, query: %s", sessionID, request.Query)
// Create user message
if _, err := h.messageService.CreateMessage(ctx, &types.Message{
SessionID: sessionID,
Role: "user",
Content: request.Query,
RequestID: c.GetString(types.RequestIDContextKey.String()),
CreatedAt: time.Now(),
IsCompleted: true,
}); err != nil {
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Create assistant message (response)
assistantMessage.CreatedAt = time.Now()
if _, err := h.messageService.CreateMessage(ctx, assistantMessage); err != nil {
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Calling knowledge QA service, session ID: %s", sessionID)
// Call service to perform knowledge QA
searchResults, respCh, err := h.sessionService.KnowledgeQA(ctx, sessionID, request.Query)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
assistantMessage.KnowledgeReferences = searchResults
// Register new stream with stream manager
requestID := c.GetString(types.RequestIDContextKey.String())
if err := h.streamManager.RegisterStream(ctx, sessionID, assistantMessage.ID, request.Query); err != nil {
logger.GetLogger(ctx).Error("Register stream failed", "error", err)
}
// Send knowledge references if available
if len(searchResults) > 0 {
logger.Debugf(ctx, "Sending reference content, total %d", len(searchResults))
c.SSEvent("message", &types.StreamResponse{
ID: requestID,
ResponseType: types.ResponseTypeReferences,
KnowledgeReferences: searchResults,
})
c.Writer.Flush()
} else {
logger.Debug(ctx, "No reference content to send")
}
// Process streamed response
func() {
defer func() {
// Mark stream as completed when done
if err := h.streamManager.CompleteStream(ctx, sessionID, assistantMessage.ID); err != nil {
logger.GetLogger(ctx).Error("Complete stream failed", "error", err)
}
}()
for response := range respCh {
response.ID = requestID
c.SSEvent("message", response)
c.Writer.Flush()
if response.ResponseType == types.ResponseTypeAnswer {
assistantMessage.Content += response.Content
// Update stream manager with new content
if err := h.streamManager.UpdateStream(
ctx, sessionID, assistantMessage.ID, response.Content, searchResults,
); err != nil {
logger.GetLogger(ctx).Error("Update stream content failed", "error", err)
}
}
}
}()
}
// completeAssistantMessage marks an assistant message as complete and updates it
func (h *SessionHandler) completeAssistantMessage(ctx context.Context, assistantMessage *types.Message) {
assistantMessage.UpdatedAt = time.Now()
assistantMessage.IsCompleted = true
_ = h.messageService.UpdateMessage(ctx, assistantMessage)
}
+226
View File
@@ -0,0 +1,226 @@
package handler
import (
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
// TenantHandler implements HTTP request handlers for tenant management
// Provides functionality for creating, retrieving, updating, and deleting tenants
// through the REST API endpoints
type TenantHandler struct {
service interfaces.TenantService
}
// NewTenantHandler creates a new tenant handler instance with the provided service
// Parameters:
// - service: An implementation of the TenantService interface for business logic
//
// Returns a pointer to the newly created TenantHandler
func NewTenantHandler(service interfaces.TenantService) *TenantHandler {
return &TenantHandler{
service: service,
}
}
// CreateTenant handles the HTTP request for creating a new tenant
// It deserializes the request body into a tenant object, validates it,
// calls the service to create the tenant, and returns the result
// Parameters:
// - c: Gin context for the HTTP request
func (h *TenantHandler) CreateTenant(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start creating tenant")
var tenantData types.Tenant
if err := c.ShouldBindJSON(&tenantData); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
appErr := errors.NewValidationError("Invalid request parameters").WithDetails(err.Error())
c.Error(appErr)
return
}
logger.Infof(ctx, "Creating tenant, name: %s", tenantData.Name)
createdTenant, err := h.service.CreateTenant(ctx, &tenantData)
if err != nil {
// Check if this is an application-specific error
if appErr, ok := errors.IsAppError(err); ok {
logger.Error(ctx, "Failed to create tenant: application error", appErr)
c.Error(appErr)
} else {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Failed to create tenant").WithDetails(err.Error()))
}
return
}
logger.Infof(ctx, "Tenant created successfully, ID: %d, name: %s", createdTenant.ID, createdTenant.Name)
c.JSON(http.StatusCreated, gin.H{
"success": true,
"data": createdTenant,
})
}
// GetTenant handles the HTTP request for retrieving a tenant by ID
// It extracts and validates the tenant ID from the URL parameter,
// retrieves the tenant from the service, and returns it in the response
// Parameters:
// - c: Gin context for the HTTP request
func (h *TenantHandler) GetTenant(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving tenant")
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
logger.Errorf(ctx, "Invalid tenant ID: %s", c.Param("id"))
c.Error(errors.NewBadRequestError("Invalid tenant ID"))
return
}
logger.Infof(ctx, "Retrieving tenant, ID: %d", id)
tenant, err := h.service.GetTenantByID(ctx, uint(id))
if err != nil {
// Check if this is an application-specific error
if appErr, ok := errors.IsAppError(err); ok {
logger.Error(ctx, "Failed to retrieve tenant: application error", appErr)
c.Error(appErr)
} else {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Failed to retrieve tenant").WithDetails(err.Error()))
}
return
}
logger.Infof(ctx, "Retrieved tenant successfully, ID: %d, Name: %s", tenant.ID, tenant.Name)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": tenant,
})
}
// UpdateTenant handles the HTTP request for updating an existing tenant
// It extracts the tenant ID from the URL parameter, deserializes the request body,
// validates the data, updates the tenant through the service, and returns the result
// Parameters:
// - c: Gin context for the HTTP request
func (h *TenantHandler) UpdateTenant(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start updating tenant")
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
logger.Errorf(ctx, "Invalid tenant ID: %s", c.Param("id"))
c.Error(errors.NewBadRequestError("Invalid tenant ID"))
return
}
var tenantData types.Tenant
if err := c.ShouldBindJSON(&tenantData); err != nil {
logger.Error(ctx, "Failed to parse request parameters", err)
c.Error(errors.NewValidationError("Invalid request data").WithDetails(err.Error()))
return
}
logger.Infof(ctx, "Updating tenant, ID: %d, Name: %s", id, tenantData.Name)
tenantData.ID = uint(id)
updatedTenant, err := h.service.UpdateTenant(ctx, &tenantData)
if err != nil {
// Check if this is an application-specific error
if appErr, ok := errors.IsAppError(err); ok {
logger.Error(ctx, "Failed to update tenant: application error", appErr)
c.Error(appErr)
} else {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Failed to update tenant").WithDetails(err.Error()))
}
return
}
logger.Infof(ctx, "Tenant updated successfully, ID: %d, Name: %s", updatedTenant.ID, updatedTenant.Name)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": updatedTenant,
})
}
// DeleteTenant handles the HTTP request for deleting a tenant
// It extracts and validates the tenant ID from the URL parameter,
// calls the service to delete the tenant, and returns the result
// Parameters:
// - c: Gin context for the HTTP request
func (h *TenantHandler) DeleteTenant(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start deleting tenant")
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
logger.Errorf(ctx, "Invalid tenant ID: %s", c.Param("id"))
c.Error(errors.NewBadRequestError("Invalid tenant ID"))
return
}
logger.Infof(ctx, "Deleting tenant, ID: %d", id)
if err := h.service.DeleteTenant(ctx, uint(id)); err != nil {
// Check if this is an application-specific error
if appErr, ok := errors.IsAppError(err); ok {
logger.Error(ctx, "Failed to delete tenant: application error", appErr)
c.Error(appErr)
} else {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Failed to delete tenant").WithDetails(err.Error()))
}
return
}
logger.Infof(ctx, "Tenant deleted successfully, ID: %d", id)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "Tenant deleted successfully",
})
}
// ListTenants handles the HTTP request for retrieving a list of all tenants
// It calls the service to fetch the tenant list and returns it in the response
// Parameters:
// - c: Gin context for the HTTP request
func (h *TenantHandler) ListTenants(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving tenant list")
tenants, err := h.service.ListTenants(ctx)
if err != nil {
// Check if this is an application-specific error
if appErr, ok := errors.IsAppError(err); ok {
logger.Error(ctx, "Failed to retrieve tenant list: application error", appErr)
c.Error(appErr)
} else {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Failed to retrieve tenant list").WithDetails(err.Error()))
}
return
}
logger.Infof(ctx, "Retrieved tenant list successfully, Total: %d tenants", len(tenants))
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"items": tenants,
},
})
}
+108
View File
@@ -0,0 +1,108 @@
package handler
import (
"errors"
"net/http"
"os"
"strconv"
"github.com/gin-gonic/gin"
"github.com/Tencent/WeKnora/internal/config"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
// TestDataHandler handles HTTP requests related to test data operations
// Used for development and testing purposes to provide sample data
type TestDataHandler struct {
config *config.Config
kbService interfaces.KnowledgeBaseService
tenantService interfaces.TenantService
}
// NewTestDataHandler creates a new instance of the test data handler
// Parameters:
// - config: Application configuration instance
// - kbService: Knowledge base service for accessing knowledge base data
// - tenantService: Tenant service for accessing tenant data
//
// Returns a pointer to the new TestDataHandler instance
func NewTestDataHandler(
config *config.Config,
kbService interfaces.KnowledgeBaseService,
tenantService interfaces.TenantService,
) *TestDataHandler {
return &TestDataHandler{
config: config,
kbService: kbService,
tenantService: tenantService,
}
}
// GetTestData handles the HTTP request to retrieve test data for development purposes
// It returns predefined test tenant and knowledge base information
// This endpoint is only available in non-production environments
// Parameters:
// - c: Gin context for the HTTP request
func (h *TestDataHandler) GetTestData(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Start retrieving test data")
// Check if we're running in release/production mode
if gin.Mode() == gin.ReleaseMode {
logger.Warn(ctx, "Attempting to retrieve test data in production mode")
c.Error(errors.New("This API is only available in development mode"))
return
}
// Check if test data environment variables are configured
if os.Getenv("INIT_TEST_TENANT_ID") == "" || os.Getenv("INIT_TEST_KNOWLEDGE_BASE_ID") == "" {
logger.Warn(ctx, "Test data environment variables not set")
c.Error(errors.New("Test data not enabled"))
return
}
tenantID := os.Getenv("INIT_TEST_TENANT_ID")
logger.Debugf(ctx, "Test tenant ID environment variable: %s", tenantID)
tenantIDUint, err := strconv.ParseUint(tenantID, 10, 64)
if err != nil {
logger.Errorf(ctx, "Failed to parse tenant ID: %s", tenantID)
c.Error(err)
return
}
// Retrieve the test tenant data
logger.Infof(ctx, "Retrieving test tenant, ID: %d", tenantIDUint)
tenant, err := h.tenantService.GetTenantByID(ctx, uint(tenantIDUint))
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(err)
return
}
knowledgeBaseID := os.Getenv("INIT_TEST_KNOWLEDGE_BASE_ID")
logger.Debugf(ctx, "Test knowledge base ID environment variable: %s", knowledgeBaseID)
// Retrieve the test knowledge base data
logger.Infof(ctx, "Retrieving test knowledge base, ID: %s", knowledgeBaseID)
knowledgeBase, err := h.kbService.GetKnowledgeBaseByID(ctx, knowledgeBaseID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(err)
return
}
logger.Info(ctx, "Test data retrieved successfully")
// Return the test data in the response
c.JSON(http.StatusOK, gin.H{
"data": gin.H{
"tenant": tenant,
"knowledge_bases": []types.KnowledgeBase{*knowledgeBase},
},
"success": true,
})
}