init commit
This commit is contained in:
@@ -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",
|
||||
})
|
||||
}
|
||||
@@ -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,
|
||||
})
|
||||
}
|
||||
@@ -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",
|
||||
})
|
||||
}
|
||||
@@ -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",
|
||||
})
|
||||
}
|
||||
@@ -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",
|
||||
})
|
||||
}
|
||||
@@ -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",
|
||||
})
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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,
|
||||
},
|
||||
})
|
||||
}
|
||||
@@ -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,
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user