Skip to content

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

Refactor: refine response data (#21858)

Wang Qia26066c879d9
diff --git a/docs/references/http_api_reference.md b/docs/references/http_api_reference.md
index b32c6efc19..f8ce271503 100644
--- a/docs/references/http_api_reference.md
+++ b/docs/references/http_api_reference.md
@@ -11,6 +11,9 @@ A complete reference for RAGFlow's RESTful API, including migration notes for RA
In the standard response envelope, `message` is always a non-empty string. Successful responses default to `"success"`; error responses contain a description of the error.
+`data` is optional. Operation acknowledgments omit it; check `code` for success
+and `message` for the result description. Result payloads use objects or arrays.
+
---
## ERROR CODES
@@ -1687,7 +1690,7 @@ Success:
```json
{
"code": 0,
- "data": true
+ "message": "success"
}
```
@@ -2076,10 +2079,14 @@ Success:
```json
{
- "code": 0
+ "code": 0,
+ "message": "success",
+ "data": {"deleted_count": 1}
}
```
+`data.deleted_count` is the number of chunks deleted. It is `0` when no chunks matched the request.
+
Failure:
```json
@@ -2236,7 +2243,7 @@ Success:
```json
{
"code": 0,
- "data": true
+ "message": "success"
}
```
@@ -3073,7 +3080,7 @@ Success:
```json
{
"code": 0,
- "data": true
+ "message": "success"
}
```
@@ -5195,7 +5202,6 @@ Failure:
```json
{
"code": 401,
- "data": null,
"message": "<Unauthorized '401: Unauthorized'>"
}
```
@@ -5353,7 +5359,10 @@ Success:
```json
{
"code": 0,
- "data": true,
+ "data": {
+ "id": "58af890a2a8911f0a71a11b922ed82d6",
+ "title": "Test Agent"
+ },
"message": "success"
}
```
@@ -5423,7 +5432,7 @@ Success:
```json
{
"code": 0,
- "data": true,
+ "data": {"update_time": 1720000000000},
"message": "success"
}
```
@@ -5484,7 +5493,6 @@ Success:
```json
{
"code": 0,
- "data": true,
"message": "success"
}
```
@@ -5538,7 +5546,6 @@ Success:
```json
{
"code": 0,
- "data": true,
"message": "success"
}
```
@@ -5591,7 +5598,6 @@ Success:
```json
{
"code": 0,
- "data": true,
"message": "success"
}
```
@@ -5990,7 +5996,6 @@ Failure
```json
{
"code": 404,
- "data": null,
"message": "Memory '{memory_id}' not found."
}
```
@@ -6032,7 +6037,6 @@ Success
```json
{
"code": 0,
- "data": null,
"message": "success"
}
```
@@ -6042,7 +6046,6 @@ Failure
```json
{
"code": 404,
- "data": null,
"message": "Resource not found"
}
```
@@ -6171,7 +6174,6 @@ Failure
```
{
"code": 404,
- "data": null,
"message": "Memory '{memory_id}' not found."
}
```
@@ -6249,7 +6251,6 @@ Success
```json
{
"code": 0,
- "data": null,
"message": "All add to task."
}
```
@@ -6259,7 +6260,6 @@ Failure
```json
{
"code": 500,
- "data": null,
"message": "Some messages failed to add. Detail: {fail information}"
}
```
@@ -6304,7 +6304,6 @@ Success
```json
{
"code": 0,
- "data": null,
"message": "success"
}
```
@@ -6314,7 +6313,6 @@ Failure
```json
{
"code": 404,
- "data": null,
"message": "Memory '{memory_id}' not found."
}
```
@@ -6369,7 +6367,6 @@ Success
```json
{
"code": 0,
- "data": null,
"message": "success"
}
```
@@ -6379,7 +6376,6 @@ Failure
```json
{
"code": 404,
- "data": null,
"message": "Memory '{memory_id}' not found."
}
```
@@ -6627,7 +6623,6 @@ Failure
```json
{
"code": 404,
- "data": null,
"message": "Memory '{memory_id}' not found."
}
```
@@ -7394,7 +7389,7 @@ Success:
```json
{
"code": 0,
- "data": true
+ "message": "success"
}
```
@@ -8349,7 +8344,7 @@ Success:
```json
{
"code": 0,
- "data": true
+ "message": "success"
}
```
diff --git a/internal/admin/handler.go b/internal/admin/handler.go
index 6bc20dde6a..0edf5e1f20 100644
--- a/internal/admin/handler.go
+++ b/internal/admin/handler.go
@@ -61,20 +61,20 @@ type ErrorResponse struct {
func (h *Handler) Healthz(c *gin.Context) {
result, allOK := service.GetComponentsHealthz(c.Request.Context())
if allOK {
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
} else {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, result, "")
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, result, "")
}
}
// Live endpoint
func (h *Handler) Live(c *gin.Context) {
- common.SuccessNoData(c, "")
+ common.RespondSuccess(c, nil, "")
}
// Ping ping endpoint
func (h *Handler) Ping(c *gin.Context) {
- common.SuccessNoData(c, "pong")
+ common.RespondSuccess(c, nil, "pong")
}
// Login handle admin login
@@ -90,7 +90,7 @@ func (h *Handler) Login(c *gin.Context) {
ctx := c.Request.Context()
var req service.EmailLoginRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
return
}
@@ -98,25 +98,25 @@ func (h *Handler) Login(c *gin.Context) {
// This allows default admin account to log in admin system
user, code, err := h.userService.LoginByEmail(ctx, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
// Check if user is superuser (admin)
if user.IsSuperuser == nil || !*user.IsSuperuser {
- common.ErrorWithCode(c, common.CodeForbidden, "Only superuser can login admin system")
+ common.RespondError(c, common.CodeForbidden, "Only superuser can login admin system")
return
}
secretKey, err := server.GetSecretKey(ctx, kvrocks.Get())
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, fmt.Sprintf("Failed to get secret key: %s", err.Error()))
+ common.RespondError(c, common.CodeServerError, fmt.Sprintf("Failed to get secret key: %s", err.Error()))
return
}
authToken, err := common.DumpAccessToken(*user.AccessToken, "", secretKey)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, fmt.Sprintf("Failed to generate auth token: %s", err.Error()))
+ common.RespondError(c, common.CodeServerError, fmt.Sprintf("Failed to generate auth token: %s", err.Error()))
return
}
@@ -128,29 +128,29 @@ func (h *Handler) Login(c *gin.Context) {
c.Header("Access-Control-Allow-Headers", "*")
c.Header("Access-Control-Expose-Headers", "Authorization")
- common.SuccessWithData(c, user, "Welcome back!")
+ common.RespondSuccess(c, user, "Welcome back!")
}
// Logout handle logout
func (h *Handler) Logout(c *gin.Context) {
user, exists := c.Get("user")
if !exists {
- common.ErrorWithCode(c, common.CodeUnauthorized, "Not authenticated")
+ common.RespondError(c, common.CodeUnauthorized, "Not authenticated")
return
}
ctx := c.Request.Context()
if err := h.service.Logout(ctx, user); err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessNoData(c, "Logout successful")
+ common.RespondSuccess(c, nil, "Logout successful")
}
// AuthCheck check admin auth
func (h *Handler) AuthCheck(c *gin.Context) {
- common.SuccessNoData(c, "Admin is authorized")
+ common.RespondSuccess(c, nil, "Admin is authorized")
}
// ListUsers handle list users
@@ -163,18 +163,18 @@ func (h *Handler) ListUsers(c *gin.Context) {
orderBy := c.DefaultQuery("order", "") // order by field
pageInt, err := common.ParseRequestIntPositive(c, c.Query("page"), "page", 1)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
pageSizeInt, err := common.ParseRequestIntPositive(c, c.Query("page_size"), "page_size", 10)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
plan := c.Query("plan") // plan name
topInt, err := common.ParseRequestIntPositive(c, c.Query("top"), "top", 0)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if !validateAdminUserListPagination(c, pageInt, pageSizeInt, topInt) {
@@ -187,18 +187,18 @@ func (h *Handler) ListUsers(c *gin.Context) {
if quotaStr := c.Query("quota"); quotaStr != "" {
q, err := common.ParseRequestIntPositive(c, quotaStr, "quota", 0)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if q > 100 {
- common.ErrorWithCode(c, common.CodeBadRequest, "Quota must be less than or equal to 100")
+ common.RespondError(c, common.CodeBadRequest, "Quota must be less than or equal to 100")
return
}
quotaPtr = &q
}
daysInt, err := common.ParseRequestIntPositive(c, c.Query("days"), "days", 0)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -211,39 +211,39 @@ func (h *Handler) ListUsers(c *gin.Context) {
case common.EnterpriseEdition:
users, total, err = h.service.ListUsersEE(ctx, pageInt, pageSizeInt, name, status, role, sort, orderBy, plan, topInt, daysInt, quotaPtr)
default:
- common.ErrorWithCode(c, common.CodeBadRequest, "Invalid RAGFlow type")
+ common.RespondError(c, common.CodeBadRequest, "Invalid RAGFlow type")
return
}
if errors.Is(err, errInvalidUserListQuery) {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithDataAndTotal(c, users, total, "List users")
+ common.RespondSuccessList(c, users, "List users", total)
}
func validateAdminUserListPagination(c *gin.Context, page, pageSize, top int) bool {
if page < 1 || pageSize < 1 {
- common.ErrorWithCode(c, common.CodeBadRequest, "page and page_size must be positive integers")
+ common.RespondError(c, common.CodeBadRequest, "page and page_size must be positive integers")
return false
}
query := c.Request.URL.Query()
if query.Has("top") {
if top < 1 {
- common.ErrorWithCode(c, common.CodeBadRequest, "top must be a positive integer")
+ common.RespondError(c, common.CodeBadRequest, "top must be a positive integer")
return false
}
if query.Has("page") || query.Has("page_size") {
- common.ErrorWithCode(c, common.CodeBadRequest, "top cannot be combined with page or page_size")
+ common.RespondError(c, common.CodeBadRequest, "top cannot be combined with page or page_size")
return false
}
switch strings.ToLower(strings.TrimSpace(c.Query("order"))) {
case "storage", "documents", "index":
default:
- common.ErrorWithCode(c, common.CodeBadRequest, "top is only supported for storage, documents and index")
+ common.RespondError(c, common.CodeBadRequest, "top is only supported for storage, documents and index")
return false
}
}
@@ -261,7 +261,7 @@ type CreateUserHTTPRequest struct {
func (h *Handler) CreateUser(c *gin.Context) {
var req CreateUserHTTPRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, "Username and password are required")
+ common.RespondError(c, common.CodeBadRequest, "Username and password are required")
return
}
@@ -272,18 +272,18 @@ func (h *Handler) CreateUser(c *gin.Context) {
userInfo, err := h.service.CreateUser(ctx, req.Username, req.Password, req.Role)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, userInfo, "User created successfully")
+ common.RespondSuccess(c, userInfo, "User created successfully")
}
func getUserName(c *gin.Context) (string, error) {
username := c.Param("username")
if username == "" {
err := errors.New("username is required")
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return "", err
}
return username, nil
@@ -299,14 +299,14 @@ func (h *Handler) GetUser(c *gin.Context) {
userDetails, err := h.service.GetUserDetails(c.Request.Context(), username)
if err != nil {
if errors.Is(err, common.ErrUserNotFound) {
- common.ErrorWithCode(c, common.CodeNotFound, "User not found")
+ common.RespondError(c, common.CodeNotFound, "User not found")
return
}
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, []map[string]interface{}{userDetails}, "")
+ common.RespondSuccessList(c, []map[string]interface{}{userDetails}, "")
}
// DeleteUser handle delete user
@@ -318,7 +318,7 @@ func (h *Handler) DeleteUser(c *gin.Context) {
result, err := h.service.DeleteUser(c.Request.Context(), username)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
@@ -327,7 +327,7 @@ func (h *Handler) DeleteUser(c *gin.Context) {
detailsMsg += detail + "\n"
}
- common.SuccessNoData(c, detailsMsg)
+ common.RespondSuccess(c, nil, detailsMsg)
}
// ChangePasswordHTTPRequest change password request
@@ -344,17 +344,17 @@ func (h *Handler) ChangePassword(c *gin.Context) {
var req ChangePasswordHTTPRequest
if err = c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, "New password is required")
+ common.RespondError(c, common.CodeBadRequest, "New password is required")
return
}
ctx := c.Request.Context()
if err = h.service.ChangePassword(ctx, username, req.NewPassword); err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessNoData(c, "Password updated successfully")
+ common.RespondSuccess(c, nil, "Password updated successfully")
}
// UpdateActivateStatusHTTPRequest update activate status request
@@ -371,23 +371,23 @@ func (h *Handler) UpdateUserActivateStatus(c *gin.Context) {
var req UpdateActivateStatusHTTPRequest
if err = c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, "Activation status is required")
+ common.RespondError(c, common.CodeBadRequest, "Activation status is required")
return
}
if req.ActivateStatus != "on" && req.ActivateStatus != "off" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Activation status must be 'on' or 'off'")
+ common.RespondError(c, common.CodeBadRequest, "Activation status must be 'on' or 'off'")
return
}
isActive := req.ActivateStatus == "on"
ctx := c.Request.Context()
if err = h.service.UpdateUserActivateStatus(ctx, username, isActive); err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessNoData(c, "Activation status updated")
+ common.RespondSuccess(c, nil, "Activation status updated")
}
// GrantAdmin handle grant admin role
@@ -400,17 +400,17 @@ func (h *Handler) GrantAdmin(c *gin.Context) {
// Get current user email from context
email, _ := c.Get("email")
if email != nil && email.(string) == username {
- common.ErrorWithCode(c, common.CodeConflict, "can't grant current user: "+username)
+ common.RespondError(c, common.CodeConflict, "can't grant current user: "+username)
return
}
ctx := c.Request.Context()
if err = h.service.GrantAdmin(ctx, username); err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessNoData(c, "Admin role granted")
+ common.RespondSuccess(c, nil, "Admin role granted")
}
// RevokeAdmin handle revoke admin role
@@ -423,17 +423,17 @@ func (h *Handler) RevokeAdmin(c *gin.Context) {
// Get current user email from context
email, _ := c.Get("email")
if email != nil && email.(string) == username {
- common.ErrorWithCode(c, common.CodeConflict, "can't revoke current user: "+username)
+ common.RespondError(c, common.CodeConflict, "can't revoke current user: "+username)
return
}
ctx := c.Request.Context()
if err = h.service.RevokeAdmin(ctx, username); err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessNoData(c, "Admin role revoked")
+ common.RespondSuccess(c, nil, "Admin role revoked")
}
// ListUserAPITokens handle get user API keys
@@ -446,11 +446,11 @@ func (h *Handler) ListUserAPITokens(c *gin.Context) {
ctx := c.Request.Context()
apiKeys, err := h.service.ListUserAPITokens(ctx, username)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, apiKeys, "Get user API keys")
+ common.RespondSuccessList(c, apiKeys, "Get user API keys")
}
// GenerateUserAPIToken handle generate user API key
@@ -463,11 +463,11 @@ func (h *Handler) GenerateUserAPIToken(c *gin.Context) {
ctx := c.Request.Context()
apiKey, err := h.service.GenerateUserAPIToken(ctx, username)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, apiKey, "API key generated successfully")
+ common.RespondSuccess(c, apiKey, "API key generated successfully")
}
// DeleteUserAPIToken handle delete user API key
@@ -478,17 +478,17 @@ func (h *Handler) DeleteUserAPIToken(c *gin.Context) {
}
key := c.Param("token")
if key == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Username and key are required")
+ common.RespondError(c, common.CodeBadRequest, "Username and key are required")
return
}
ctx := c.Request.Context()
if err = h.service.DeleteUserAPIToken(ctx, username, key); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
- common.SuccessNoData(c, "API key deleted successfully")
+ common.RespondSuccess(c, nil, "API key deleted successfully")
}
// GetServices handle get all services
@@ -496,104 +496,104 @@ func (h *Handler) GetServices(c *gin.Context) {
ctx := c.Request.Context()
services, err := h.service.ListServices(ctx)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeBadRequest, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeBadRequest, nil, err.Error())
return
}
- common.SuccessWithData(c, services, "Get all services")
+ common.RespondSuccessList(c, services, "Get all services")
}
// GetServicesByType handle get services by type
func (h *Handler) GetServicesByType(c *gin.Context) {
serviceType := c.Param("service_type")
if serviceType == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Service type is required")
+ common.RespondError(c, common.CodeBadRequest, "Service type is required")
return
}
services, err := h.service.GetServicesByType(serviceType)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, services, "")
+ common.RespondSuccessList(c, services, "")
}
// GetService handle get service details
func (h *Handler) GetService(c *gin.Context) {
serviceName := c.Param("service_name")
if serviceName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Service name is required")
+ common.RespondError(c, common.CodeBadRequest, "Service name is required")
return
}
ctx := c.Request.Context()
services, err := h.service.ListServices(ctx)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
for _, serviceInstance := range services {
if serviceInstance.Name == serviceName {
- common.SuccessWithData(c, serviceInstance, "")
+ common.RespondSuccess(c, serviceInstance, "")
return
}
}
- common.ErrorWithCode(c, common.CodeNotFound, "Service not found")
+ common.RespondError(c, common.CodeNotFound, "Service not found")
}
// ShutdownService handle shutdown service
func (h *Handler) ShutdownService(c *gin.Context) {
serviceName := c.Param("service_name")
if serviceName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Service name is required")
+ common.RespondError(c, common.CodeBadRequest, "Service name is required")
return
}
result, err := h.service.ShutdownService(serviceName)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, result, "")
+ common.RespondSuccess(c, result, "")
}
// StartService handle start service
func (h *Handler) StartService(c *gin.Context) {
serviceName := c.Param("service_name")
if serviceName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Service name is required")
+ common.RespondError(c, common.CodeBadRequest, "Service name is required")
return
}
result, err := h.service.StartService(serviceName)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, result, "")
+ common.RespondSuccess(c, result, "")
}
// RestartService handle restart service
func (h *Handler) RestartService(c *gin.Context) {
serviceName := c.Param("service_name")
if serviceName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Service name is required")
+ common.RespondError(c, common.CodeBadRequest, "Service name is required")
return
}
result, err := h.service.RestartService(serviceName)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, result, "")
+ common.RespondSuccess(c, result, "")
}
// ListVariables handle list variables
@@ -604,10 +604,10 @@ func (h *Handler) ListVariables(c *gin.Context) {
// List all variables
variables, err := h.service.ListAllVariables(ctx)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, variables, "")
+ common.RespondSuccessList(c, variables, "")
return
}
@@ -616,22 +616,22 @@ func (h *Handler) ListVariables(c *gin.Context) {
VarName string `json:"var_name"`
}
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, "Invalid request body")
+ common.RespondError(c, common.CodeBadRequest, "Invalid request body")
return
}
if req.VarName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
+ common.RespondError(c, common.CodeBadRequest, "Var name is required")
return
}
variable, err := h.service.GetVariable(ctx, req.VarName)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, variable, "")
+ common.RespondSuccessList(c, variable, "")
}
// ShowVariable handle show variable
@@ -639,22 +639,22 @@ func (h *Handler) ShowVariable(c *gin.Context) {
encodedVarName := c.Param("var_name")
varName, err := common.DecodeFromBase64(encodedVarName)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if varName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
+ common.RespondError(c, common.CodeBadRequest, "Var name is required")
return
}
ctx := c.Request.Context()
variable, err := h.service.GetVariable(ctx, varName)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, variable, "")
+ common.RespondSuccessList(c, variable, "")
}
// SetVariableHTTPRequest set variable request
@@ -707,28 +707,28 @@ func (r SetVariableHTTPRequest) flattenedVariableValue() (string, error) {
func (h *Handler) SetVariable(c *gin.Context) {
var req SetVariableHTTPRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, "Invalid request body: "+err.Error())
+ common.RespondError(c, common.CodeBadRequest, "Invalid request body: "+err.Error())
return
}
if req.VarName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
+ common.RespondError(c, common.CodeBadRequest, "Var name is required")
return
}
varValue, err := req.flattenedVariableValue()
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
ctx := c.Request.Context()
if err := h.service.SetVariable(ctx, req.VarName, varValue); err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessNoData(c, "Set variable successfully")
+ common.RespondSuccess(c, nil, "Set variable successfully")
}
// ListConfigs returns configurations, including plaintext credentials, for
@@ -736,28 +736,28 @@ func (h *Handler) SetVariable(c *gin.Context) {
func (h *Handler) ListConfigs(c *gin.Context) {
configs, err := h.service.ListAllConfigs()
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, configs, "")
+ common.RespondSuccessList(c, configs, "")
}
// ListEnvironments handle list environments
func (h *Handler) ListEnvironments(c *gin.Context) {
environments, err := h.service.ListEnvironments()
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, environments, "")
+ common.RespondSuccessList(c, environments, "")
}
// GetVersion handle get version
func (h *Handler) GetVersion(c *gin.Context) {
version, versionType := h.service.GetVersion()
- common.SuccessWithData(c, gin.H{"version": version, "version_type": versionType}, "")
+ common.RespondSuccess(c, gin.H{"version": version, "version_type": versionType}, "")
}
// ListSandboxProviders handle list sandbox providers
@@ -768,14 +768,14 @@ func (h *Handler) ListSandboxProviders(c *gin.Context) {
return
}
- common.SuccessWithData(c, providers, "")
+ common.RespondSuccessList(c, providers, "")
}
// GetSandboxProviderSchema handle get sandbox provider schema
func (h *Handler) GetSandboxProviderSchema(c *gin.Context) {
providerID := c.Param("provider_id")
if providerID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Provider ID is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Provider ID is required")
return
}
@@ -785,7 +785,7 @@ func (h *Handler) GetSandboxProviderSchema(c *gin.Context) {
return
}
- common.SuccessWithData(c, schema, "")
+ common.RespondSuccess(c, schema, "")
}
// GetSandboxConfig handle get sandbox config
@@ -796,7 +796,7 @@ func (h *Handler) GetSandboxConfig(c *gin.Context) {
return
}
- common.SuccessWithData(c, config, "")
+ common.RespondSuccess(c, config, "")
}
// SetSandboxConfigHTTPRequest set sandbox config request
@@ -810,12 +810,12 @@ type SetSandboxConfigHTTPRequest struct {
func (h *Handler) SetSandboxConfig(c *gin.Context) {
var req SetSandboxConfigHTTPRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid JSON request: provider_type must be a nonempty string, config an object, and set_active a boolean")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid JSON request: provider_type must be a nonempty string, config an object, and set_active a boolean")
return
}
if req.ProviderType == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Provider type is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Provider type is required")
return
}
@@ -826,7 +826,7 @@ func (h *Handler) SetSandboxConfig(c *gin.Context) {
return
}
- common.SuccessWithData(c, result, "Sandbox configuration updated successfully")
+ common.RespondSuccess(c, result, "Sandbox configuration updated successfully")
}
// TestSandboxConnectionHTTPRequest test sandbox connection request
@@ -839,12 +839,12 @@ type TestSandboxConnectionHTTPRequest struct {
func (h *Handler) TestSandboxConnection(c *gin.Context) {
var req TestSandboxConnectionHTTPRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid JSON request: provider_type must be a nonempty string and config an object")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid JSON request: provider_type must be a nonempty string and config an object")
return
}
if req.ProviderType == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Provider type is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Provider type is required")
return
}
@@ -854,20 +854,20 @@ func (h *Handler) TestSandboxConnection(c *gin.Context) {
return
}
if success, ok := result["success"].(bool); ok && !success {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, result, "Sandbox connection test failed")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, result, "Sandbox connection test failed")
return
}
- common.SuccessWithData(c, result, "")
+ common.RespondSuccess(c, result, "")
}
func writeSandboxError(c *gin.Context, err error) {
var coded *common.CodedError
if errors.As(err, &coded) {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, coded.Code, nil, coded.Message)
+ common.Respond(c, http.StatusBadRequest, coded.Code, nil, coded.Message)
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
}
// AuthMiddleware authenticates system administrators for admin routes.
@@ -876,7 +876,7 @@ func (h *Handler) AuthMiddleware() gin.HandlerFunc {
ctx := c.Request.Context()
token := c.GetHeader("Authorization")
if token == "" {
- common.ErrorWithCode(c, common.CodeUnauthorized, "Missing authorization header")
+ common.RespondError(c, common.CodeUnauthorized, "Missing authorization header")
c.Abort()
return
}
@@ -884,14 +884,14 @@ func (h *Handler) AuthMiddleware() gin.HandlerFunc {
// Get user by access token
identity, code, err := h.userService.ResolveAccessToken(ctx, token)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, code, nil, "Invalid access token")
+ common.Respond(c, http.StatusUnauthorized, code, nil, "Invalid access token")
c.Abort()
return
}
user := identity.User
if user.IsSuperuser == nil || !*user.IsSuperuser {
- common.ResponseWithHttpCodeData(c, http.StatusForbidden, common.CodeForbidden, nil, "Permission denied")
+ common.Respond(c, http.StatusForbidden, common.CodeForbidden, nil, "Permission denied")
c.Abort()
return
}
@@ -906,13 +906,13 @@ func (h *Handler) AuthMiddleware() gin.HandlerFunc {
// HandleNoRoute handle undefined routes
func (h *Handler) HandleNoRoute(c *gin.Context) {
- common.ResponseWithHttpCodeData(c, http.StatusNotFound, 404, nil, "The requested resource was not found")
+ common.Respond(c, http.StatusNotFound, 404, nil, "The requested resource was not found")
}
// GetLogLevel returns the current log level
func (h *Handler) GetLogLevel(c *gin.Context) {
level := common.GetLogLevel()
- common.SuccessWithData(c, gin.H{"level": level}, "SUCCESS")
+ common.RespondSuccess(c, gin.H{"level": level}, "SUCCESS")
}
// SetLogLevelRequest set log level request
@@ -924,16 +924,16 @@ type SetLogLevelRequest struct {
func (h *Handler) SetLogLevel(c *gin.Context) {
var req SetLogLevelRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, "Level is required")
+ common.RespondError(c, common.CodeBadRequest, "Level is required")
return
}
if err := common.SetLogLevel(req.Level); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"level": req.Level}, "SUCCESS")
+ common.RespondSuccess(c, gin.H{"level": req.Level}, "SUCCESS")
}
func (h *Handler) ListMessagesFromQueue(c *gin.Context) {
@@ -941,7 +941,7 @@ func (h *Handler) ListMessagesFromQueue(c *gin.Context) {
msgQueueEngine := engine.GetMessageQueueEngine()
messages, err := msgQueueEngine.ListMessages("ingestion", false)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
var result []map[string]string
@@ -958,7 +958,7 @@ func (h *Handler) ListMessagesFromQueue(c *gin.Context) {
})
}
- common.SuccessWithData(c, result, "List messages from queue successfully")
+ common.RespondSuccessList(c, result, "List messages from queue successfully")
}
type PublishMessageToQueueRequest struct {
@@ -968,7 +968,7 @@ type PublishMessageToQueueRequest struct {
func (h *Handler) PublishMessageToQueue(c *gin.Context) {
var req PublishMessageToQueueRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, "Message is required")
+ common.RespondError(c, common.CodeBadRequest, "Message is required")
return
}
@@ -980,18 +980,18 @@ func (h *Handler) PublishMessageToQueue(c *gin.Context) {
// convert task
taskMessageStr, err := json.Marshal(taskMessage)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
msgQueueEngine := engine.GetMessageQueueEngine()
err = msgQueueEngine.PublishTask(common.TaskSubject, taskMessageStr)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
- common.SuccessWithData(c, nil, "Publish message successfully")
+ common.RespondSuccess(c, nil, "Publish message successfully")
}
type PullMessageFromQueueRequest struct {
@@ -1002,25 +1002,24 @@ type PullMessageFromQueueRequest struct {
func (h *Handler) PullMessageFromQueue(c *gin.Context) {
var req PullMessageFromQueueRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, fmt.Sprintf("Message count error: %s", err.Error()))
+ common.RespondError(c, common.CodeBadRequest, fmt.Sprintf("Message count error: %s", err.Error()))
return
}
if req.MessageCount > common.MaxManualPullMessages {
- common.ErrorWithCode(c, common.CodeBadRequest,
- fmt.Sprintf("message count must be between 1 and %d", common.MaxManualPullMessages))
+ common.RespondError(c, common.CodeBadRequest, fmt.Sprintf("message count must be between 1 and %d", common.MaxManualPullMessages))
return
}
msgQueueEngine := engine.GetMessageQueueEngine()
if err := msgQueueEngine.InitConsumer(common.TaskSubject); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
pullCtx, cancel := context.WithTimeout(c.Request.Context(), time.Second)
defer cancel()
messages, err := msgQueueEngine.PullMessages(pullCtx, req.MessageCount)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
var result []map[string]string
@@ -1056,7 +1055,7 @@ func (h *Handler) PullMessageFromQueue(c *gin.Context) {
}
}
- common.SuccessWithData(c, result, "Pull messages from queue successfully")
+ common.RespondSuccessList(c, result, "Pull messages from queue successfully")
}
func (h *Handler) ShowMessageQueue(c *gin.Context) {
@@ -1064,11 +1063,11 @@ func (h *Handler) ShowMessageQueue(c *gin.Context) {
msgQueueEngine := engine.GetMessageQueueEngine()
result, err := msgQueueEngine.ShowMessageQueue()
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
- common.SuccessWithData(c, result, "show message queue successfully")
+ common.RespondSuccess(c, result, "show message queue successfully")
}
func (h *Handler) ListIngestors(c *gin.Context) {
@@ -1090,7 +1089,7 @@ func (h *Handler) ListIngestors(c *gin.Context) {
ingestorResults = append(ingestorResults, ingestorResult)
}
}
- common.SuccessWithData(c, ingestorResults, "Get all tasks")
+ common.RespondSuccessList(c, ingestorResults, "Get all tasks")
}
type ShutdownIngestorRequest struct {
@@ -1100,7 +1099,7 @@ type ShutdownIngestorRequest struct {
func (h *Handler) ShutdownIngestor(c *gin.Context) {
var req ShutdownIngestorRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, "Ingestor ID is required")
+ common.RespondError(c, common.CodeBadRequest, "Ingestor ID is required")
return
}
@@ -1111,14 +1110,14 @@ func (h *Handler) ShutdownIngestor(c *gin.Context) {
// AssignedTo: req.IngestorID,
//})
- common.SuccessWithData(c, gin.H{"task_id": taskID, "ingestor_id": req.IngestorID}, "Shutdown ingestor")
+ common.RespondSuccess(c, gin.H{"task_id": taskID, "ingestor_id": req.IngestorID}, "Shutdown ingestor")
}
// Reports handle heartbeat reports from servers
func (h *Handler) Reports(c *gin.Context) {
var req common.BaseMessage
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
@@ -1129,13 +1128,17 @@ func (h *Handler) Reports(c *gin.Context) {
// Only process heartbeat messages for now
if req.MessageType != common.MessageHeartbeat {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Unsupported report type: "+string(req.MessageType))
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Unsupported report type: "+string(req.MessageType))
return
}
// Handle the heartbeat
errCode, data, message := h.service.HandleHeartbeat(&req)
- common.ResponseWithCodeData(c, errCode, data, message)
+ if errCode != common.CodeSuccess {
+ common.RespondError(c, errCode, message)
+ return
+ }
+ common.RespondSuccess(c, data, message)
}
func (h *Handler) ListAllModels(c *gin.Context) {
@@ -1157,53 +1160,53 @@ func (h *Handler) ListAllModels(c *gin.Context) {
// List models
models, err := h.service.ListAllModels(page, pageSize)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, models, "")
+ common.RespondSuccessList(c, models, "")
}
func (h *Handler) ShowModel(c *gin.Context) {
encodedModelName := c.Param("model_name")
if encodedModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Encoded model name is empty")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Encoded model name is empty")
return
}
decodedModelName, err := common.DecodeFromBase64(encodedModelName)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if decodedModelName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Decoded model name is empty")
+ common.RespondError(c, common.CodeBadRequest, "Decoded model name is empty")
return
}
// Get model
model, err := h.service.GetModelByModelName(decodedModelName)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, model, "")
+ common.RespondSuccess(c, model, "")
}
func (h *Handler) PingStore(c *gin.Context) {
storageImpl := storage.GetStorageFactory().GetStorage()
if storageImpl == nil {
- common.ErrorWithCode(c, common.CodeServerError, "storage not initialized")
+ common.RespondError(c, common.CodeServerError, "storage not initialized")
return
}
ctx := c.Request.Context()
if storageImpl.Health(ctx) {
- common.SuccessWithData(c, "SUCCESS", "success")
+ common.RespondSuccess(c, nil, "success")
} else {
- common.ErrorWithCode(c, common.CodeServerError, "storage health check failed")
+ common.RespondError(c, common.CodeServerError, "storage health check failed")
}
}
@@ -1211,9 +1214,9 @@ func (h *Handler) PingCache(c *gin.Context) {
ctx := c.Request.Context()
redisClient := kvrocks.Get()
if redisClient.Health(ctx) {
- common.SuccessWithData(c, "SUCCESS", "success")
+ common.RespondSuccess(c, nil, "success")
} else {
- common.ErrorWithCode(c, common.CodeServerError, "cache health check failed")
+ common.RespondError(c, common.CodeServerError, "cache health check failed")
}
}
@@ -1225,21 +1228,21 @@ func (h *Handler) PingEngine(c *gin.Context) {
Code() common.ErrorCode
}
if errors.As(err, &coded) {
- common.ResponseWithHttpCodeData(c, http.StatusServiceUnavailable, coded.Code(), nil, err.Error())
+ common.Respond(c, http.StatusServiceUnavailable, coded.Code(), nil, err.Error())
return
}
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, "SUCCESS", "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *Handler) GetHardwareInfo(c *gin.Context) {
hardwareInfo, err := utility.GetHardwareInfo()
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, hardwareInfo, "SUCCESS")
+ common.RespondSuccess(c, hardwareInfo, "SUCCESS")
}
diff --git a/internal/cli/user_command.go b/internal/cli/user_command.go
index 80594d0c9a..6f27be912e 100644
--- a/internal/cli/user_command.go
+++ b/internal/cli/user_command.go
@@ -52,12 +52,21 @@ func (c *CLI) APIShowVersionCommand(commandCount int, cmd *Command) (ResponseIf,
return nil, fmt.Errorf("failed to show version: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
}
- var result KeyValueResponse
- if err = json.Unmarshal(resp.Body, &result); err != nil {
+ var payload struct {
+ Code int `json:"code"`
+ Data struct {
+ Version string `json:"version"`
+ } `json:"data"`
+ }
+ if err = json.Unmarshal(resp.Body, &payload); err != nil {
return nil, fmt.Errorf("show version failed: invalid JSON (%w)", err)
}
- result.Key = "version"
- result.Duration = resp.Duration
+ result := KeyValueResponse{
+ Code: payload.Code,
+ Key: "version",
+ Value: payload.Data.Version,
+ Duration: resp.Duration,
+ }
return &result, nil
}
@@ -2939,16 +2948,18 @@ func (c *CLI) DevRemoveChunksCommand(commandCount int, cmd *Command) (ResponseIf
var result SimpleResponse
result.Code = int(code)
if result.Code == 0 {
- deletedCount := int64(0)
- switch data := resJSON["data"].(type) {
- case float64:
- deletedCount = int64(data)
- case map[string]interface{}:
- var count float64
- if count, ok = data["deleted_count"].(float64); ok {
- deletedCount = int64(count)
- }
+ var payload struct {
+ Data *struct {
+ DeletedCount *int64 `json:"deleted_count"`
+ } `json:"data"`
+ }
+ if err := json.Unmarshal(resp.Body, &payload); err != nil {
+ return nil, fmt.Errorf("invalid chunk deletion response: %w", err)
+ }
+ if payload.Data == nil || payload.Data.DeletedCount == nil || *payload.Data.DeletedCount < 0 {
+ return nil, fmt.Errorf("invalid response format: data.deleted_count must be a non-negative integer")
}
+ deletedCount := *payload.Data.DeletedCount
result.Message = fmt.Sprintf("Success to remove chunks from document %s: %d chunks deleted", docID, deletedCount)
} else {
result.Message = fmt.Sprintf("Failed to remove chunks: %v", resJSON)
diff --git a/internal/cli/user_command_test.go b/internal/cli/user_command_test.go
index 0ccaedfc15..956ca0f4ed 100644
--- a/internal/cli/user_command_test.go
+++ b/internal/cli/user_command_test.go
@@ -40,6 +40,31 @@ func TestParseLocalHTMLWithInlineImage(t *testing.T) {
}
}
+func TestAPIShowVersionCommandReadsVersionObject(t *testing.T) {
+ client := newTestHTTPClient(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodGet || r.URL.Path != "/api/v1/system/version" {
+ t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
+ }
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = fmt.Fprint(w, `{"code":0,"message":"success","data":{"version":"v1.2.3"}}`)
+ }))
+ c := &CLI{
+ Config: &CommandLineConfig{
+ CLIMode: APIMode,
+ APIClientConfig: APIModeConfig{CurrentAPIServer: "test"},
+ },
+ APIServerClientMap: map[string]*HTTPClient{"test": client},
+ }
+ result, err := c.APIShowVersionCommand(1, &Command{})
+ if err != nil {
+ t.Fatal(err)
+ }
+ response, ok := result.(*KeyValueResponse)
+ if !ok || response.Code != 0 || response.Key != "version" || response.Value != "v1.2.3" {
+ t.Fatalf("unexpected version response: %#v", result)
+ }
+}
+
func TestDevUpdateChunkCommandUsesChunkResource(t *testing.T) {
updated := make(chan struct{}, 1)
client := newTestHTTPClient(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -95,6 +120,70 @@ func TestDevUpdateChunkCommandUsesChunkResource(t *testing.T) {
}
}
+func TestDevRemoveChunksCommandReadsDeletedCount(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ body string
+ count string
+ wantErr bool
+ }{
+ {name: "deleted chunks", body: `{"code":0,"data":{"deleted_count":2}}`, count: "2"},
+ {name: "nothing deleted", body: `{"code":0,"data":{"deleted_count":0}}`, count: "0"},
+ {name: "large count", body: `{"code":0,"data":{"deleted_count":9007199254740993}}`, count: "9007199254740993"},
+ {name: "missing data", body: `{"code":0}`, wantErr: true},
+ {name: "missing count", body: `{"code":0,"data":{}}`, wantErr: true},
+ {name: "null count", body: `{"code":0,"data":{"deleted_count":null}}`, wantErr: true},
+ {name: "scalar data", body: `{"code":0,"data":2}`, wantErr: true},
+ {name: "fractional count", body: `{"code":0,"data":{"deleted_count":1.5}}`, wantErr: true},
+ {name: "negative count", body: `{"code":0,"data":{"deleted_count":-1}}`, wantErr: true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ client := newTestHTTPClient(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ switch r.URL.Path {
+ case "/api/v1/datasets":
+ _, _ = fmt.Fprint(w, `{"code":0,"data":[{"id":"dataset-1","name":"test"}]}`)
+ case "/api/v1/datasets/dataset-1/documents/doc-1/chunks":
+ if r.Method != http.MethodDelete {
+ t.Errorf("method = %s, want DELETE", r.Method)
+ }
+ _, _ = fmt.Fprint(w, tc.body)
+ default:
+ t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
+ http.NotFound(w, r)
+ }
+ }))
+ client.useAPIKey = true
+ c := &CLI{
+ Config: &CommandLineConfig{
+ CLIMode: APIMode,
+ APIClientConfig: APIModeConfig{CurrentAPIServer: "test"},
+ },
+ APIServerClientMap: map[string]*HTTPClient{"test": client},
+ }
+ result, err := c.DevRemoveChunksCommand(1, &Command{Params: map[string]interface{}{
+ "dataset_name": "test",
+ "doc_id": "doc-1",
+ "chunk_ids": []string{"chunk-1", "chunk-2"},
+ }})
+ if tc.wantErr {
+ if err == nil {
+ t.Fatalf("expected invalid deletion response to fail, got %#v", result)
+ }
+ return
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ response, ok := result.(*SimpleResponse)
+ wantMessage := "Success to remove chunks from document doc-1: " + tc.count + " chunks deleted"
+ if !ok || response.Code != 0 || response.Message != wantMessage {
+ t.Fatalf("unexpected deletion response: %#v, want %q", result, wantMessage)
+ }
+ })
+ }
+}
+
// TestAPIListIngestionTasksSendsDatasetIDFilter pins the fix for the wrong
// type assertion: the parser stores dataset_id as a plain string, but the old
// code asserted .(*string), which always failed and sent dataset_id: null —
diff --git a/internal/common/http.go b/internal/common/http.go
index 058e067290..c4a1b5a16d 100644
--- a/internal/common/http.go
+++ b/internal/common/http.go
@@ -729,89 +729,6 @@ func allZero(b []byte) bool {
return true
}
-type response struct {
- Code ErrorCode `json:"code"`
- Data interface{} `json:"data"`
- Message string `json:"message"`
- Total interface{} `json:"total,omitempty"`
-}
-
-// errorResponse error response
-type errorResponse struct {
- Code ErrorCode `json:"code"`
- Message string `json:"message"`
-}
-
-func responseMessage(code ErrorCode, message string) string {
- if message != "" {
- return message
- }
- if code == CodeSuccess {
- return "success"
- }
- return code.Message()
-}
-
-// SuccessWithData returns success response with data
-func SuccessWithData(c *gin.Context, data interface{}, message string) {
- c.JSON(http.StatusOK, response{
- Code: CodeSuccess,
- Data: data,
- Message: responseMessage(CodeSuccess, message),
- })
-}
-
-// SuccessWithDataAndTotal returns success response with data and total number
-func SuccessWithDataAndTotal(c *gin.Context, data, total interface{}, message string) {
- c.JSON(http.StatusOK, response{
- Code: CodeSuccess,
- Data: data,
- Total: total,
- Message: responseMessage(CodeSuccess, message),
- })
-}
-
-// SuccessNoData returns success response without data
-func SuccessNoData(c *gin.Context, message string) {
- c.JSON(http.StatusOK, response{
- Code: CodeSuccess,
- Data: nil,
- Message: responseMessage(CodeSuccess, message),
- })
-}
-
-// SuccessWithMessage returns success response with message only
-func SuccessWithMessage(c *gin.Context, message string) {
- c.JSON(http.StatusOK, response{
- Code: CodeSuccess,
- Message: responseMessage(CodeSuccess, message),
- })
-}
-
-// ErrorWithCode returns error response with code and message
-func ErrorWithCode(c *gin.Context, code ErrorCode, message string) {
- c.JSON(http.StatusOK, errorResponse{
- Code: code,
- Message: responseMessage(code, message),
- })
-}
-
-func ResponseWithCodeData(c *gin.Context, code ErrorCode, data interface{}, message string) {
- c.JSON(http.StatusOK, response{
- Code: code,
- Data: data,
- Message: responseMessage(code, message),
- })
-}
-
-func ResponseWithHttpCodeData(c *gin.Context, httpCode int, code ErrorCode, data interface{}, message string) {
- c.JSON(httpCode, response{
- Code: code,
- Data: data,
- Message: responseMessage(code, message),
- })
-}
-
func ParseRequestIntPositive(c *gin.Context, parameter, parameterName string, defaultValue int) (int, error) {
var parameterInt int
var err error
@@ -829,14 +746,3 @@ func ParseRequestIntPositive(c *gin.Context, parameter, parameterName string, de
}
return parameterInt, nil
}
-
-// ResponseWithDetail returns an error envelope with a structured detail
-// payload. Billing resource failures expose detail.current / detail.limit so
-// the web upgrade modal can render the shortage.
-func ResponseWithDetail(c *gin.Context, code ErrorCode, message string, detail interface{}) {
- c.JSON(http.StatusOK, struct {
- Code ErrorCode `json:"code"`
- Message interface{} `json:"message"`
- Detail interface{} `json:"detail,omitempty"`
- }{Code: code, Message: message, Detail: detail})
-}
diff --git a/internal/common/response.go b/internal/common/response.go
new file mode 100644
index 0000000000..c4671edb3d
--- /dev/null
+++ b/internal/common/response.go
@@ -0,0 +1,84 @@
+package common
+
+import (
+ "net/http"
+ "reflect"
+
+ "github.com/gin-gonic/gin"
+)
+
+// ResponseOptions supplies optional envelope metadata.
+type ResponseOptions struct {
+ Total any
+ Detail any
+}
+
+type response struct {
+ Code ErrorCode `json:"code"`
+ Message string `json:"message"`
+ Data any `json:"data,omitempty"`
+ Total any `json:"total,omitempty"`
+ Detail any `json:"detail,omitempty"`
+}
+
+// RespondSuccessList writes a successful response with list data and an optional total.
+// Supply at most one total; omitting it leaves total out of the response.
+func RespondSuccessList[T any](c *gin.Context, data []T, message string, total ...int64) {
+ var options ResponseOptions
+ if len(total) > 0 {
+ options.Total = total[0]
+ }
+ Respond(c, http.StatusOK, CodeSuccess, data, message, options)
+}
+
+// RespondSuccess writes a successful response with optional data.
+func RespondSuccess(c *gin.Context, data any, message string, options ...ResponseOptions) {
+ Respond(c, http.StatusOK, CodeSuccess, data, message, options...)
+}
+
+// RespondError writes an error code and message without data.
+func RespondError(c *gin.Context, code ErrorCode, message string, options ...ResponseOptions) {
+ Respond(c, http.StatusOK, code, nil, message, options...)
+}
+
+// Respond writes a response with an HTTP status and application code. A zero
+// HTTP status defaults to 200. Use RespondSuccess or RespondError for HTTP 200
+// responses, and Respond for responses that need another HTTP status.
+// Data accepts structs, maps, slices, arrays, and pointers to those types.
+// Other values and typed nils are silently omitted without pre-encoding data.
+func Respond(c *gin.Context, httpStatus int, code ErrorCode, data any, message string, options ...ResponseOptions) {
+ if message == "" {
+ message = code.Message()
+ if code == CodeSuccess {
+ message = "success"
+ }
+ }
+
+ if httpStatus == 0 {
+ httpStatus = http.StatusOK
+ }
+ body := response{Code: code, Message: message}
+ value := reflect.ValueOf(data)
+ for value.IsValid() && value.Kind() == reflect.Pointer {
+ value = value.Elem()
+ }
+ if value.IsValid() {
+ switch value.Kind() {
+ case reflect.Struct, reflect.Array:
+ body.Data = data
+ case reflect.Map, reflect.Slice:
+ if !value.IsNil() {
+ body.Data = data
+ }
+ }
+ }
+ for _, option := range options {
+ if option.Total != nil {
+ body.Total = option.Total
+ }
+ if option.Detail != nil {
+ body.Detail = option.Detail
+ }
+ }
+ c.JSON(httpStatus, body)
+}
diff --git a/internal/common/response_test.go b/internal/common/response_test.go
new file mode 100644
index 0000000000..075416408f
--- /dev/null
+++ b/internal/common/response_test.go
@@ -0,0 +1,115 @@
+package common
+
+import (
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "reflect"
+ "testing"
+ "time"
+
+ "github.com/gin-gonic/gin"
+)
+
+func TestResponseHelpers(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ var nilMap map[string]any
+ var nilSlice []string
+ var nilPointer *struct{ ID string }
+ objectPointer := &struct {
+ ID string `json:"id"`
+ }{"one"}
+ objectMap := map[string]string{"id": "one"}
+ list := []int{0, 1}
+ scalar := "scalar"
+ tests := []struct {
+ name string
+ write func(*gin.Context)
+ status int
+ body string
+ }{
+ {"no data", func(c *gin.Context) { RespondSuccess(c, nil, "") }, 200, `{"code":0,"message":"success"}`},
+ {"object", func(c *gin.Context) { RespondSuccess(c, map[string]any{"ok": false}, "") }, 200, `{"code":0,"message":"success","data":{"ok":false}}`},
+ {"struct", func(c *gin.Context) {
+ RespondSuccess(c, struct {
+ ID string `json:"id"`
+ }{"one"}, "")
+ }, 200, `{"code":0,"message":"success","data":{"id":"one"}}`},
+ {"list", func(c *gin.Context) { RespondSuccessList(c, []int{0, 1}, "") }, 200, `{"code":0,"message":"success","data":[0,1]}`},
+ {"array", func(c *gin.Context) { RespondSuccess(c, [2]int{0, 1}, "") }, 200, `{"code":0,"message":"success","data":[0,1]}`},
+ {"object pointer", func(c *gin.Context) { RespondSuccess(c, objectPointer, "") }, 200, `{"code":0,"message":"success","data":{"id":"one"}}`},
+ {"nested object pointer", func(c *gin.Context) { RespondSuccess(c, &objectPointer, "") }, 200, `{"code":0,"message":"success","data":{"id":"one"}}`},
+ {"typed map", func(c *gin.Context) { RespondSuccess(c, objectMap, "") }, 200, `{"code":0,"message":"success","data":{"id":"one"}}`},
+ {"map pointer", func(c *gin.Context) { RespondSuccess(c, &objectMap, "") }, 200, `{"code":0,"message":"success","data":{"id":"one"}}`},
+ {"slice pointer", func(c *gin.Context) { RespondSuccess(c, &list, "") }, 200, `{"code":0,"message":"success","data":[0,1]}`},
+ {"empty object", func(c *gin.Context) { RespondSuccess(c, map[string]any{}, "") }, 200, `{"code":0,"message":"success","data":{}}`},
+ {"empty list", func(c *gin.Context) { RespondSuccessList(c, []int{}, "") }, 200, `{"code":0,"message":"success","data":[]}`},
+ {"nil object", func(c *gin.Context) { RespondSuccess(c, nilMap, "") }, 200, `{"code":0,"message":"success"}`},
+ {"nil pointer", func(c *gin.Context) { RespondSuccess(c, nilPointer, "") }, 200, `{"code":0,"message":"success"}`},
+ {"nil list", func(c *gin.Context) { RespondSuccessList(c, nilSlice, "") }, 200, `{"code":0,"message":"success"}`},
+ {"pointer to nil map", func(c *gin.Context) { RespondSuccess(c, &nilMap, "") }, 200, `{"code":0,"message":"success"}`},
+ {"pointer to nil list", func(c *gin.Context) { RespondSuccess(c, &nilSlice, "") }, 200, `{"code":0,"message":"success"}`},
+ {"business error", func(c *gin.Context) { RespondError(c, CodeBadRequest, "") }, 200, `{"code":400,"message":"Bad request"}`},
+ {"zero HTTP status", func(c *gin.Context) { Respond(c, 0, CodeSuccess, nil, "") }, 200, `{"code":0,"message":"success"}`},
+ {"HTTP error", func(c *gin.Context) {
+ Respond(c, http.StatusBadRequest, CodeArgumentError, nil, "Missing name")
+ }, 400, `{"code":101,"message":"Missing name"}`},
+ {"string", func(c *gin.Context) { RespondSuccess(c, "v1.2.3", "") }, 200, `{"code":0,"message":"success"}`},
+ {"empty string", func(c *gin.Context) { RespondSuccess(c, "", "") }, 200, `{"code":0,"message":"success"}`},
+ {"boolean", func(c *gin.Context) { RespondSuccess(c, false, "") }, 200, `{"code":0,"message":"success"}`},
+ {"integer", func(c *gin.Context) { RespondSuccess(c, int64(0), "") }, 200, `{"code":0,"message":"success"}`},
+ {"true", func(c *gin.Context) { Respond(c, http.StatusCreated, CodeSuccess, true, "") }, 201, `{"code":0,"message":"success"}`},
+ {"float", func(c *gin.Context) { RespondSuccess(c, 1.5, "") }, 200, `{"code":0,"message":"success"}`},
+ {"scalar pointer", func(c *gin.Context) { RespondSuccess(c, &scalar, "") }, 200, `{"code":0,"message":"success"}`},
+ {"bytes retain encoding", func(c *gin.Context) { RespondSuccess(c, []byte("bytes"), "") }, 200, `{"code":0,"message":"success","data":"Ynl0ZXM="}`},
+ {"struct retains custom encoding", func(c *gin.Context) { RespondSuccess(c, time.Unix(0, 0).UTC(), "") }, 200, `{"code":0,"message":"success","data":"1970-01-01T00:00:00Z"}`},
+ {"raw object", func(c *gin.Context) { RespondSuccess(c, json.RawMessage(` {"id":"raw"} `), "") }, 200, `{"code":0,"message":"success","data":{"id":"raw"}}`},
+ {"raw array", func(c *gin.Context) { RespondSuccess(c, json.RawMessage(`[1,"two",false]`), "") }, 200, `{"code":0,"message":"success","data":[1,"two",false]}`},
+ {"raw scalar retains encoding", func(c *gin.Context) { RespondSuccess(c, json.RawMessage(`true`), "") }, 200, `{"code":0,"message":"success","data":true}`},
+ {"raw null retains encoding", func(c *gin.Context) { RespondSuccess(c, json.RawMessage(`null`), "") }, 200, `{"code":0,"message":"success","data":null}`},
+ {"unsupported data", func(c *gin.Context) { RespondSuccess(c, make(chan int), "") }, 200, `{"code":0,"message":"success"}`},
+ {"error message", func(c *gin.Context) { RespondError(c, CodeDataError, "Missing document") }, 200, `{"code":102,"message":"Missing document"}`},
+ {"pagination", func(c *gin.Context) {
+ RespondSuccessList(c, []string{}, "", 0)
+ }, 200, `{"code":0,"message":"success","data":[],"total":0}`},
+ {"paginated list", func(c *gin.Context) {
+ RespondSuccessList(c, []string{"one"}, "listed", 42)
+ }, 200, `{"code":0,"message":"listed","data":["one"],"total":42}`},
+ {"large total", func(c *gin.Context) {
+ var total int64 = 1 << 40
+ RespondSuccessList(c, []string{}, "", total)
+ }, 200, `{"code":0,"message":"success","data":[],"total":1099511627776}`},
+ {"nil list with total", func(c *gin.Context) {
+ RespondSuccessList(c, nilSlice, "", 0)
+ }, 200, `{"code":0,"message":"success","total":0}`},
+ {"detail", func(c *gin.Context) {
+ RespondError(c, CodeBillingStorageInsufficient, "", ResponseOptions{Detail: map[string]int{"limit": 100}})
+ }, 200, `{"code":2003,"message":"Billing storage insufficient","detail":{"limit":100}}`},
+ {"combined options", func(c *gin.Context) {
+ Respond(c, http.StatusCreated, CodeSuccess, []string{"one"}, "created", ResponseOptions{Total: 1})
+ }, 201, `{"code":0,"message":"created","data":["one"],"total":1}`},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ recorder := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(recorder)
+ tt.write(c)
+ if recorder.Code != tt.status {
+ t.Fatalf("status = %d, want %d", recorder.Code, tt.status)
+ }
+ var got, want map[string]any
+ if err := json.Unmarshal(recorder.Body.Bytes(), &got); err != nil {
+ t.Fatal(err)
+ }
+ if err := json.Unmarshal([]byte(tt.body), &want); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(got, want) {
+ t.Fatalf("body = %s, want %s", recorder.Body.String(), tt.body)
+ }
+ if got := recorder.Header().Get("Content-Type"); got != "application/json; charset=utf-8" {
+ t.Fatalf("Content-Type = %q", got)
+ }
+ })
+ }
+}
diff --git a/internal/development.md b/internal/development.md
index 36274c4df0..a0b388b566 100644
--- a/internal/development.md
+++ b/internal/development.md
@@ -1,5 +1,42 @@
# RAGFlow Go implementation - Development Guide
+## API response helpers
+
+Pass response data directly to the helper:
+
+```go
+common.RespondSuccessList(c, items, "success")
+common.RespondSuccess(c, item, "success")
+common.RespondError(c, common.CodeBadRequest, "Missing name")
+```
+
+For HTTP 200, use `RespondSuccess` when the application code is `CodeSuccess`
+and `RespondError` otherwise. `RespondError` omits `data`. `Respond` takes the
+HTTP status before the application code for responses with other HTTP statuses:
+
+```go
+common.RespondSuccess(c, nil, "success")
+common.Respond(c, httpStatus, code, data, message)
+```
+
+The convenience helpers use HTTP 200. Pass an optional `int64` total directly to
+`RespondSuccessList` for pagination. Omit it when no total is available; an explicit
+zero remains present in the response. Use `ResponseOptions` with the other helpers
+for envelope metadata such as error details:
+
+```go
+common.RespondSuccessList(c, items, "success", total)
+common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Missing name")
+```
+
+Use objects or lists for result data and plain nil for operation acknowledgments.
+The system version is returned as `gin.H{"version": version}`. Return chunk-deletion counts as
+`gin.H{"deleted_count": count}`. Callers determine success from the envelope code.
+`Respond` checks Go kinds using reflection and accepts structs, maps, slices,
+arrays, and pointers to those types. Other kinds and typed nils are silently
+omitted. Empty objects and lists remain present. The helper does not pre-encode
+data or validate its JSON shape; accepted types retain their custom JSON encoding.
+
## 1. Prepare dependencies
### 1.1 Install CMake and build RAGFlow on Ubuntu 24.04
diff --git a/internal/handler/agent.go b/internal/handler/agent.go
index 557d6303c0..3da9e2eefd 100644
--- a/internal/handler/agent.go
+++ b/internal/handler/agent.go
@@ -168,7 +168,7 @@ func (h *AgentHandler) WithNewExecutor(f func(taskCtx *task.TaskContext, canvasI
func (h *AgentHandler) ListAgents(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -178,10 +178,10 @@ func (h *AgentHandler) ListAgents(c *gin.Context) {
if c.Query("type") == "filter" {
filters, code, err := h.agentService.ListAgentFilters(c.Request.Context(), user.ID, strings.TrimSpace(c.Query("canvas_category")))
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, filters, "success")
+ common.RespondSuccess(c, filters, "success")
return
}
@@ -244,11 +244,11 @@ func (h *AgentHandler) ListAgents(c *gin.Context) {
tags,
)
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// mapAgentError normalises service-layer errors onto the existing
@@ -294,7 +294,7 @@ func mapAgentError(err error) (common.ErrorCode, string) {
func (h *AgentHandler) CreateAgent(c *gin.Context) {
user, errorCode, err := billingQuotaUser(c)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
if !billingEnforceApps(c, user.ID) {
@@ -303,15 +303,15 @@ func (h *AgentHandler) CreateAgent(c *gin.Context) {
var req service.CreateAgentRequest
if err = decodeJSONWithNumber(c.Request.Body, &req); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
row, code, err := h.agentService.CreateAgent(c.Request.Context(), user.ID, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, row, "success")
+ common.RespondSuccess(c, row, "success")
}
// GetAgent returns one canvas by ID.
@@ -324,14 +324,14 @@ func (h *AgentHandler) CreateAgent(c *gin.Context) {
func (h *AgentHandler) GetAgent(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
row, err := h.agentService.GetAgent(c.Request.Context(), user.ID, canvasID)
if err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
// Defensive: any historical v1 / Go-v2-only row in user_canvas.dsl
@@ -346,14 +346,14 @@ func (h *AgentHandler) GetAgent(c *gin.Context) {
lastPublishTime, err := h.agentService.GetLastPublishTime(c.Request.Context(), canvasID)
if err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
tenantID := ""
if row != nil {
tenantID = row.EffectiveTenantID()
}
- common.SuccessWithData(c, &agentDetailResponse{
+ common.RespondSuccess(c, &agentDetailResponse{
UserCanvas: row,
TenantID: tenantID,
LastPublishTime: lastPublishTime,
@@ -385,13 +385,13 @@ func decodeJSONWithNumber(body io.Reader, target any) error {
func (h *AgentHandler) UpdateAgent(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
var req map[string]interface{}
if err := decodeJSONWithNumber(c.Request.Body, &req); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
if req == nil {
@@ -399,15 +399,15 @@ func (h *AgentHandler) UpdateAgent(c *gin.Context) {
}
if err := h.agentService.UpdateAgent(c.Request.Context(), user.ID, canvasID, req); err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
canvasInstance, err := h.agentService.GetAgent(c.Request.Context(), user.ID, canvasID)
if err != nil || canvasInstance == nil {
- common.SuccessWithData(c, map[string]interface{}{}, "success")
+ common.RespondSuccess(c, map[string]interface{}{}, "success")
return
}
- common.SuccessWithData(c, map[string]interface{}{
+ common.RespondSuccess(c, map[string]interface{}{
"update_time": canvasInstance.UpdateTime,
}, "success")
}
@@ -422,16 +422,16 @@ func (h *AgentHandler) UpdateAgent(c *gin.Context) {
func (h *AgentHandler) DeleteAgent(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
if err := h.agentService.DeleteAgent(c.Request.Context(), user.ID, canvasID); err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// ListTemplates lists every canvas template available to authenticated users.
@@ -444,7 +444,7 @@ func (h *AgentHandler) DeleteAgent(c *gin.Context) {
// @Router /api/v1/agents/templates [get]
func (h *AgentHandler) ListTemplates(c *gin.Context) {
if _, errorCode, errorMessage := GetUser(c); errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
@@ -458,7 +458,7 @@ func (h *AgentHandler) ListTemplates(c *gin.Context) {
templates = []*entity.CanvasTemplate{}
}
- common.SuccessWithData(c, templates, "success")
+ common.RespondSuccessList(c, templates, "success")
}
// RunAgent returns an SSE stream of execution events. The Phase 5 stub emits
@@ -474,7 +474,7 @@ func (h *AgentHandler) ListTemplates(c *gin.Context) {
func (h *AgentHandler) RunAgent(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
@@ -488,7 +488,7 @@ func (h *AgentHandler) RunAgent(c *gin.Context) {
}
userInput, err := readUserInput(c)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
@@ -497,7 +497,7 @@ func (h *AgentHandler) RunAgent(c *gin.Context) {
events, err := h.chatRunner.RunAgent(ctx, user.ID, canvasID, sessionID, version, userInput, nil)
if err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
c.Writer.Header().Set("Content-Type", "text/event-stream")
@@ -610,24 +610,16 @@ func (h *AgentHandler) runCanvasPipelineDebug(ctx context.Context, user *entity.
return result, runErr
}
-// respondWithDebugResult writes the outcome of a dataflow debug run. On a run
-// failure it keeps a non-success code (errors must not be masked as success)
-// but still carries message_id in the error envelope's data, because
-// runCanvasPipelineDebug already flushed the failure log to Redis — the front-end
-// needs that key to poll the failure timeline. On success it returns the
-// message_id (the polling key) together with the produced chunks. Empty chunk
-// slices become `[]` rather than `null` so the response shape stays stable.
+// respondWithDebugResult writes the outcome of a dataflow debug run. On success
+// it returns the message_id (the polling key) together with the produced chunks.
+// Empty chunk slices become `[]` rather than `null` so the response shape stays stable.
// This is the single wire-shape helper for the chat/completions DataFlow debug
// entry point, and it matches the contract the front-end expects:
// `data.data.message_id` drives the log-poll loop and `data.data.chunks`
// renders the debug output.
func respondWithDebugResult(c *gin.Context, result *task.PipelineResult, err error) {
if err != nil {
- messageID := ""
- if result != nil {
- messageID = result.MessageID
- }
- common.ResponseWithCodeData(c, common.CodeServerError, gin.H{"message_id": messageID}, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
messageID := ""
@@ -639,7 +631,7 @@ func respondWithDebugResult(c *gin.Context, result *task.PipelineResult, err err
if len(chunks) == 0 {
chunks = []map[string]any{}
}
- common.SuccessWithData(c, gin.H{"message_id": messageID, "chunks": chunks}, "success")
+ common.RespondSuccess(c, gin.H{"message_id": messageID, "chunks": chunks}, "success")
}
// extractChatDebugFile pulls the first uploaded file from a chat/completions
@@ -684,19 +676,19 @@ func (h *AgentHandler) extractChatDebugFile(ctx context.Context, files []map[str
func (h *AgentHandler) CancelSessionRun(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
if h.agentService == nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "agent service unavailable")
+ common.RespondError(c, common.CodeServerError, "agent service unavailable")
return
}
if err := h.agentService.CancelSessionRun(c.Request.Context(), user.ID, c.Param("session_id")); err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// publishAgentRequest is the wire shape for POST /api/v1/agents/:canvas_id/publish.
@@ -719,13 +711,13 @@ type publishAgentRequest struct {
func (h *AgentHandler) PublishAgent(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
var req publishAgentRequest
if err := decodeJSONWithNumber(c.Request.Body, &req); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
row, err := h.agentService.PublishAgent(c.Request.Context(), user.ID, canvasID, &service.PublishAgentRequest{
@@ -736,13 +728,13 @@ func (h *AgentHandler) PublishAgent(c *gin.Context) {
})
if err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
if row != nil {
row.DSL = dslpkg.NormalizeForCanvas(row.DSL)
}
- common.SuccessWithData(c, row, "success")
+ common.RespondSuccess(c, row, "success")
}
// ListVersions returns every version of a canvas, newest first.
@@ -755,14 +747,14 @@ func (h *AgentHandler) PublishAgent(c *gin.Context) {
func (h *AgentHandler) ListVersions(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
rows, err := h.agentService.ListVersions(c.Request.Context(), user.ID, canvasID)
if err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
if rows == nil {
@@ -774,7 +766,7 @@ func (h *AgentHandler) ListVersions(c *gin.Context) {
}
row.DSL = dslpkg.NormalizeForCanvas(row.DSL)
}
- common.SuccessWithData(c, rows, "success")
+ common.RespondSuccessList(c, rows, "success")
}
// GetVersion returns a single version.
@@ -788,7 +780,7 @@ func (h *AgentHandler) ListVersions(c *gin.Context) {
func (h *AgentHandler) GetVersion(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
@@ -796,13 +788,13 @@ func (h *AgentHandler) GetVersion(c *gin.Context) {
row, err := h.agentService.GetVersion(c.Request.Context(), user.ID, canvasID, versionID)
if err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
if row != nil {
row.DSL = dslpkg.NormalizeForCanvas(row.DSL)
}
- common.SuccessWithData(c, row, "success")
+ common.RespondSuccess(c, row, "success")
}
// DeleteVersion removes a single version by id.
@@ -816,17 +808,17 @@ func (h *AgentHandler) GetVersion(c *gin.Context) {
func (h *AgentHandler) DeleteVersion(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
versionID := c.Param("version_id")
if err := h.agentService.DeleteVersion(c.Request.Context(), user.ID, canvasID, versionID); err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// PatchVersion patches mutable metadata (alias/title/description) of a single
@@ -844,7 +836,7 @@ func (h *AgentHandler) DeleteVersion(c *gin.Context) {
func (h *AgentHandler) PatchVersion(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
@@ -855,16 +847,16 @@ func (h *AgentHandler) PatchVersion(c *gin.Context) {
Description *string `json:"description"`
}
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
patch := dao.UserCanvasVersionPatch{Alias: req.Alias, Title: req.Title, Description: req.Description}
if err := h.agentService.UpdateVersion(c.Request.Context(), user.ID, canvasID, versionID, patch); err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// ApplyVersion restores a saved workflow as the current agent draft.
@@ -878,17 +870,17 @@ func (h *AgentHandler) PatchVersion(c *gin.Context) {
func (h *AgentHandler) ApplyVersion(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
versionID := c.Param("version_id")
if err := h.agentService.ApplyVersion(c.Request.Context(), user.ID, canvasID, versionID); err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// --- PR2: missing routes wired up to the existing service layer ---
@@ -896,16 +888,16 @@ func (h *AgentHandler) ApplyVersion(c *gin.Context) {
// ListAgentTemplates GET /api/v1/agents/templates
func (h *AgentHandler) ListAgentTemplates(c *gin.Context) {
if _, code, msg := GetUser(c); code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
ctx := c.Request.Context()
rows, err := h.agentService.ListTemplates(ctx)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, rows, "success")
+ common.RespondSuccessList(c, rows, "success")
}
// Prompts GET /api/v1/agents/prompts — returns the four hardcoded
@@ -913,10 +905,10 @@ func (h *AgentHandler) ListAgentTemplates(c *gin.Context) {
// returns these from a module-level constant; we keep the same shape.
func (h *AgentHandler) Prompts(c *gin.Context) {
if _, code, msg := GetUser(c); code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
- common.SuccessWithData(c, gin.H{
+ common.RespondSuccess(c, gin.H{
"task_analysis": "As an AI agent designer, your role is to engage users by understanding their objectives and creating effective agent designs. Begin by analyzing the user's request to determine the appropriate actions.",
"output_format": "For each agent you create, detail its components and explain how they collaborate to achieve the user's goal.",
"citation_guidelines": "If the agent uses external sources, cite them in the final output. Use the format: [index] document_id, which corresponds to the document identifier in the database.",
@@ -928,24 +920,24 @@ func (h *AgentHandler) Prompts(c *gin.Context) {
func (h *AgentHandler) ListAgentTags(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
ctx := c.Request.Context()
rows, errCode, err := h.agentService.ListAgentTags(ctx, user.ID, strings.TrimSpace(c.Query("canvas_category")))
if err != nil {
- common.ResponseWithCodeData(c, errCode, nil, err.Error())
+ common.RespondError(c, errCode, err.Error())
return
}
- common.SuccessWithData(c, rows, "success")
+ common.RespondSuccessList(c, rows, "success")
}
// UpdateAgentTags PUT /api/v1/agents/:canvas_id/tags
func (h *AgentHandler) UpdateAgentTags(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
@@ -953,23 +945,23 @@ func (h *AgentHandler) UpdateAgentTags(c *gin.Context) {
Tags interface{} `json:"tags"`
}
if err := c.ShouldBindJSON(&body); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
ctx := c.Request.Context()
ok, errCode, errMsg := h.agentService.UpdateAgentTags(ctx, user.ID, canvasID, body.Tags)
if !ok {
- common.ResponseWithCodeData(c, errCode, nil, errMsg.Error())
+ common.RespondError(c, errCode, errMsg.Error())
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// ListAgentSessions GET /api/v1/agents/:canvas_id/sessions
func (h *AgentHandler) ListAgentSessions(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
@@ -989,7 +981,7 @@ func (h *AgentHandler) ListAgentSessions(c *gin.Context) {
ctx := c.Request.Context()
options, err := sessionHistoryQuery(c)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
resp, code, err := h.agentService.ListAgentSessions(ctx, user.ID, user.ID, canvasID, service.ListAgentSessionsRequest{
@@ -1009,17 +1001,17 @@ func (h *AgentHandler) ListAgentSessions(c *gin.Context) {
NoHistory: c.Query("include_history") == "false" || c.Query("include_history") == "False",
})
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithDataAndTotal(c, resp.Data, resp.Total, "success")
+ common.RespondSuccessList(c, resp.Data, "success", resp.Total)
}
// CreateAgentSession POST /api/v1/agents/:canvas_id/sessions
func (h *AgentHandler) CreateAgentSession(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
@@ -1029,7 +1021,7 @@ func (h *AgentHandler) CreateAgentSession(c *gin.Context) {
DSL json.RawMessage `json:"dsl"`
}
if err := c.ShouldBindJSON(&body); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
ctx := c.Request.Context()
@@ -1041,10 +1033,10 @@ func (h *AgentHandler) CreateAgentSession(c *gin.Context) {
DSL: body.DSL,
})
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, struct {
+ common.RespondSuccess(c, struct {
*entity.API4Conversation
AgentID string `json:"agent_id"`
}{row, row.DialogID}, "success")
@@ -1054,7 +1046,7 @@ func (h *AgentHandler) CreateAgentSession(c *gin.Context) {
func (h *AgentHandler) GetAgentSession(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
@@ -1062,15 +1054,15 @@ func (h *AgentHandler) GetAgentSession(c *gin.Context) {
ctx := c.Request.Context()
options, err := sessionHistoryQuery(c)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
row, code, err := h.agentService.GetAgentSession(ctx, user.ID, canvasID, sessionID, options)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, row, "success")
+ common.RespondSuccess(c, row, "success")
}
// DeleteAgentSession DELETE /api/v1/agents/:canvas_id/sessions[/:session_id]
@@ -1081,19 +1073,19 @@ func (h *AgentHandler) GetAgentSession(c *gin.Context) {
func (h *AgentHandler) DeleteAgentSession(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
ctx := c.Request.Context()
canvasID := c.Param("canvas_id")
sessionID := c.Param("session_id")
if sessionID != "" {
- ok, code, err := h.agentService.DeleteAgentSessionItem(ctx, user.ID, canvasID, sessionID)
+ _, code, err := h.agentService.DeleteAgentSessionItem(ctx, user.ID, canvasID, sessionID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, ok, "success")
+ common.RespondSuccess(c, nil, "success")
return
}
idsParam := c.Query("ids")
@@ -1113,15 +1105,15 @@ func (h *AgentHandler) DeleteAgentSession(c *gin.Context) {
if err := c.ShouldBindJSON(&body); err == nil {
ids, deleteAll = body.IDs, body.DeleteAll
} else if !errors.Is(err, io.EOF) {
- common.ErrorWithCode(c, common.CodeArgumentError, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
result, code, err := h.agentService.DeleteAgentSessions(ctx, user.ID, canvasID, ids, deleteAll)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// AgentChatCompletions POST /api/v1/agents/chat/completions
@@ -1250,17 +1242,17 @@ func userInputMeta(userInput any) []zap.Field {
func (h *AgentHandler) AgentChatCompletions(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
var req agentChatCompletionsRequest
if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
question, err := service.ResolveCompletionQuestion(req.Question, req.Query, req.Messages)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
req.Query = question
@@ -1271,11 +1263,11 @@ func (h *AgentHandler) AgentChatCompletions(c *gin.Context) {
req.Messages = req.Messages[len(req.Messages)-1:]
}
if req.AgentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`agent_id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`agent_id` is required.")
return
}
if req.OpenAICompat && len(req.Messages) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "at least one message is required in openai-compatible mode.")
+ common.RespondError(c, common.CodeDataError, "at least one message is required in openai-compatible mode.")
return
}
common.Debug("agent chat completions: request received",
@@ -1310,7 +1302,7 @@ func (h *AgentHandler) AgentChatCompletions(c *gin.Context) {
if cv, lerr := h.loader.LoadCanvasByID(c.Request.Context(), user.ID, req.AgentID); lerr == nil && cv.CanvasCategory == "dataflow_canvas" {
fileName, fileData := h.extractChatDebugFile(c.Request.Context(), req.Files, user)
if len(fileData) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataflow debug requires an uploaded file")
+ common.RespondError(c, common.CodeDataError, "dataflow debug requires an uploaded file")
return
}
result, derr := h.runCanvasPipelineDebug(c.Request.Context(), user, req.AgentID, fileName, fileData)
@@ -1358,7 +1350,7 @@ func (h *AgentHandler) AgentChatCompletions(c *gin.Context) {
}, userInputMeta(userInput)...)...,
)
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
@@ -1510,7 +1502,7 @@ func (h *AgentHandler) AgentChatCompletions(c *gin.Context) {
zap.String("agent_id", req.AgentID),
zap.String("session_id", req.SessionID),
)
- common.SuccessWithData(c, gin.H{"session_id": req.SessionID}, "success")
+ common.RespondSuccess(c, gin.H{"session_id": req.SessionID}, "success")
return
}
@@ -1542,28 +1534,28 @@ func (h *AgentHandler) AgentChatCompletions(c *gin.Context) {
"task_id": finalAns.SessionID,
"session_id": finalAns.SessionID,
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// TestDBConnection POST /api/v1/agents/test-db-connection
func (h *AgentHandler) TestDBConnection(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
var req service.TestDBConnectionRequest
if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
ctx := c.Request.Context()
code, err := h.agentService.TestDBConnection(ctx, user.ID, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// parseAgentLogs decodes the debug-log payload stored in Redis by the pipeline
@@ -1658,14 +1650,14 @@ func (h *AgentHandler) persistAgentToolInvocations(ctx context.Context, canvasID
func (h *AgentHandler) GetAgentLogs(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
messageID := c.Param("message_id")
ok, errCode, errMsg := h.checkCanvasAccessForHandler(c, user.ID, canvasID)
if !ok {
- common.ResponseWithCodeData(c, errCode, nil, errMsg)
+ common.RespondError(c, errCode, errMsg)
return
}
@@ -1675,7 +1667,7 @@ func (h *AgentHandler) GetAgentLogs(c *gin.Context) {
if rerr == nil {
data = parseAgentLogs(payload)
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
// GetAgentWebhookLogs GET /api/v1/agents/:canvas_id/webhook/logs
@@ -1690,7 +1682,7 @@ func (h *AgentHandler) GetAgentLogs(c *gin.Context) {
func (h *AgentHandler) GetAgentWebhookLogs(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
@@ -1705,13 +1697,13 @@ func (h *AgentHandler) GetAgentWebhookLogs(c *gin.Context) {
jsonInternalError(c, err)
return
}
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Canvas not found.")
+ common.RespondError(c, common.CodeDataError, "Canvas not found.")
return
}
sinceTS, hasSinceTS := parseWebhookSinceTS(c.Query("since_ts"))
if !hasSinceTS {
- common.SuccessWithData(c, newWebhookTracePoll(nil, float64(time.Now().UnixNano())/1e9, false), "success")
+ common.RespondSuccess(c, newWebhookTracePoll(nil, float64(time.Now().UnixNano())/1e9, false), "success")
return
}
if h.redisGet == nil {
@@ -1728,7 +1720,7 @@ func (h *AgentHandler) GetAgentWebhookLogs(c *gin.Context) {
jsonInternalError(c, err)
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// checkCanvasAccessForHandler is the shared 103 envelope helper for
@@ -1782,15 +1774,15 @@ func (h *AgentHandler) checkCanvasAccessForHandler(c *gin.Context, userID, canva
func (h *AgentHandler) ResetAgent(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
dsl, err := h.agentService.ResetAgent(c.Request.Context(), user.ID, canvasID)
if err != nil {
ec, em := mapAgentError(err)
- common.ResponseWithCodeData(c, ec, nil, em)
+ common.RespondError(c, ec, em)
return
}
- common.SuccessWithData(c, dsl, "success")
+ common.RespondSuccess(c, dsl, "success")
}
diff --git a/internal/handler/agent_attachment.go b/internal/handler/agent_attachment.go
index 70a0f38089..a5b6bc2d36 100644
--- a/internal/handler/agent_attachment.go
+++ b/internal/handler/agent_attachment.go
@@ -78,14 +78,14 @@ func attachmentRequestMeta(c *gin.Context) attachmentRequestMetadata {
// _stream_agent_attachment().
func (h *AgentHandler) streamAgentAttachment(c *gin.Context, tenantID, attachmentID string, inline bool) {
if h.fileService == nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "file service not configured")
+ common.RespondError(c, common.CodeServerError, "file service not configured")
return
}
ctx := c.Request.Context()
blob, err := h.fileService.DownloadAgentFile(ctx, tenantID, attachmentID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Attachment not found!")
+ common.RespondError(c, common.CodeDataError, "Attachment not found!")
return
}
@@ -111,12 +111,12 @@ func (h *AgentHandler) streamAgentAttachment(c *gin.Context, tenantID, attachmen
func (h *AgentHandler) DownloadAttachment(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
attachmentID := c.Param("attachment_id")
if attachmentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`attachment_id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`attachment_id` is required.")
return
}
// Note (review F9): the plan explicitly defers attachment-id
@@ -131,7 +131,7 @@ func (h *AgentHandler) DownloadAttachment(c *gin.Context) {
// never crosses the service boundary.
safe := filepath.Base(attachmentID)
if safe == "" || safe == "." || safe == "/" || strings.ContainsAny(safe, "\r\n\"") {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "invalid attachment id.")
+ common.RespondError(c, common.CodeArgumentError, "invalid attachment id.")
return
}
@@ -150,17 +150,17 @@ func (h *AgentHandler) DownloadAttachment(c *gin.Context) {
func (h *AgentHandler) PreviewAttachment(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
attachmentID := c.Param("attachment_id")
if attachmentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`attachment_id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`attachment_id` is required.")
return
}
safe := filepath.Base(attachmentID)
if safe == "" || safe == "." || safe == "/" || strings.ContainsAny(safe, "\r\n\"") {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "invalid attachment id.")
+ common.RespondError(c, common.CodeArgumentError, "invalid attachment id.")
return
}
diff --git a/internal/handler/agent_component.go b/internal/handler/agent_component.go
index 029ceece4f..45d0c47af3 100644
--- a/internal/handler/agent_component.go
+++ b/internal/handler/agent_component.go
@@ -51,23 +51,23 @@ import (
func (h *AgentHandler) GetComponentInputForm(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
componentID := c.Param("component_id")
if canvasID == "" || componentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`canvas_id` and `component_id` are required.")
+ common.RespondError(c, common.CodeArgumentError, "`canvas_id` and `component_id` are required.")
return
}
cv, err := h.loader.LoadCanvasByID(c.Request.Context(), user.ID, canvasID)
if err != nil {
if errors.Is(err, dao.ErrUserCanvasNotFound) {
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, canvasNoAccessMessage)
+ common.RespondError(c, common.CodeOperatingError, canvasNoAccessMessage)
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
@@ -76,7 +76,7 @@ func (h *AgentHandler) GetComponentInputForm(c *gin.Context) {
mapDSLError(c, componentID, err)
return
}
- common.SuccessWithData(c, form, "success")
+ common.RespondSuccess(c, form, "success")
}
// componentInputForm returns the input-form schema for a single component.
@@ -121,13 +121,13 @@ func (h *AgentHandler) componentInputForm(ctx context.Context, dslMap map[string
func (h *AgentHandler) DebugComponent(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
componentID := c.Param("component_id")
if canvasID == "" || componentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`canvas_id` and `component_id` are required.")
+ common.RespondError(c, common.CodeArgumentError, "`canvas_id` and `component_id` are required.")
return
}
@@ -136,11 +136,11 @@ func (h *AgentHandler) DebugComponent(c *gin.Context) {
IncludeModelInputs json.RawMessage `json:"include_model_inputs"`
}
if err := c.ShouldBindJSON(&body); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
if body.Params == nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`params` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`params` is required.")
return
}
includeModelInputs := false
@@ -149,17 +149,17 @@ func (h *AgentHandler) DebugComponent(c *gin.Context) {
case "true":
includeModelInputs = true
default:
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`include_model_inputs` must be a boolean.")
+ common.RespondError(c, common.CodeArgumentError, "`include_model_inputs` must be a boolean.")
return
}
cv, err := h.loader.LoadCanvasByID(c.Request.Context(), user.ID, canvasID)
if err != nil {
if errors.Is(err, dao.ErrUserCanvasNotFound) {
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, canvasNoAccessMessage)
+ common.RespondError(c, common.CodeOperatingError, canvasNoAccessMessage)
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
@@ -182,14 +182,12 @@ func (h *AgentHandler) DebugComponent(c *gin.Context) {
inputs := make(map[string]any, len(body.Params))
for k, v := range body.Params {
if v == nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "`params."+k+".value` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`params."+k+".value` is required.")
return
}
value, ok := v["value"]
if !ok {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "`params."+k+".value` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`params."+k+".value` is required.")
return
}
inputs[k] = value
@@ -197,24 +195,24 @@ func (h *AgentHandler) DebugComponent(c *gin.Context) {
factory := runtime.DefaultFactory()
if factory == nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "component factory not initialised")
+ common.RespondError(c, common.CodeServerError, "component factory not initialised")
return
}
comp, err := factory(name, dslParams)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "component factory: "+err.Error())
+ common.RespondError(c, common.CodeDataError, "component factory: "+err.Error())
return
}
if includeModelInputs {
if _, ok := comp.(*component.AgentComponent); !ok {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Model inputs are available only for Agent components.")
+ common.RespondError(c, common.CodeArgumentError, "Model inputs are available only for Agent components.")
return
}
if err := permission.NewDatabaseChecker(dao.DB).CheckResource(c.Request.Context(), permission.ResourceRef{Kind: permission.ResourceKindCanvas, ID: canvasID}, permission.OperationUpdate); err != nil {
if errors.Is(err, permission.ErrResourceNotFound) || errors.Is(err, permission.ErrPermissionDenied) {
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, canvasNoAccessMessage)
+ common.RespondError(c, common.CodeOperatingError, canvasNoAccessMessage)
} else {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
}
return
}
@@ -269,6 +267,10 @@ func (h *AgentHandler) DebugComponent(c *gin.Context) {
outputs, err := runtime.TrackElapsed(name, func() (map[string]any, error) {
return comp.Invoke(invokeCtx, dao.DB, inputs)
})
+ if err != nil {
+ common.RespondError(c, common.CodeServerError, "invoke: "+err.Error())
+ return
+ }
var data any = outputs
if capture != nil {
data = struct {
@@ -276,15 +278,7 @@ func (h *AgentHandler) DebugComponent(c *gin.Context) {
ModelInputs models.ModelInputs `json:"model_inputs"`
}{Outputs: outputs, ModelInputs: capture.Finalize()}
}
- if err != nil {
- if capture == nil {
- data = nil
- }
- common.ResponseWithCodeData(c, common.CodeServerError, data, "invoke: "+err.Error())
- return
- }
-
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
// mapDSLError translates a dsl extractor error into a 102 envelope.
@@ -295,12 +289,12 @@ func (h *AgentHandler) DebugComponent(c *gin.Context) {
func mapDSLError(c *gin.Context, componentID string, err error) {
switch {
case errors.Is(err, dsl.ErrComponentNotFound):
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "component not found: "+componentID)
+ common.RespondError(c, common.CodeDataError, "component not found: "+componentID)
case errors.Is(err, dsl.ErrMissingInputForm):
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "component has no params.inputs: "+componentID)
+ common.RespondError(c, common.CodeDataError, "component has no params.inputs: "+componentID)
case errors.Is(err, dsl.ErrMalformedDSL):
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "malformed dsl: "+err.Error())
+ common.RespondError(c, common.CodeDataError, "malformed dsl: "+err.Error())
default:
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "internal: "+err.Error())
+ common.RespondError(c, common.CodeServerError, "internal: "+err.Error())
}
}
diff --git a/internal/handler/agent_download.go b/internal/handler/agent_download.go
index 1801a62f2c..11ce295d20 100644
--- a/internal/handler/agent_download.go
+++ b/internal/handler/agent_download.go
@@ -44,13 +44,12 @@ import (
func (h *AgentHandler) DownloadAgentFile(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
fileID := c.Query("id")
if fileID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "`id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`id` is required.")
return
}
@@ -65,7 +64,7 @@ func (h *AgentHandler) DownloadAgentFile(c *gin.Context) {
// both the python and Go code paths.
blob, err := h.fileService.DownloadAgentFile(ctx, user.ID, fileID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
@@ -77,8 +76,7 @@ func (h *AgentHandler) DownloadAgentFile(c *gin.Context) {
// value.
safe := filepath.Base(fileID)
if safe == "" || safe == "." || safe == "/" || strings.ContainsAny(safe, "\r\n\"") {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "invalid file id.")
+ common.RespondError(c, common.CodeArgumentError, "invalid file id.")
return
}
c.Header("Content-Disposition", fmt.Sprintf(
diff --git a/internal/handler/agent_logs_test.go b/internal/handler/agent_logs_test.go
index 9f7d234898..1a75275f10 100644
--- a/internal/handler/agent_logs_test.go
+++ b/internal/handler/agent_logs_test.go
@@ -493,12 +493,7 @@ func TestRespondWithDebugResult_Shape(t *testing.T) {
}
}
-// TestRespondWithDebugResult_ErrorCarriesMessageID pins that a run failure
-// still surfaces the polling key: the response must keep a non-success code
-// (the existing contract forbids masking errors as success) BUT the error
-// envelope's data must carry message_id so the front-end can poll the failure
-// timeline that DebugLogSink.Flush already wrote to Redis.
-func TestRespondWithDebugResult_ErrorCarriesMessageID(t *testing.T) {
+func TestRespondWithDebugResult_ErrorOmitsData(t *testing.T) {
gin.SetMode(gin.TestMode)
w := httptest.NewRecorder()
@@ -508,15 +503,14 @@ func TestRespondWithDebugResult_ErrorCarriesMessageID(t *testing.T) {
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v body=%s", err, w.Body.String())
}
- if code, _ := resp["code"].(float64); int(code) == int(common.CodeSuccess) {
- t.Fatalf("error case must not be success: %v", resp)
+ if code, _ := resp["code"].(float64); int(code) != int(common.CodeServerError) {
+ t.Fatalf("code=%v want %d", resp["code"], common.CodeServerError)
}
- data, ok := resp["data"].(map[string]interface{})
- if !ok {
- t.Fatalf("error envelope data must be an object carrying message_id: %v", resp)
+ if _, ok := resp["data"]; ok {
+ t.Fatalf("error envelope must omit data: %v", resp)
}
- if data["message_id"] != "m-err" {
- t.Fatalf("error envelope data.message_id=%v want m-err", data["message_id"])
+ if resp["message"] != "boom" {
+ t.Fatalf("message=%v want boom", resp["message"])
}
}
diff --git a/internal/handler/agent_model_inputs_test.go b/internal/handler/agent_model_inputs_test.go
index 7989041a40..e64f74f924 100644
--- a/internal/handler/agent_model_inputs_test.go
+++ b/internal/handler/agent_model_inputs_test.go
@@ -137,8 +137,8 @@ func TestDebugAgentModelInputsMatchProviderMessages(t *testing.T) {
}
}
-// TestDebugAgentModelInputsDefaultAndErrorContracts checks unchanged default
-// outputs and error codes, with opt-in diagnostics retained on provider failure.
+// TestDebugAgentModelInputsDefaultAndErrorContracts checks default outputs and
+// that provider failures omit data with or without opt-in diagnostics.
func TestDebugAgentModelInputsDefaultAndErrorContracts(t *testing.T) {
var fail atomic.Bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -165,19 +165,9 @@ func TestDebugAgentModelInputsDefaultAndErrorContracts(t *testing.T) {
fail.Store(true)
without := runModelInputDebug(t, handler, "false")
with := runModelInputDebug(t, handler, "true")
- if without.Code == 0 || without.Code != with.Code || without.Message != with.Message || string(without.Data) != "null" {
+ if without.Code == 0 || without.Code != with.Code || without.Message != with.Message || without.Data != nil || with.Data != nil {
t.Fatalf("error contract changed: without=%+v with=%+v", without, with)
}
- var data struct {
- Outputs map[string]any `json:"outputs"`
- ModelInputs models.ModelInputs `json:"model_inputs"`
- }
- if err := json.Unmarshal(with.Data, &data); err != nil {
- t.Fatal(err)
- }
- if data.Outputs != nil || len(data.ModelInputs.Calls) != 1 || data.ModelInputs.Calls[0].Status != "captured" {
- t.Fatalf("failed provider input was lost: %s", with.Data)
- }
}
// TestDebugAgentModelInputsRejectsInvalidFlagAndUnauthorizedExecution checks
@@ -191,7 +181,7 @@ func TestDebugAgentModelInputsRejectsInvalidFlagAndUnauthorizedExecution(t *test
defer server.Close()
handler, _ := setupModelInputDebug(t, server.URL)
for _, flag := range []string{`null`, `"true"`, `1`, `{}`, `[]`} {
- if response := runModelInputDebug(t, handler, flag); response.Code != int(common.CodeArgumentError) || string(response.Data) != "null" {
+ if response := runModelInputDebug(t, handler, flag); response.Code != int(common.CodeArgumentError) || response.Data != nil {
t.Fatalf("flag %s accepted: %+v", flag, response)
}
}
@@ -201,7 +191,7 @@ func TestDebugAgentModelInputsRejectsInvalidFlagAndUnauthorizedExecution(t *test
t.Fatal(err)
}
response := runModelInputDebug(t, handler, "true")
- if response.Code != int(common.CodeOperatingError) || response.Message != canvasNoAccessMessage || string(response.Data) != "null" {
+ if response.Code != int(common.CodeOperatingError) || response.Message != canvasNoAccessMessage || response.Data != nil {
t.Fatalf("unauthorized result: %+v", response)
}
if calls.Load() != 0 {
@@ -220,7 +210,7 @@ func TestDebugModelInputsRejectsNonAgent(t *testing.T) {
if err := json.Unmarshal(w.Body.Bytes(), &response); err != nil {
t.Fatal(err)
}
- if response.Code != int(common.CodeArgumentError) || string(response.Data) != "null" {
+ if response.Code != int(common.CodeArgumentError) || response.Data != nil {
t.Fatalf("non-Agent capture accepted: %+v", response)
}
}
diff --git a/internal/handler/agent_test.go b/internal/handler/agent_test.go
index 72a6f08bab..70c89731ea 100644
--- a/internal/handler/agent_test.go
+++ b/internal/handler/agent_test.go
@@ -490,31 +490,31 @@ type agentHandlerTestable struct {
func (h *agentHandlerTestable) listAgents(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
result, code, err := h.svc.ListAgents(user.ID, "", 0, 0, "create_time", true, nil, "", nil)
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func (h *agentHandlerTestable) listTemplates(c *gin.Context) {
if _, errorCode, errorMessage := GetUser(c); errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
templates, err := h.svc.ListTemplates()
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
if templates == nil {
templates = []*entity.CanvasTemplate{}
}
- common.SuccessWithData(c, templates, "success")
+ common.RespondSuccessList(c, templates, "success")
}
func (f *fakeAgentService) ListAgents(userID, keywords string, page, pageSize int, orderby string, desc bool, ownerIDs []string, canvasCategory string, tags []string) (*service.ListAgentsResponse, common.ErrorCode, error) {
@@ -711,7 +711,7 @@ func TestAgentHandler_NotFoundOnUnknownCanvas(t *testing.T) {
r2.Use(setUser())
g2 := r2.Group("/api/v1/agents")
g2.GET("/:canvas_id", func(c *gin.Context) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "agent unknown: not found")
+ common.RespondError(c, common.CodeNotFound, "agent unknown: not found")
})
w := httptest.NewRecorder()
diff --git a/internal/handler/agent_upload.go b/internal/handler/agent_upload.go
index 295a542da1..0364855fa3 100644
--- a/internal/handler/agent_upload.go
+++ b/internal/handler/agent_upload.go
@@ -58,13 +58,12 @@ const canvasNoAccessMessage = "Make sure you have permission to access the agent
func (h *AgentHandler) UploadAgentFile(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
canvasID := c.Param("canvas_id")
if canvasID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "`canvas_id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`canvas_id` is required.")
return
}
@@ -76,10 +75,10 @@ func (h *AgentHandler) UploadAgentFile(c *gin.Context) {
// still pattern-match the text.
if _, err := h.loader.LoadCanvasByID(c.Request.Context(), user.ID, canvasID); err != nil {
if errors.Is(err, dao.ErrUserCanvasNotFound) {
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, canvasNoAccessMessage)
+ common.RespondError(c, common.CodeOperatingError, canvasNoAccessMessage)
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
@@ -88,13 +87,11 @@ func (h *AgentHandler) UploadAgentFile(c *gin.Context) {
// into memory by ParseMultipartForm before any size check fires.
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, uploadMaxBytes)
if cl := c.Request.ContentLength; cl > uploadMaxBytes {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "request body too large.")
+ common.RespondError(c, common.CodeArgumentError, "request body too large.")
return
}
if err := c.Request.ParseMultipartForm(uploadMaxBytes); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "invalid multipart form: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "invalid multipart form: "+err.Error())
return
}
defer func() {
@@ -104,8 +101,7 @@ func (h *AgentHandler) UploadAgentFile(c *gin.Context) {
}()
form := c.Request.MultipartForm
if form == nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "missing multipart form.")
+ common.RespondError(c, common.CodeArgumentError, "missing multipart form.")
return
}
files := form.File["file"]
@@ -121,22 +117,21 @@ func (h *AgentHandler) UploadAgentFile(c *gin.Context) {
if url := c.Query("url"); url != "" && len(files) == 1 {
uploaded, err := h.fileService.UploadFromURL(ctx, user.ID, url)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, uploaded, "success")
+ common.RespondSuccess(c, uploaded, "success")
return
}
if len(files) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "`file` field is required.")
+ common.RespondError(c, common.CodeArgumentError, "`file` field is required.")
return
}
results, err := h.fileService.UploadInfos(ctx, user.ID, files)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
@@ -147,5 +142,5 @@ func (h *AgentHandler) UploadAgentFile(c *gin.Context) {
} else {
payload = results
}
- common.SuccessWithData(c, payload, "success")
+ common.RespondSuccess(c, payload, "success")
}
diff --git a/internal/handler/agent_version_test.go b/internal/handler/agent_version_test.go
index a1b4d5d40a..9bdac7ec63 100644
--- a/internal/handler/agent_version_test.go
+++ b/internal/handler/agent_version_test.go
@@ -111,7 +111,7 @@ func TestAgentVersionActions(t *testing.T) {
}
var response struct {
Code common.ErrorCode `json:"code"`
- Data interface{} `json:"data"`
+ Data json.RawMessage `json:"data"`
Message string `json:"message"`
}
if err := json.Unmarshal(w.Body.Bytes(), &response); err != nil {
@@ -120,8 +120,8 @@ func TestAgentVersionActions(t *testing.T) {
if response.Code != wantCode || response.Message == "" {
t.Fatalf("unexpected response: %s", w.Body.String())
}
- if wantCode == common.CodeSuccess && response.Data != true {
- t.Fatalf("success data = %v, want true", response.Data)
+ if len(response.Data) != 0 {
+ t.Fatalf("data must be omitted, got %s", response.Data)
}
persisted, err := dao.NewUserCanvasDAO().GetByID(t.Context(), db, current.ID)
if err != nil {
diff --git a/internal/handler/agent_wait_for_user_test.go b/internal/handler/agent_wait_for_user_test.go
index 5736847f2e..095ecdb38c 100644
--- a/internal/handler/agent_wait_for_user_test.go
+++ b/internal/handler/agent_wait_for_user_test.go
@@ -154,7 +154,7 @@ func waitForUserRoutes(svc *waitFakeAgentService) *gin.Engine {
if err != nil {
// We never expect a non-nil err from the fake,
// but be defensive.
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
c.Writer.Header().Set("Content-Type", "text/event-stream")
diff --git a/internal/handler/agent_webhook.go b/internal/handler/agent_webhook.go
index 8dd825f6f1..3c46fda6d4 100644
--- a/internal/handler/agent_webhook.go
+++ b/internal/handler/agent_webhook.go
@@ -126,7 +126,7 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
if isTest {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, code, nil, msg)
+ common.Respond(c, http.StatusUnauthorized, code, nil, msg)
return
}
userID = user.ID
@@ -137,7 +137,7 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
credential, err := h.webhookCredentialManager().Resolve(ctx, canvasID, c.Query("credential"))
if err != nil {
if errors.Is(err, service.ErrInvalidAgentWebhookCredential) {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, common.CodeUnauthorized, nil, "Invalid or revoked webhook credential.")
+ common.Respond(c, http.StatusUnauthorized, common.CodeUnauthorized, nil, "Invalid or revoked webhook credential.")
} else {
jsonInternalError(c, err)
}
@@ -160,7 +160,7 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
cv, err := h.loader.LoadCanvasByID(ctx, userID, canvasID)
if err != nil {
if errors.Is(err, dao.ErrUserCanvasNotFound) || errors.Is(err, dao.ErrUserCanvasVersionNotFound) {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Canvas not found.")
+ common.RespondError(c, common.CodeDataError, "Canvas not found.")
return
}
jsonInternalError(c, err)
@@ -172,7 +172,7 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
// Mirrors Python agent_api.py:1786, which returns
// "Dataflow can not be triggered by webhook." for the same case.
if cv.CanvasCategory == "dataflow_canvas" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Dataflow can not be triggered by webhook.")
+ common.RespondError(c, common.CodeDataError, "Dataflow can not be triggered by webhook.")
return
}
@@ -188,20 +188,20 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
// 4. Find Begin component with mode=="Webhook".
webhookCfg := findWebhookBegin(dsl)
if webhookCfg == nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Webhook not configured for this agent.")
+ common.RespondError(c, common.CodeDataError, "Webhook not configured for this agent.")
return
}
// 5. Method gate.
if !methodAllowed(webhookCfg["methods"], c.Request.Method) {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, fmt.Sprintf("HTTP method '%s' not allowed for this webhook.", c.Request.Method))
+ common.RespondError(c, common.CodeDataError, fmt.Sprintf("HTTP method '%s' not allowed for this webhook.", c.Request.Method))
return
}
// 6. Security gate (strict; surfaces all errors as 102).
securityCfg := stringMap(webhookCfg["security"])
if err = validateWebhookSecurity(securityCfg, c, canvasID); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -232,13 +232,13 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
// 501 — multipart/form-data uploads are not yet
// supported. Body is short so operators see exactly what
// is missing.
- common.ResponseWithHttpCodeData(c, http.StatusNotImplemented, common.CodeNotImplemented, nil, parseErr.Error())
+ common.Respond(c, http.StatusNotImplemented, common.CodeNotImplemented, nil, parseErr.Error())
return
case errors.Is(parseErr, ErrWebhookContentTypeMismatch):
- common.ResponseWithCodeData(c, common.CodeDataError, nil, parseErr.Error())
+ common.RespondError(c, common.CodeDataError, parseErr.Error())
return
default:
- common.ResponseWithCodeData(c, common.CodeDataError, nil, parseErr.Error())
+ common.RespondError(c, common.CodeDataError, parseErr.Error())
return
}
}
@@ -247,7 +247,7 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
schema, _ := webhookCfg["schema"].(map[string]any)
clean, schemaErr := applyWebhookSchema(parsed, schema)
if schemaErr != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, schemaErr.Error())
+ common.RespondError(c, common.CodeDataError, schemaErr.Error())
return
}
@@ -259,7 +259,7 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
if mode == "Immediately" {
status, contentType, payload, perr := renderImmediatelyResponse(stringMap(webhookCfg["response"]))
if perr != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, perr.Error())
+ common.RespondError(c, common.CodeDataError, perr.Error())
return
}
// Detached background run — does NOT inherit c.Request.Context()
@@ -278,7 +278,7 @@ func (h *AgentHandler) Webhook(c *gin.Context) {
func (h *AgentHandler) CreateWebhookCredential(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
if h.loader == nil {
@@ -290,13 +290,13 @@ func (h *AgentHandler) CreateWebhookCredential(c *gin.Context) {
canvas, err := h.loader.LoadCanvasByID(ctx, user.ID, canvasID)
if err != nil {
responseCode, responseMessage := mapAgentError(err)
- common.ResponseWithCodeData(c, responseCode, nil, responseMessage)
+ common.RespondError(c, responseCode, responseMessage)
return
}
credential, err := h.webhookCredentialManager().Issue(ctx, canvas)
if err != nil {
if errors.Is(err, permission.ErrPermissionDenied) || errors.Is(err, permission.ErrMembershipNotFound) || errors.Is(err, permission.ErrIdentityMismatch) {
- common.ResponseWithHttpCodeData(c, http.StatusForbidden, common.CodeForbidden, nil, "You do not have permission to create a webhook credential for this agent.")
+ common.Respond(c, http.StatusForbidden, common.CodeForbidden, nil, "You do not have permission to create a webhook credential for this agent.")
return
}
jsonInternalError(c, err)
@@ -304,7 +304,7 @@ func (h *AgentHandler) CreateWebhookCredential(c *gin.Context) {
}
query := url.Values{"credential": []string{credential}}
webhookPath := fmt.Sprintf("/api/v1/agents/%s/webhook?%s", url.PathEscape(canvasID), query.Encode())
- common.ResponseWithCodeData(c, common.CodeSuccess, gin.H{
+ common.RespondSuccess(c, gin.H{
"credential": credential,
"webhook_url": webhookPath,
}, "success")
@@ -315,14 +315,14 @@ func (h *AgentHandler) CreateWebhookCredential(c *gin.Context) {
func (h *AgentHandler) RevokeWebhookCredential(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
if err := h.webhookCredentialManager().Revoke(c.Request.Context(), c.Param("canvas_id"), user.ID); err != nil {
jsonInternalError(c, err)
return
}
- common.ResponseWithCodeData(c, common.CodeSuccess, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *AgentHandler) webhookCredentialManager() agentWebhookCredentialManager {
diff --git a/internal/handler/api_token.go b/internal/handler/api_token.go
index d17cfbe639..8e34118b84 100644
--- a/internal/handler/api_token.go
+++ b/internal/handler/api_token.go
@@ -40,11 +40,11 @@ func (h *SystemHandler) ListAPIKeys(c *gin.Context) {
// Get keys for the tenant
keys, err := h.systemService.ListAPIKeys(ctx, tenantID)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Failed to list keys")
+ common.Respond(c, http.StatusInternalServerError, 500, nil, "Failed to list keys")
return
}
- common.SuccessWithData(c, keys, "success")
+ common.RespondSuccessList(c, keys, "success")
}
func (h *SystemHandler) CreateKey(c *gin.Context) {
@@ -59,18 +59,18 @@ func (h *SystemHandler) CreateKey(c *gin.Context) {
// ShouldBind reports io.EOF for it.
var req service.CreateAPIKeyRequest
if err = c.ShouldBind(&req); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Invalid request")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Invalid request")
return
}
// Create key
key, err := h.systemService.CreateAPIKey(ctx, user.ID, tenantID, &req)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Failed to create key")
+ common.Respond(c, http.StatusInternalServerError, 500, nil, "Failed to create key")
return
}
- common.SuccessWithData(c, key, "success")
+ common.RespondSuccess(c, key, "success")
}
func (h *SystemHandler) DeleteKey(c *gin.Context) {
@@ -84,17 +84,17 @@ func (h *SystemHandler) DeleteKey(c *gin.Context) {
// Get key from path parameter
key := c.Param("key")
if key == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Key is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Key is required")
return
}
// Delete key
if err = h.systemService.DeleteAPIKey(ctx, tenantID, key); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Failed to delete key")
+ common.Respond(c, http.StatusInternalServerError, 500, nil, "Failed to delete key")
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
func currentAPIKeyOwner(c *gin.Context) (*entity.User, string, common.ErrorCode, error) {
@@ -126,5 +126,5 @@ func respondAPIKeyContextError(c *gin.Context, code common.ErrorCode, err error)
} else if code == common.CodeServerError {
status = http.StatusInternalServerError
}
- common.ResponseWithHttpCodeData(c, status, code, nil, err.Error())
+ common.Respond(c, status, code, nil, err.Error())
}
diff --git a/internal/handler/auth.go b/internal/handler/auth.go
index 1b6671546c..8934ac0e6d 100644
--- a/internal/handler/auth.go
+++ b/internal/handler/auth.go
@@ -113,7 +113,7 @@ func (h *AuthHandler) BetaAuthMiddleware() gin.HandlerFunc {
if auth == "" {
// Mirror Python's login_required(auth_types=AUTH_BETA): any auth
// failure on beta endpoints is a business error, not an HTTP 401.
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Authorization is not valid!")
+ common.RespondError(c, common.CodeDataError, "Authorization is not valid!")
c.Abort()
return
}
@@ -125,7 +125,7 @@ func (h *AuthHandler) BetaAuthMiddleware() gin.HandlerFunc {
// Then try a regular API token (non-beta public bot flow).
if identity, code, err := h.userService.ResolveAPIToken(ctx, auth); err == nil && code == common.CodeSuccess {
if !billingAllowsAPIToken(ctx, identity.TenantID) {
- common.ResponseWithCodeData(c, common.CodePermissionError, nil, "API key requires a Starter or Pro plan")
+ common.RespondError(c, common.CodePermissionError, "API key requires a Starter or Pro plan")
c.Abort()
return
}
@@ -137,7 +137,7 @@ func (h *AuthHandler) BetaAuthMiddleware() gin.HandlerFunc {
// Fall back to beta API token (public bot access).
if identity, code, err := h.userService.ResolveBetaAPIToken(ctx, auth); err == nil && code == common.CodeSuccess {
if !billingAllowsAPIToken(ctx, identity.TenantID) {
- common.ResponseWithCodeData(c, common.CodePermissionError, nil, "API key requires a Starter or Pro plan")
+ common.RespondError(c, common.CodePermissionError, "API key requires a Starter or Pro plan")
c.Abort()
return
}
@@ -150,7 +150,7 @@ func (h *AuthHandler) BetaAuthMiddleware() gin.HandlerFunc {
return
}
// Mirror Python's login_required(auth_types=AUTH_BETA).
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Authorization is not valid!")
+ common.RespondError(c, common.CodeDataError, "Authorization is not valid!")
c.Abort()
}
}
@@ -162,7 +162,7 @@ func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
ctx := c.Request.Context()
token := c.GetHeader("Authorization")
if token == "" {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, 401, nil, "Missing Authorization header")
+ common.Respond(c, http.StatusUnauthorized, 401, nil, "Missing Authorization header")
c.Abort()
return
}
@@ -173,7 +173,7 @@ func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
if err != nil {
identity, code, err = h.userService.ResolveAPIToken(ctx, token)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, code, nil, "Invalid access token")
+ common.Respond(c, http.StatusUnauthorized, code, nil, "Invalid access token")
c.Abort()
return
}
@@ -185,12 +185,12 @@ func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
if billingService := billing.Get(); billingService != nil && billingService.Enabled() {
allowed, gateErr := billingService.APIAuthAllowed(ctx, identity.TenantID)
if gateErr != nil {
- common.ResponseWithHttpCodeData(c, http.StatusForbidden, common.CodeForbidden, nil, gateErr.Error())
+ common.Respond(c, http.StatusForbidden, common.CodeForbidden, nil, gateErr.Error())
c.Abort()
return
}
if !allowed {
- common.ResponseWithHttpCodeData(c, http.StatusForbidden, common.CodeForbidden, nil, "API key requires a Starter or Pro plan")
+ common.Respond(c, http.StatusForbidden, common.CodeForbidden, nil, "API key requires a Starter or Pro plan")
c.Abort()
return
}
@@ -198,7 +198,7 @@ func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
}
if identity.User.IsSuperuser != nil && *identity.User.IsSuperuser {
- common.ResponseWithHttpCodeData(c, http.StatusForbidden, common.CodeForbidden, nil, "Super user shouldn't access the URL")
+ common.Respond(c, http.StatusForbidden, common.CodeForbidden, nil, "Super user shouldn't access the URL")
c.Abort()
return
}
@@ -207,7 +207,7 @@ func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
adminStatus := local.GetAdminStatus()
errMsg := fmt.Sprintf("server error: %s", adminStatus.Reason)
common.Warn(errMsg)
- common.ResponseWithHttpCodeData(c, http.StatusServiceUnavailable, common.CodeUnauthorized, "No", errMsg)
+ common.Respond(c, http.StatusServiceUnavailable, common.CodeUnauthorized, nil, errMsg)
c.Abort()
return
}
diff --git a/internal/handler/bot.go b/internal/handler/bot.go
index 520ffeaeac..23627b0c9a 100644
--- a/internal/handler/bot.go
+++ b/internal/handler/bot.go
@@ -63,12 +63,12 @@ func NewBotHandler(svc *service.BotService) *BotHandler {
func (h *BotHandler) ChatbotInfo(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
dialogID := c.Param("dialog_id")
if dialogID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`dialog_id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`dialog_id` is required.")
return
}
title, avatar, prologue, llmID, hasWebSearch, ec, err := h.botService.ChatbotInfo(
@@ -77,10 +77,10 @@ func (h *BotHandler) ChatbotInfo(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, ec, nil, err.Error())
+ common.RespondError(c, ec, err.Error())
return
}
- common.SuccessWithData(c, gin.H{
+ common.RespondSuccess(c, gin.H{
"title": title,
"avatar": avatar,
"prologue": prologue,
@@ -97,21 +97,21 @@ func (h *BotHandler) ChatbotInfo(c *gin.Context) {
func (h *BotHandler) AgentbotInputs(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
agentID := c.Param("agent_id")
if agentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`agent_id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`agent_id` is required.")
return
}
title, avatar, prologue, mode, inputs, ec, err := h.botService.AgentbotInputs(
c.Request.Context(), user.ID, agentID)
if err != nil {
- common.ResponseWithCodeData(c, ec, nil, err.Error())
+ common.RespondError(c, ec, err.Error())
return
}
- common.SuccessWithData(c, gin.H{
+ common.RespondSuccess(c, gin.H{
"title": title,
"avatar": avatar,
"inputs": inputs,
@@ -138,12 +138,12 @@ func (h *BotHandler) AgentbotInputs(c *gin.Context) {
func (h *BotHandler) AgentbotCompletion(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
agentID := c.Param("agent_id")
if agentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`agent_id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`agent_id` is required.")
return
}
var body service.AgentbotCompletionRequest
@@ -153,8 +153,7 @@ func (h *BotHandler) AgentbotCompletion(c *gin.Context) {
// then ran with empty inputs.
if c.Request.ContentLength != 0 {
if err := c.ShouldBindJSON(&body); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
}
@@ -162,8 +161,7 @@ func (h *BotHandler) AgentbotCompletion(c *gin.Context) {
if rawRelease, ok := c.GetQuery("release"); ok {
release, err := strconv.ParseBool(rawRelease)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "Invalid release value: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid release value: "+err.Error())
return
}
body.Release = &release
@@ -174,7 +172,7 @@ func (h *BotHandler) AgentbotCompletion(c *gin.Context) {
events, ec, err := h.botService.AgentbotCompletion(
ctx, user.ID, agentID, body)
if err != nil {
- common.ResponseWithCodeData(c, ec, nil, err.Error())
+ common.RespondError(c, ec, err.Error())
return
}
c.Writer.Header().Set("Content-Type", "text/event-stream")
@@ -202,12 +200,12 @@ func (h *BotHandler) AgentbotCompletion(c *gin.Context) {
func (h *BotHandler) ChatbotCompletion(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
dialogID := c.Param("dialog_id")
if dialogID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "`dialog_id` is required.")
+ common.RespondError(c, common.CodeArgumentError, "`dialog_id` is required.")
return
}
var body service.ChatbotCompletionRequest
@@ -217,8 +215,7 @@ func (h *BotHandler) ChatbotCompletion(c *gin.Context) {
// then ran with empty session_id/question.
if c.Request.ContentLength != 0 {
if err := c.ShouldBindJSON(&body); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
}
@@ -230,7 +227,7 @@ func (h *BotHandler) ChatbotCompletion(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, ec, nil, err.Error())
+ common.RespondError(c, ec, err.Error())
return
}
c.Writer.Header().Set("Content-Type", "text/event-stream")
@@ -257,17 +254,17 @@ func (h *BotHandler) ChatbotCompletion(c *gin.Context) {
func (h *BotHandler) GetAgentbotLogs(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
agentIDStr := c.Param("agent_id")
if agentIDStr == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "agent_id is required")
+ common.RespondError(c, common.CodeArgumentError, "agent_id is required")
return
}
messageID := c.Param("message_id")
if messageID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "message_id is required")
+ common.RespondError(c, common.CodeArgumentError, "message_id is required")
return
}
// A beta token with DialogID is restricted to that agent. Tokens without
@@ -276,14 +273,14 @@ func (h *BotHandler) GetAgentbotLogs(c *gin.Context) {
if boundAgentID, ok := c.Get("agent_id"); ok {
boundAgentIDStr, ok := boundAgentID.(string)
if ok && boundAgentIDStr != "" && boundAgentIDStr != agentIDStr {
- common.ResponseWithCodeData(c, common.CodeUnauthorized, nil, "API token is not authorized for this agent.")
+ common.RespondError(c, common.CodeUnauthorized, "API token is not authorized for this agent.")
return
}
}
data, ec, err := h.botService.AgentbotLogs(c.Request.Context(), user.ID, agentIDStr, messageID)
if err != nil {
- common.ResponseWithCodeData(c, ec, nil, err.Error())
+ common.RespondError(c, ec, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
diff --git a/internal/handler/bot_test.go b/internal/handler/bot_test.go
index 3184f2423d..47e9f6be3b 100644
--- a/internal/handler/bot_test.go
+++ b/internal/handler/bot_test.go
@@ -997,7 +997,7 @@ func TestBotRoutes_NoRegularAuthRequired(t *testing.T) {
// production AuthMiddleware is exercised separately;
// here we just need to assert "the path resolves to
// something that is NOT a BotHandler".
- common.ResponseWithCodeData(c, common.CodeUnauthorized, nil, "no bot route on v1")
+ common.RespondError(c, common.CodeUnauthorized, "no bot route on v1")
})
// (1) regular JWT on apiNoAuth bot path -> 200.
@@ -1066,13 +1066,13 @@ func TestDownloadAttachment_Unauth(t *testing.T) {
g.Use(func(c *gin.Context) {
auth := c.GetHeader("Authorization")
if auth == "" {
- common.ResponseWithCodeData(c, common.CodeUnauthorized, nil, "Authorization required")
+ common.RespondError(c, common.CodeUnauthorized, "Authorization required")
c.Abort()
return
}
identity, code, err := stub.ResolveAccessToken(c.Request.Context(), auth)
if err != nil || code != common.CodeSuccess {
- common.ResponseWithCodeData(c, common.CodeUnauthorized, nil, "Invalid auth credentials")
+ common.RespondError(c, common.CodeUnauthorized, "Invalid auth credentials")
c.Abort()
return
}
diff --git a/internal/handler/chat.go b/internal/handler/chat.go
index c8039f72a4..efed077a8b 100644
--- a/internal/handler/chat.go
+++ b/internal/handler/chat.go
@@ -73,7 +73,7 @@ type ChatMindMapRequest struct {
func (h *ChatHandler) ListChats(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
@@ -110,7 +110,7 @@ func (h *ChatHandler) ListChats(c *gin.Context) {
switch orderBy {
case "create_time", "update_time", "name":
default:
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("invalid orderby field: %s", orderBy))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("invalid orderby field: %s", orderBy))
return
}
}
@@ -130,11 +130,11 @@ func (h *ChatHandler) ListChats(c *gin.Context) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// Create creates a chat.
@@ -147,7 +147,7 @@ func (h *ChatHandler) ListChats(c *gin.Context) {
func (h *ChatHandler) Create(c *gin.Context) {
user, errorCode, err := billingQuotaUser(c)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
if !billingEnforceApps(c, user.ID) {
@@ -156,7 +156,7 @@ func (h *ChatHandler) Create(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -164,7 +164,7 @@ func (h *ChatHandler) Create(c *gin.Context) {
decoder := json.NewDecoder(c.Request.Body)
decoder.UseNumber()
if err = decoder.Decode(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
if req == nil {
@@ -174,11 +174,11 @@ func (h *ChatHandler) Create(c *gin.Context) {
ctx := c.Request.Context()
result, code, err := h.chatService.Create(ctx, user.ID, req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// MindMap generates a query mind map for chat search results.
@@ -191,17 +191,17 @@ func (h *ChatHandler) Create(c *gin.Context) {
func (h *ChatHandler) MindMap(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req ChatMindMapRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
if strings.TrimSpace(req.Question) == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_ids and question are required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_ids and question are required")
return
}
@@ -229,7 +229,7 @@ func (h *ChatHandler) MindMap(c *gin.Context) {
kbIDs := mergeMindMapKbIDs(stringSliceFromConfig(searchConfig, "kb_ids"), req.KbIDs)
if len(kbIDs) == 0 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_ids and question are required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_ids and question are required")
return
}
@@ -245,23 +245,23 @@ func (h *ChatHandler) MindMap(c *gin.Context) {
})
if err != nil {
common.Warn("mindmap failed", zap.String("error", err.Error()))
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
+ common.RespondError(c, common.CodeOperatingError, err.Error())
return
}
- common.SuccessWithData(c, mindMap, "success")
+ common.RespondSuccess(c, mindMap, "success")
}
func (h *ChatHandler) DeleteChat(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
chatID := c.Param("chat_id")
if chatID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "chat_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "chat_id is required")
return
}
@@ -270,29 +270,29 @@ func (h *ChatHandler) DeleteChat(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// BulkDeleteChats soft deletes multiple chats owned by the current user.
func (h *ChatHandler) BulkDeleteChats(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
if c.Request.Body == nil || c.Request.ContentLength == 0 {
- common.SuccessWithData(c, map[string]interface{}{}, "success")
+ common.RespondSuccess(c, map[string]interface{}{}, "success")
return
}
var req service.BulkDeleteChatsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
@@ -303,21 +303,21 @@ func (h *ChatHandler) BulkDeleteChats(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
return
}
- common.SuccessWithData(c, map[string]interface{}{}, "success")
+ common.RespondSuccess(c, map[string]interface{}{}, "success")
return
}
result, err := h.chatService.BulkDeleteChats(ctx, userID, &req)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -328,7 +328,7 @@ func (h *ChatHandler) BulkDeleteChats(c *gin.Context) {
}
}
- common.SuccessWithData(c, result, message)
+ common.RespondSuccess(c, result, message)
}
// GetChat get chat detail
@@ -345,7 +345,7 @@ func (h *ChatHandler) GetChat(c *gin.Context) {
// Get current user from context (same as Python current_user)
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
@@ -353,7 +353,7 @@ func (h *ChatHandler) GetChat(c *gin.Context) {
// Get chat_id from path parameter (same as Python <chat_id>)
chatID := c.Param("chat_id")
if chatID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "chat_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "chat_id is required")
return
}
@@ -365,7 +365,7 @@ func (h *ChatHandler) GetChat(c *gin.Context) {
return
}
// Not found error
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -406,19 +406,19 @@ func (h *ChatHandler) GetChat(c *gin.Context) {
}
// Return success response
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetAgenticRAGConfig returns defaults and effective Agentic RAG settings.
func (h *ChatHandler) GetAgenticRAGConfig(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
chatID := c.Param("chat_id")
if chatID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "chat_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "chat_id is required")
return
}
settings, err := h.chatService.GetAgenticRAGConfig(c.Request.Context(), user.ID, chatID)
@@ -426,10 +426,10 @@ func (h *ChatHandler) GetAgenticRAGConfig(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, settings, "success")
+ common.RespondSuccess(c, settings, "success")
}
// UpdateChat updates a chat by ID using REST PUT semantics.
@@ -445,19 +445,19 @@ func (h *ChatHandler) PatchChat(c *gin.Context) {
func (h *ChatHandler) updateChatByMethod(c *gin.Context, patch bool) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
chatID := c.Param("chat_id")
if chatID == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "chat_id is required")
+ common.RespondError(c, common.CodeBadRequest, "chat_id is required")
return
}
var req map[string]interface{}
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -473,9 +473,9 @@ func (h *ChatHandler) updateChatByMethod(c *gin.Context, patch bool) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
diff --git a/internal/handler/chat_audio.go b/internal/handler/chat_audio.go
index 6595d013f6..331fa0005d 100644
--- a/internal/handler/chat_audio.go
+++ b/internal/handler/chat_audio.go
@@ -55,7 +55,7 @@ var ttsSegmentSplitRegex = regexp.MustCompile("[,。/《》?;:!\\n\\r:
func (h *ChatHandler) ChatAudioSpeech(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -64,18 +64,18 @@ func (h *ChatHandler) ChatAudioSpeech(c *gin.Context) {
var req chatAudioSpeechRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
if h.modelFactory == nil {
- common.ErrorWithCode(c, common.CodeServerError, "TTS service not available")
+ common.RespondError(c, common.CodeServerError, "TTS service not available")
return
}
ttsModel, err := h.modelFactory.NewDefaultTTSModel(ctx, service.Identity{UserID: user.ID, TenantID: user.ID})
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -174,12 +174,10 @@ func (h *ChatHandler) ChatAudioSpeech(c *gin.Context) {
}
if !headerWritten {
if firstSynthErr != nil {
- common.ErrorWithCode(c, common.CodeServerError,
- fmt.Sprintf("TTS synthesis failed for model %s (%s)", modelName, providerName))
+ common.RespondError(c, common.CodeServerError, fmt.Sprintf("TTS synthesis failed for model %s (%s)", modelName, providerName))
return
}
- common.ErrorWithCode(c, common.CodeServerError,
- fmt.Sprintf("TTS synthesis produced no audio for model %s (%s)", modelName, providerName))
+ common.RespondError(c, common.CodeServerError, fmt.Sprintf("TTS synthesis produced no audio for model %s (%s)", modelName, providerName))
}
}
@@ -213,12 +211,12 @@ var chatAudioAllowedExtsList = func() string {
func (h *ChatHandler) ChatAudioTranscription(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
if h.modelFactory == nil {
- common.ErrorWithCode(c, common.CodeServerError, "ASR service not available")
+ common.RespondError(c, common.CodeServerError, "ASR service not available")
return
}
@@ -227,11 +225,11 @@ func (h *ChatHandler) ChatAudioTranscription(c *gin.Context) {
// rejected instead of being drained into memory or spooled to disk.
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, chatAudioUploadMaxBytes)
if cl := c.Request.ContentLength; cl > chatAudioUploadMaxBytes {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "request body too large.")
+ common.RespondError(c, common.CodeArgumentError, "request body too large.")
return
}
if err := c.Request.ParseMultipartForm(chatAudioUploadMaxBytes); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "invalid multipart form: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "invalid multipart form: "+err.Error())
return
}
defer func() {
@@ -242,21 +240,20 @@ func (h *ChatHandler) ChatAudioTranscription(c *gin.Context) {
fileHeader, err := c.FormFile("file")
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Missing 'file' in multipart form-data")
+ common.RespondError(c, common.CodeArgumentError, "Missing 'file' in multipart form-data")
return
}
suffix := strings.ToLower(filepath.Ext(fileHeader.Filename))
if _, ok := chatAudioAllowedExts[suffix]; suffix == "" || !ok {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- fmt.Sprintf("Unsupported audio format: %s. Allowed: %s", suffix, chatAudioAllowedExtsList))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("Unsupported audio format: %s. Allowed: %s", suffix, chatAudioAllowedExtsList))
return
}
// Save the uploaded file to a temporary location so the model driver can read it.
tmpFile, err := os.CreateTemp("", "*"+suffix)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, "Failed to create temp audio file: "+err.Error())
+ common.RespondError(c, common.CodeServerError, "Failed to create temp audio file: "+err.Error())
return
}
tmpPath := tmpFile.Name()
@@ -264,13 +261,13 @@ func (h *ChatHandler) ChatAudioTranscription(c *gin.Context) {
defer func() { _ = os.Remove(tmpPath) }()
if err := c.SaveUploadedFile(fileHeader, tmpPath); err != nil {
- common.ErrorWithCode(c, common.CodeServerError, "Failed to save audio file: "+err.Error())
+ common.RespondError(c, common.CodeServerError, "Failed to save audio file: "+err.Error())
return
}
asrModel, err := h.modelFactory.NewDefaultASRModel(ctx, service.Identity{UserID: user.ID, TenantID: user.ID})
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -323,13 +320,13 @@ func (h *ChatHandler) ChatAudioTranscription(c *gin.Context) {
resp, err := asrModel.Transcribe(ctx, &tmpPath, &modelModule.ASRConfig{}, nil)
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
if resp == nil {
- common.ErrorWithCode(c, common.CodeServerError, "empty transcription response")
+ common.RespondError(c, common.CodeServerError, "empty transcription response")
return
}
- common.SuccessWithData(c, map[string]string{"text": resp.Text}, "success")
+ common.RespondSuccess(c, map[string]string{"text": resp.Text}, "success")
}
diff --git a/internal/handler/chat_channel.go b/internal/handler/chat_channel.go
index 1a0e874740..fd45d15939 100644
--- a/internal/handler/chat_channel.go
+++ b/internal/handler/chat_channel.go
@@ -58,13 +58,13 @@ type CreateChatChannelRequest struct {
func (h *ChatChannelHandler) CreateChatChannel(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req CreateChatChannelRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeDataError, "Invalid request: "+err.Error())
return
}
if req.Config == nil {
@@ -85,17 +85,17 @@ func (h *ChatChannelHandler) CreateChatChannel(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, row, "success")
+ common.RespondSuccess(c, row, "success")
}
// ListChatChannel handles GET /chat-channels.
func (h *ChatChannelHandler) ListChatChannel(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -105,29 +105,29 @@ func (h *ChatChannelHandler) ListChatChannel(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, rows, "success")
+ common.RespondSuccessList(c, rows, "success")
}
// GetChatChannel handles GET /chat-channels/:channel_id.
func (h *ChatChannelHandler) GetChatChannel(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "user_id is required")
+ common.RespondError(c, common.CodeArgumentError, "user_id is required")
return
}
channelID := strings.TrimSpace(c.Param("channel_id"))
if channelID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "channel_id is required")
+ common.RespondError(c, common.CodeArgumentError, "channel_id is required")
return
}
@@ -138,32 +138,32 @@ func (h *ChatChannelHandler) GetChatChannel(c *gin.Context) {
return
}
- common.SuccessWithData(c, channel, "success")
+ common.RespondSuccess(c, channel, "success")
}
// UpdateChatChannel handles PATCH /chat-channels/:channel_id.
func (h *ChatChannelHandler) UpdateChatChannel(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "user_id is required")
+ common.RespondError(c, common.CodeArgumentError, "user_id is required")
return
}
channelID := strings.TrimSpace(c.Param("channel_id"))
if channelID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "channel_id is required")
+ common.RespondError(c, common.CodeArgumentError, "channel_id is required")
return
}
var request map[string]interface{}
if err := c.ShouldBindJSON(&request); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -177,26 +177,26 @@ func (h *ChatChannelHandler) UpdateChatChannel(c *gin.Context) {
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetChatChannelRuntime returns live runtime metadata for a running chat channel.
func (h *ChatChannelHandler) GetChatChannelRuntime(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "user_id is required")
+ common.RespondError(c, common.CodeArgumentError, "user_id is required")
return
}
channelID := strings.TrimSpace(c.Param("channel_id"))
if channelID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "channel_id is required")
+ common.RespondError(c, common.CodeArgumentError, "channel_id is required")
return
}
@@ -206,37 +206,37 @@ func (h *ChatChannelHandler) GetChatChannelRuntime(c *gin.Context) {
writeChatChannelError(c, code, chatChannelErrMsg(code, err))
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// DeleteChatChannel handles DELETE /chat-channels/:channel_id.
func (h *ChatChannelHandler) DeleteChatChannel(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "user_id is required")
+ common.RespondError(c, common.CodeArgumentError, "user_id is required")
return
}
channelID := strings.TrimSpace(c.Param("channel_id"))
if channelID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "channel_id is required")
+ common.RespondError(c, common.CodeArgumentError, "channel_id is required")
return
}
ctx := c.Request.Context()
- result, code, err := h.chatChannelService.DeleteChatChannel(ctx, userID, channelID)
+ _, code, err := h.chatChannelService.DeleteChatChannel(ctx, userID, channelID)
if code != common.CodeSuccess || err != nil {
writeChatChannelError(c, code, chatChannelErrMsg(code, err))
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, nil, "success")
}
func unwrapChatChannelPayload(payload map[string]interface{}) map[string]interface{} {
@@ -247,7 +247,7 @@ func unwrapChatChannelPayload(payload map[string]interface{}) map[string]interfa
}
func writeChatChannelError(c *gin.Context, code common.ErrorCode, message string) {
- common.ResponseWithCodeData(c, code, nil, message)
+ common.RespondError(c, code, message)
}
func chatChannelErrMsg(code common.ErrorCode, err error) string {
diff --git a/internal/handler/chat_channel_test.go b/internal/handler/chat_channel_test.go
index d27a989162..8014980ebe 100644
--- a/internal/handler/chat_channel_test.go
+++ b/internal/handler/chat_channel_test.go
@@ -331,8 +331,8 @@ func TestChatChannelHandlerDeleteChatChannelSuccess(t *testing.T) {
if payload["code"] != float64(common.CodeSuccess) {
t.Fatalf("payload=%v", payload)
}
- if payload["data"] != true {
- t.Fatalf("payload=%v", payload)
+ if data, exists := payload["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
}
diff --git a/internal/handler/chat_recommendation.go b/internal/handler/chat_recommendation.go
index aac3fbecce..aa21b11bdf 100644
--- a/internal/handler/chat_recommendation.go
+++ b/internal/handler/chat_recommendation.go
@@ -45,26 +45,26 @@ type ChatRecommendationRequest struct {
func (h *ChatHandler) Recommendation(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req ChatRecommendationRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "question is required")
+ common.RespondError(c, common.CodeArgumentError, "question is required")
return
}
if strings.TrimSpace(req.Question) == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "question is required")
+ common.RespondError(c, common.CodeArgumentError, "question is required")
return
}
ctx := c.Request.Context()
questions, err := service.GenerateRelatedQuestions(ctx, req.Question, req.SearchID, h.searchSvc, h.modelFactory)
if err != nil {
common.Warn("chat recommendation failed", zap.String("error", err.Error()))
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
+ common.RespondError(c, common.CodeOperatingError, err.Error())
return
}
- common.SuccessWithData(c, questions, "success")
+ common.RespondSuccessList(c, questions, "success")
}
diff --git a/internal/handler/chat_session.go b/internal/handler/chat_session.go
index 50403ee32d..f8cc33e79c 100644
--- a/internal/handler/chat_session.go
+++ b/internal/handler/chat_session.go
@@ -74,7 +74,7 @@ func sessionHistoryQuery(c *gin.Context) (dao.ConversationHistoryOptions, error)
func (h *ChatSessionHandler) ListChatSessions(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
@@ -82,7 +82,7 @@ func (h *ChatSessionHandler) ListChatSessions(c *gin.Context) {
// Get chat_id from query parameter
chatID := c.Param("chat_id")
if chatID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "chat_id is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "chat_id is required")
return
}
@@ -112,7 +112,7 @@ func (h *ChatSessionHandler) ListChatSessions(c *gin.Context) {
orderby = queryOrderby
default:
if len(sortTerms) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("invalid orderby field: %s", queryOrderby))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("invalid orderby field: %s", queryOrderby))
return
}
}
@@ -129,7 +129,7 @@ func (h *ChatSessionHandler) ListChatSessions(c *gin.Context) {
includeHistory := c.DefaultQuery("include_history", "true")
options, err := sessionHistoryQuery(c)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
options.NoHistory = includeHistory == "false" || includeHistory == "False"
@@ -138,11 +138,11 @@ func (h *ChatSessionHandler) ListChatSessions(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithDataAndTotal(c, result.Sessions, result.Total, "success")
+ common.RespondSuccessList(c, result.Sessions, "success", result.Total)
}
type ChatCompletionsRequest struct {
@@ -181,29 +181,29 @@ type ChatCompletionsRequest struct {
func (h *ChatSessionHandler) ChatCompletions(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
var rawBody map[string]interface{}
if err := c.ShouldBindJSON(&rawBody); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if _, err := service.ResolveStoreHistoryMessages(rawBody); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
var req ChatCompletionsRequest
b, err := json.Marshal(rawBody)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if err = json.Unmarshal(b, &req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -242,7 +242,7 @@ func (h *ChatSessionHandler) ChatCompletions(c *gin.Context) {
}
if req.MaxTokens != nil {
if *req.MaxTokens <= 0 {
- common.ErrorWithCode(c, common.CodeBadRequest, "`max_tokens` must be greater than 0.")
+ common.RespondError(c, common.CodeBadRequest, "`max_tokens` must be greater than 0.")
return
}
genConfig["max_tokens"] = *req.MaxTokens
@@ -322,20 +322,20 @@ func (h *ChatSessionHandler) ChatCompletions(c *gin.Context) {
if err != nil {
var codedErr *common.CodedError
if errors.As(err, &codedErr) {
- common.ErrorWithCode(c, codedErr.Code, codedErr.Message)
+ common.RespondError(c, codedErr.Code, codedErr.Message)
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithData(c, result, "")
+ common.RespondSuccess(c, result, "")
}
}
func (h *ChatSessionHandler) GetSession(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -345,7 +345,7 @@ func (h *ChatSessionHandler) GetSession(c *gin.Context) {
ctx := c.Request.Context()
options, err := sessionHistoryQuery(c)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
result, code, err := h.chatSessionService.GetSession(ctx, userID, chatID, sessionID, options)
@@ -353,29 +353,29 @@ func (h *ChatSessionHandler) GetSession(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// CreateSession create a session in a dialog
func (h *ChatSessionHandler) CreateSession(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "user_id is required")
+ common.RespondError(c, common.CodeBadRequest, "user_id is required")
return
}
chatID := strings.TrimSpace(c.Param("chat_id"))
if chatID == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "chat_id is required")
+ common.RespondError(c, common.CodeBadRequest, "chat_id is required")
return
}
@@ -385,7 +385,7 @@ func (h *ChatSessionHandler) CreateSession(c *gin.Context) {
req = map[string]interface{}{}
} else {
// Mirror Python's malformed-JSON contract message.
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Malformed JSON syntax: Missing commas/brackets or invalid encoding")
+ common.RespondError(c, common.CodeArgumentError, "Malformed JSON syntax: Missing commas/brackets or invalid encoding")
return
}
}
@@ -399,30 +399,30 @@ func (h *ChatSessionHandler) CreateSession(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// DeleteSessions delete a session in a dialog
func (h *ChatSessionHandler) DeleteSessions(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
chatID := strings.TrimSpace(c.Param("chat_id"))
if chatID == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "chat_id is required")
+ common.RespondError(c, common.CodeBadRequest, "chat_id is required")
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "user_id is required")
+ common.RespondError(c, common.CodeBadRequest, "user_id is required")
return
}
@@ -432,7 +432,7 @@ func (h *ChatSessionHandler) DeleteSessions(c *gin.Context) {
req = map[string]interface{}{}
} else {
// Mirror Python's malformed-JSON contract message.
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Malformed JSON syntax: Missing commas/brackets or invalid encoding")
+ common.RespondError(c, common.CodeArgumentError, "Malformed JSON syntax: Missing commas/brackets or invalid encoding")
return
}
}
@@ -446,17 +446,17 @@ func (h *ChatSessionHandler) DeleteSessions(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, message)
+ common.RespondSuccess(c, result, message)
}
func (h *ChatSessionHandler) UpdateSession(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -466,7 +466,7 @@ func (h *ChatSessionHandler) UpdateSession(c *gin.Context) {
// An empty payload is a valid no-op (mirrors Python's update_session).
req := map[string]any{}
if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
@@ -476,16 +476,16 @@ func (h *ChatSessionHandler) UpdateSession(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func (h *ChatSessionHandler) DeleteSessionMessage(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
@@ -497,16 +497,16 @@ func (h *ChatSessionHandler) DeleteSessionMessage(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func (h *ChatSessionHandler) UpdateMessageFeedback(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -516,15 +516,14 @@ func (h *ChatSessionHandler) UpdateMessageFeedback(c *gin.Context) {
req := map[string]interface{}{}
if err := c.ShouldBindJSON(&req); err != nil {
if errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "Request body cannot be empty")
+ common.RespondError(c, common.CodeArgumentError, "Request body cannot be empty")
return
}
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
if len(req) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Request body cannot be empty")
+ common.RespondError(c, common.CodeArgumentError, "Request body cannot be empty")
return
}
@@ -533,8 +532,8 @@ func (h *ChatSessionHandler) UpdateMessageFeedback(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
diff --git a/internal/handler/chat_test.go b/internal/handler/chat_test.go
index 3b7b2b67cd..8f0d483069 100644
--- a/internal/handler/chat_test.go
+++ b/internal/handler/chat_test.go
@@ -97,8 +97,8 @@ func TestDeleteChatHandlerSuccess(t *testing.T) {
if resp["code"] != float64(common.CodeSuccess) {
t.Fatalf("expected success code, got %v", resp["code"])
}
- if resp["data"] != true {
- t.Fatalf("expected data=true, got %v", resp["data"])
+ if data, exists := resp["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
}
diff --git a/internal/handler/chunk.go b/internal/handler/chunk.go
index efa7e53c88..2d23cc9319 100644
--- a/internal/handler/chunk.go
+++ b/internal/handler/chunk.go
@@ -70,7 +70,7 @@ func NewChunkHandler(chunkService chunkService, userService *service.UserService
func (h *ChunkHandler) Get(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -78,7 +78,7 @@ func (h *ChunkHandler) Get(c *gin.Context) {
documentID := c.Param("document_id")
chunkID := c.Param("chunk_id")
if datasetID == "" || documentID == "" || chunkID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "dataset_id, document_id and chunk_id are required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "dataset_id, document_id and chunk_id are required")
return
}
@@ -94,71 +94,71 @@ func (h *ChunkHandler) Get(c *gin.Context) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithData(c, resp.Chunk, "success")
+ common.RespondSuccess(c, resp.Chunk, "success")
}
// Parse reparse the datasets' files
func (h *ChunkHandler) Parse(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "user_id is required")
+ common.RespondError(c, common.CodeArgumentError, "user_id is required")
return
}
datasetId := strings.TrimSpace(c.Param("dataset_id"))
if datasetId == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "dataset_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "dataset_id is required")
return
}
var req service.ParseFileRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
ctx := c.Request.Context()
data, code, err := h.chunkService.Parse(ctx, userID, datasetId, &req)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.ResponseWithCodeData(c, code, data, "success")
+ common.RespondSuccess(c, data, "success")
}
// ListChunks retrieves chunks for a document from path/query parameters.
func (h *ChunkHandler) ListChunks(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := c.Param("dataset_id")
documentID := c.Param("document_id")
if datasetID == "" || documentID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "dataset_id and document_id are required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "dataset_id and document_id are required")
return
}
page, err := parsePositiveQueryInt(c, "page", 1)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
size, err := parsePositiveQueryInt(c, "page_size", 30)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
@@ -175,7 +175,7 @@ func (h *ChunkHandler) ListChunks(c *gin.Context) {
}
available, ok, err := parseAvailableQuery(c.Query("available"))
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
if ok {
@@ -188,11 +188,11 @@ func (h *ChunkHandler) ListChunks(c *gin.Context) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
return
}
- common.SuccessWithData(c, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
func queryStringList(c *gin.Context, name string) []string {
@@ -243,34 +243,30 @@ func parseAvailableQuery(raw string) (int, bool, error) {
func (h *ChunkHandler) StopParsing(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := c.Param("dataset_id")
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeDataError, "dataset_id is required")
return
}
var req service.StopParsingRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if len(req.DocumentIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "`document_ids` is required")
+ common.RespondError(c, common.CodeDataError, "`document_ids` is required")
return
}
ctx := c.Request.Context()
resp, code, err := h.chunkService.StopParsing(ctx, user.ID, datasetID, req)
if err != nil {
- var data interface{}
- if resp != nil {
- data = resp.Data
- }
- common.ResponseWithCodeData(c, code, data, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
@@ -283,56 +279,56 @@ func (h *ChunkHandler) StopParsing(c *gin.Context) {
data = resp.Data
}
- common.SuccessWithData(c, data, message)
+ common.RespondSuccess(c, data, message)
}
// SwitchChunks enable or disable a chunk
func (h *ChunkHandler) SwitchChunks(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeAuthenticationError, nil, "user_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeAuthenticationError, nil, "user_id is required")
return
}
// Get required ID
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "dataset_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "dataset_id is required")
return
}
documentID := strings.TrimSpace(c.Param("document_id"))
if documentID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "document_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "document_id is required")
return
}
var rawBody map[string]interface{}
if err := json.NewDecoder(c.Request.Body).Decode(&rawBody); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
chunkIDs, ok := parseStringSlice(rawBody["chunk_ids"])
if !ok || len(chunkIDs) == 0 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "`chunk_ids` is required.")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "`chunk_ids` is required.")
return
}
if rawBody["available_int"] == nil && rawBody["available"] == nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "`available_int` or `available` is required.")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "`available_int` or `available` is required.")
return
}
availableInt, err := parseAvailableBody(rawBody)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
@@ -341,11 +337,11 @@ func (h *ChunkHandler) SwitchChunks(c *gin.Context) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
func parseStringSlice(raw interface{}) ([]string, bool) {
@@ -424,7 +420,7 @@ func optionalBodyString(rawBody map[string]interface{}, field, typeMessage strin
func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -435,7 +431,7 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
err = json.Unmarshal(body, &rawBody)
}
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "invalid JSON body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "invalid JSON body: "+err.Error())
return
}
// The same body, undecoded, for the list validator shared with AddChunk.
@@ -446,20 +442,20 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
// Get required ID fields
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "dataset_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "dataset_id is required")
return
}
chunkID := strings.TrimSpace(c.Param("chunk_id"))
if chunkID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "chunk_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "chunk_id is required")
return
}
// Get document_id from request
documentID := strings.TrimSpace(c.Param("document_id"))
if documentID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "document_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "document_id is required")
return
}
@@ -477,7 +473,7 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
}
for field := range rawBody {
if field != "dataset_id" && field != "document_id" && field != "chunk_id" && !allowedFields[field] {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Update field '"+field+"' is not supported. Updatable fields: content, important_keywords, questions, available, positions, image_base64, image_update_mode, tag_kwd, tag_feas")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Update field '"+field+"' is not supported. Updatable fields: content, important_keywords, questions, available, positions, image_base64, image_update_mode, tag_kwd, tag_feas")
return
}
}
@@ -486,14 +482,14 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
var req service.UpdateChunkRequest
content, err := optionalBodyString(rawBody, "content", "`content` must be a string")
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
req.Content = content
for _, field := range []string{"important_keywords", "questions"} {
values, err := addChunkStringListField(rawFields, field, "`"+field+"` is required to be a list", "`"+field+"` must be a list of strings")
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeDataError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeDataError, nil, err.Error())
return
}
if field == "important_keywords" {
@@ -505,7 +501,7 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
if raw, exists := rawBody["available"]; exists {
available, ok := raw.(bool)
if !ok {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "`available` must be a boolean")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "`available` must be a boolean")
return
}
req.Available = &available
@@ -515,19 +511,19 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
}
tagKwd, err := addChunkStringListField(rawFields, "tag_kwd", "`tag_kwd` is required to be a list", "`tag_kwd` must be a list of strings")
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeDataError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeDataError, nil, err.Error())
return
}
req.TagKwd = tagKwd
req.TagFeas = rawBody["tag_feas"]
imageBase64, err := optionalBodyString(rawBody, "image_base64", "`image_base64` must be a non-empty string")
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeDataError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeDataError, nil, err.Error())
return
}
imageUpdateMode, err := optionalBodyString(rawBody, "image_update_mode", "`image_update_mode` must be a string")
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeDataError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeDataError, nil, err.Error())
return
}
req.ImageBase64 = imageBase64
@@ -550,16 +546,16 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
if errors.As(err, &coded) {
switch coded.Code() {
case common.CodeArgumentError, common.CodeBadRequest, common.CodeDataError:
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, coded.Code(), nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, coded.Code(), nil, err.Error())
return
}
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithMessage(c, "chunk updated successfully")
+ common.RespondSuccess(c, nil, "chunk updated successfully")
}
// RemoveChunks handles chunk removal requests
@@ -572,20 +568,20 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {
func (h *ChunkHandler) RemoveChunks(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := c.Param("dataset_id")
docID := c.Param("document_id")
if datasetID == "" || docID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "dataset_id and document_id are required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "dataset_id and document_id are required")
return
}
var req service.RemoveChunksRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, 400, nil, err.Error())
return
}
@@ -598,11 +594,11 @@ func (h *ChunkHandler) RemoveChunks(c *gin.Context) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithData(c, deletedCount, "success")
+ common.RespondSuccess(c, gin.H{"deleted_count": deletedCount}, "success")
}
func addChunkStringField(rawBody map[string]json.RawMessage, field string) (string, error) {
@@ -664,7 +660,7 @@ func (h *ChunkHandler) AddChunk(c *gin.Context) {
ctx := c.Request.Context()
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -673,38 +669,38 @@ func (h *ChunkHandler) AddChunk(c *gin.Context) {
var rawBody map[string]json.RawMessage
if err := json.NewDecoder(c.Request.Body).Decode(&rawBody); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
content, err := addChunkStringField(rawBody, "content")
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
importantKeywords, err := addChunkStringListField(rawBody, "important_keywords", "`important_keywords` is required to be a list", "`important_keywords` must be a list of strings")
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
questions, err := addChunkStringListField(rawBody, "questions", "`questions` is required to be a list", "`questions` must be a list of strings")
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
tagKwd, err := addChunkStringListField(rawBody, "tag_kwd", "`tag_kwd` is required to be a list", "`tag_kwd` must be a list of strings")
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
imageBase64, err := addChunkStringPtrField(rawBody, "image_base64")
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
var tagFeas interface{}
if raw, ok := rawBody["tag_feas"]; ok {
if err = json.Unmarshal(raw, &tagFeas); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
}
@@ -724,12 +720,12 @@ func (h *ChunkHandler) AddChunk(c *gin.Context) {
if err != nil {
var codedErr service.ErrorCoder
if errors.As(err, &codedErr) {
- common.ResponseWithCodeData(c, codedErr.Code(), nil, addChunkResponseMessage(codedErr.Code(), err))
+ common.RespondError(c, codedErr.Code(), addChunkResponseMessage(codedErr.Code(), err))
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, addChunkResponseMessage(common.CodeServerError, err))
+ common.RespondError(c, common.CodeServerError, addChunkResponseMessage(common.CodeServerError, err))
return
}
- common.SuccessWithData(c, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
diff --git a/internal/handler/chunk_test.go b/internal/handler/chunk_test.go
index e312fc9795..195b21776a 100644
--- a/internal/handler/chunk_test.go
+++ b/internal/handler/chunk_test.go
@@ -72,11 +72,13 @@ func (m *mockChunkSvc) RemoveChunks(ctx context.Context, req *service.RemoveChun
func TestChunkRemoveUsesRouteIDs(t *testing.T) {
for _, tc := range []struct {
- name string
- err error
- code int
+ name string
+ err error
+ code int
+ count int64
}{
- {name: "success", code: 0},
+ {name: "success", code: 0, count: 1},
+ {name: "nothing deleted", code: 0, count: 0},
{name: "mismatched dataset", err: permission.ErrResourceNotFound, code: 404},
} {
t.Run(tc.name, func(t *testing.T) {
@@ -89,7 +91,7 @@ func TestChunkRemoveUsesRouteIDs(t *testing.T) {
if !reflect.DeepEqual(req.ChunkIDs, []string{"chunk-1"}) {
t.Fatalf("unexpected chunk IDs: %v", req.ChunkIDs)
}
- return 1, tc.err
+ return tc.count, tc.err
}}
r, h := setupChunkHandlerWithUser("user-1", mock)
r.DELETE("/api/v1/datasets/:dataset_id/documents/:document_id/chunks", h.RemoveChunks)
@@ -111,6 +113,12 @@ func TestChunkRemoveUsesRouteIDs(t *testing.T) {
if tc.err != nil && (payload["message"] != "Resource not found" || payload["data"] != nil) {
t.Fatalf("unexpected resource error: %s", response.Body.String())
}
+ if tc.err == nil {
+ data, ok := payload["data"].(map[string]interface{})
+ if !ok || data["deleted_count"] != float64(tc.count) {
+ t.Fatalf("unexpected deletion count: %s", response.Body.String())
+ }
+ }
})
}
}
@@ -263,8 +271,11 @@ func TestChunkHandlerSwitchChunksCallsService(t *testing.T) {
if err := json.Unmarshal(w.Body.Bytes(), &res); err != nil {
t.Fatalf("invalid JSON response: %v", err)
}
- if res["data"] != true {
- t.Fatalf("data = %v, want true", res["data"])
+ if res["code"] != float64(common.CodeSuccess) {
+ t.Fatalf("expected success, got %v", res)
+ }
+ if data, exists := res["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
}
@@ -576,7 +587,7 @@ func TestChunkStopParsingRouteRequiresDocumentIDs(t *testing.T) {
}
}
-func TestChunkStopParsing_InvalidStateIncludesPythonErrorCode(t *testing.T) {
+func TestChunkStopParsing_InvalidStateOmitsData(t *testing.T) {
r, mock := setupChunkStopParsingTest("user1")
mock.stopParsingFn = func(ctx context.Context, userID, datasetID string, req service.StopParsingRequest) (*service.StopParsingResponse, common.ErrorCode, error) {
return &service.StopParsingResponse{
@@ -599,12 +610,8 @@ func TestChunkStopParsing_InvalidStateIncludesPythonErrorCode(t *testing.T) {
if resp["code"] != float64(common.CodeDataError) {
t.Fatalf("expected data error, got %v: %s", resp["code"], w.Body.String())
}
- data, ok := resp["data"].(map[string]interface{})
- if !ok {
- t.Fatalf("expected data object, got %T", resp["data"])
- }
- if data["error_code"] != "DOC_STOP_PARSING_INVALID_STATE" {
- t.Fatalf("unexpected error_code: %v", data["error_code"])
+ if _, ok := resp["data"]; ok {
+ t.Fatalf("error response must omit data: %v", resp)
}
if resp["message"] != "can't stop parsing document that has not started or already completed" {
t.Fatalf("unexpected message: %v", resp["message"])
diff --git a/internal/handler/common.go b/internal/handler/common.go
index bb25113839..5ee53ea9cc 100644
--- a/internal/handler/common.go
+++ b/internal/handler/common.go
@@ -36,7 +36,7 @@ func permissionErrorResult(err error, hideResource bool) (common.ErrorCode, stri
func respondPermissionError(c *gin.Context, err error, hideResource bool) {
code, message := permissionErrorResult(err, hideResource)
- common.ResponseWithCodeData(c, code, nil, message)
+ common.RespondError(c, code, message)
}
func respondPermissionErrorIf(c *gin.Context, err error, hideResource bool) bool {
@@ -49,7 +49,7 @@ func respondPermissionErrorIf(c *gin.Context, err error, hideResource bool) bool
func respondHTTPPermissionError(c *gin.Context, err error, hideResource bool) {
code, message := permissionErrorResult(err, hideResource)
- common.ResponseWithHttpCodeData(c, int(code), code, nil, message)
+ common.Respond(c, int(code), code, nil, message)
}
// sortTermsFromQuery reads the `sort` parameter, a comma separated list of
diff --git a/internal/handler/compilation_template.go b/internal/handler/compilation_template.go
index e37e2270cd..e599a47ac1 100644
--- a/internal/handler/compilation_template.go
+++ b/internal/handler/compilation_template.go
@@ -45,15 +45,15 @@ func NewCompilationTemplateHandler(svc *service.CompilationTemplateService) *Com
func (h *CompilationTemplateHandler) ListBuiltins(c *gin.Context) {
_, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, msg)
+ common.RespondError(c, code, msg)
return
}
templates, err := h.compilationTemplateService.ListBuiltins(c.Request.Context())
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
- common.SuccessWithData(c, templates, "success")
+ common.RespondSuccessList(c, templates, "success")
}
// ListWikiPresets returns the wiki page-structure presets loaded from YAML.
@@ -66,13 +66,13 @@ func (h *CompilationTemplateHandler) ListBuiltins(c *gin.Context) {
func (h *CompilationTemplateHandler) ListWikiPresets(c *gin.Context) {
_, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, msg)
+ common.RespondError(c, code, msg)
return
}
presets, err := h.compilationTemplateService.LoadWikiPresets()
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
- common.SuccessWithData(c, presets, "success")
+ common.RespondSuccessList(c, presets, "success")
}
diff --git a/internal/handler/compilation_template_group.go b/internal/handler/compilation_template_group.go
index d48f2039f2..e21e0f53ea 100644
--- a/internal/handler/compilation_template_group.go
+++ b/internal/handler/compilation_template_group.go
@@ -57,7 +57,7 @@ func NewCompilationTemplateGroupHandler(svc *service.CompilationTemplateGroupSer
func (h *CompilationTemplateGroupHandler) List(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, msg)
+ common.RespondError(c, code, msg)
return
}
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
@@ -85,7 +85,7 @@ func (h *CompilationTemplateGroupHandler) List(c *gin.Context) {
groups, err := h.compilationTemplateGroupService.ListSaved(c.Request.Context(), tenantID, keywords, scope, terms)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
total := len(groups)
@@ -101,7 +101,7 @@ func (h *CompilationTemplateGroupHandler) List(c *gin.Context) {
groups = groups[start:end]
}
}
- common.SuccessWithData(c, gin.H{"groups": groups, "total": total}, "success")
+ common.RespondSuccess(c, gin.H{"groups": groups, "total": total}, "success")
}
// Get returns a single compilation template group.
@@ -115,20 +115,20 @@ func (h *CompilationTemplateGroupHandler) List(c *gin.Context) {
func (h *CompilationTemplateGroupHandler) Get(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, msg)
+ common.RespondError(c, code, msg)
return
}
id := c.Param("group_id")
group, err := h.compilationTemplateGroupService.GetSaved(c.Request.Context(), user.ID, id)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
if group == nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Cannot find compilation template group "+id+".")
+ common.RespondError(c, common.CodeNotFound, "Cannot find compilation template group "+id+".")
return
}
- common.SuccessWithData(c, group, "success")
+ common.RespondSuccess(c, group, "success")
}
// Save creates a new compilation template group with its child templates.
@@ -142,24 +142,24 @@ func (h *CompilationTemplateGroupHandler) Get(c *gin.Context) {
func (h *CompilationTemplateGroupHandler) Save(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, msg)
+ common.RespondError(c, code, msg)
return
}
var req service.GroupRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
if err := service.ValidateGroupRequest(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
group, err := h.compilationTemplateGroupService.CreateGroup(c.Request.Context(), user.ID, &req)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, group, "success")
+ common.RespondSuccess(c, group, "success")
}
// Update applies a partial update to a compilation template group.
@@ -174,40 +174,40 @@ func (h *CompilationTemplateGroupHandler) Save(c *gin.Context) {
func (h *CompilationTemplateGroupHandler) Update(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, msg)
+ common.RespondError(c, code, msg)
return
}
id := c.Param("group_id")
var req service.GroupRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid request: "+err.Error())
return
}
if err := service.ValidateGroupRequest(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if req.Name != "" {
nameExists, nerr := h.compilationTemplateGroupService.NameExists(c.Request.Context(), user.ID, req.Name, id)
if nerr != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, nerr.Error())
+ common.RespondError(c, common.CodeExceptionError, nerr.Error())
return
}
if nameExists {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Duplicated compilation template group name.")
+ common.RespondError(c, common.CodeDataError, "Duplicated compilation template group name.")
return
}
}
group, err := h.compilationTemplateGroupService.UpdateGroup(c.Request.Context(), user.ID, id, &req)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if group == nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Cannot find compilation template group "+id+".")
+ common.RespondError(c, common.CodeNotFound, "Cannot find compilation template group "+id+".")
return
}
- common.SuccessWithData(c, group, "success")
+ common.RespondSuccess(c, group, "success")
}
// Delete soft-deletes a compilation template group and its children.
@@ -221,18 +221,18 @@ func (h *CompilationTemplateGroupHandler) Update(c *gin.Context) {
func (h *CompilationTemplateGroupHandler) Delete(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, msg)
+ common.RespondError(c, code, msg)
return
}
id := c.Param("group_id")
ok, err := h.compilationTemplateGroupService.DeleteGroup(c.Request.Context(), user.ID, id)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
if !ok {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Cannot find compilation template group "+id+".")
+ common.RespondError(c, common.CodeNotFound, "Cannot find compilation template group "+id+".")
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
diff --git a/internal/handler/components.go b/internal/handler/components.go
index 35e4fd0c2d..23270e583f 100644
--- a/internal/handler/components.go
+++ b/internal/handler/components.go
@@ -68,17 +68,17 @@ func (h *ComponentsHandler) Get(c *gin.Context) {
raw := c.Query("category")
cats, err := parseCategories(raw)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, 400, nil, err.Error())
return
}
out, err := h.svc.List(cats...)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithData(c, out, "success")
+ common.RespondSuccessList(c, out, "success")
}
// parseCategories splits a comma-separated category query string into
diff --git a/internal/handler/connector.go b/internal/handler/connector.go
index d984d547ca..a8ba66f68b 100644
--- a/internal/handler/connector.go
+++ b/internal/handler/connector.go
@@ -79,7 +79,7 @@ func NewConnectorHandler(connectorService *service.ConnectorService, userService
func (h *ConnectorHandler) ListConnectors(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
@@ -91,11 +91,11 @@ func (h *ConnectorHandler) ListConnectors(c *gin.Context) {
if connectorErrorResponse(c, err) {
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithData(c, result.Connectors, "success")
+ common.RespondSuccessList(c, result.Connectors, "success")
}
// connectorErrorResponse maps service sentinel errors to the response codes used
@@ -107,17 +107,17 @@ func connectorErrorResponse(c *gin.Context, err error) bool {
return false
case permissionresponse.IsPermissionError(err):
code, permissionErr := permissionresponse.NormalizeHidden(err)
- common.ErrorWithCode(c, code, permissionErr.Error())
+ common.RespondError(c, code, permissionErr.Error())
case errors.Is(err, service.ErrConnectorIDRequired):
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
case errors.Is(err, service.ErrConnectorNotFound):
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Can't find this Connector!")
+ common.RespondError(c, common.CodeDataError, "Can't find this Connector!")
case errors.Is(err, service.ErrConnectorTestUnsupported):
- common.ResponseWithCodeData(c, common.CodeNotImplemented, false, err.Error())
+ common.RespondError(c, common.CodeNotImplemented, err.Error())
case errors.Is(err, service.ErrConnectorSourceNotImplemented):
- common.ResponseWithCodeData(c, common.CodeNotImplemented, false, err.Error())
+ common.RespondError(c, common.CodeNotImplemented, err.Error())
default:
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
}
return true
}
@@ -133,7 +133,7 @@ func connectorErrorResponse(c *gin.Context, err error) bool {
func (h *ConnectorHandler) GetConnector(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
@@ -143,20 +143,20 @@ func (h *ConnectorHandler) GetConnector(c *gin.Context) {
return
}
- common.SuccessWithData(c, connector, "success")
+ common.RespondSuccess(c, connector, "success")
}
// UpdateConnector Update an accessible connector's polling configuration.
func (h *ConnectorHandler) UpdateConnector(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
req, err := decodeUpdateConnectorRequest(c)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -164,11 +164,11 @@ func (h *ConnectorHandler) UpdateConnector(c *gin.Context) {
connector, code, err := h.connectorService.UpdateConnector(ctx, c.Param("connector_id"), user.ID, req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, connector, "success")
+ common.RespondSuccess(c, connector, "success")
}
func decodeUpdateConnectorRequest(c *gin.Context) (*service.UpdateConnectorRequest, error) {
@@ -209,7 +209,7 @@ func decodeUpdateConnectorRequest(c *gin.Context) (*service.UpdateConnectorReque
func (h *ConnectorHandler) ListLogs(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -217,7 +217,7 @@ func (h *ConnectorHandler) ListLogs(c *gin.Context) {
if rawPage := strings.TrimSpace(c.DefaultQuery("page", "1")); rawPage != "" {
parsedPage, err := strconv.Atoi(rawPage)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, "page must be an integer")
+ common.RespondError(c, common.CodeArgumentError, "page must be an integer")
return
}
page = parsedPage
@@ -227,7 +227,7 @@ func (h *ConnectorHandler) ListLogs(c *gin.Context) {
if rawPageSize := strings.TrimSpace(c.DefaultQuery("page_size", "15")); rawPageSize != "" {
parsedPageSize, err := strconv.Atoi(rawPageSize)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, "page_size must be an integer")
+ common.RespondError(c, common.CodeArgumentError, "page_size must be an integer")
return
}
pageSize = parsedPageSize
@@ -237,14 +237,14 @@ func (h *ConnectorHandler) ListLogs(c *gin.Context) {
logs, total, code, err := h.connectorService.ListLog(ctx, c.Param("connector_id"), user.ID, page, pageSize)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
if logs == nil {
logs = []*entity.ConnectorSyncLog{}
}
- common.SuccessWithData(c, gin.H{"total": total, "logs": logs}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "logs": logs}, "success")
}
// ListSyncLogs handles GET /api/v1/connectors/sync-logs.
@@ -260,7 +260,7 @@ func (h *ConnectorHandler) ListLogs(c *gin.Context) {
func (h *ConnectorHandler) ListSyncLogs(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -269,7 +269,7 @@ func (h *ConnectorHandler) ListSyncLogs(c *gin.Context) {
if rawPage := strings.TrimSpace(c.Query("page")); rawPage != "" {
parsedPage, err := strconv.Atoi(rawPage)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, "page must be an integer")
+ common.RespondError(c, common.CodeArgumentError, "page must be an integer")
return
}
page = parsedPage
@@ -277,7 +277,7 @@ func (h *ConnectorHandler) ListSyncLogs(c *gin.Context) {
if rawPageSize := strings.TrimSpace(c.Query("page_size")); rawPageSize != "" {
parsedPageSize, err := strconv.Atoi(rawPageSize)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, "page_size must be an integer")
+ common.RespondError(c, common.CodeArgumentError, "page_size must be an integer")
return
}
pageSize = parsedPageSize
@@ -289,14 +289,14 @@ func (h *ConnectorHandler) ListSyncLogs(c *gin.Context) {
logs, total, code, err := h.connectorService.ListLogs(ctx, user.ID, datasetID, page, pageSize)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
if logs == nil {
logs = []*entity.ConnectorSyncLog{}
}
- common.SuccessWithData(c, gin.H{"total": total, "logs": logs}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "logs": logs}, "success")
}
// CreateConnector create connector
@@ -310,26 +310,26 @@ func (h *ConnectorHandler) ListSyncLogs(c *gin.Context) {
func (h *ConnectorHandler) CreateConnector(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.CreateConnectorRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
if strings.TrimSpace(req.Name) == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "name is required")
+ common.RespondError(c, common.CodeDataError, "name is required")
return
}
if strings.TrimSpace(req.Source) == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "source is required")
+ common.RespondError(c, common.CodeDataError, "source is required")
return
}
if req.Config == nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "config is required")
+ common.RespondError(c, common.CodeDataError, "config is required")
return
}
@@ -338,14 +338,14 @@ func (h *ConnectorHandler) CreateConnector(c *gin.Context) {
connector, err := h.connectorService.CreateConnector(ctx, user.ID, &req)
if err != nil {
if errors.Is(err, service.ErrConnectorInvalidFreq) {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
return
}
- common.SuccessWithData(c, connector, "success")
+ common.RespondSuccess(c, connector, "success")
}
type testConnectorRequest struct {
@@ -364,13 +364,13 @@ func (h *ConnectorHandler) TestConnector(c *gin.Context) {
// check user and connector
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
connectorID := c.Param("connector_id")
if connectorID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "connector_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "connector_id is required")
return
}
@@ -381,7 +381,7 @@ func (h *ConnectorHandler) TestConnector(c *gin.Context) {
if c.Request.Body != nil && c.Request.ContentLength != 0 {
var body testConnectorRequest
if err := c.ShouldBindJSON(&body); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
return
}
// get source and config from web
@@ -411,17 +411,17 @@ func (h *ConnectorHandler) TestConnector(c *gin.Context) {
rateErr *syncerconnector.RateLimitTriedTooManyTimesError
)
if errors.As(err, &valErr) || errors.As(err, &credErr) || errors.As(err, &rateErr) {
- common.ResponseWithCodeData(c, common.CodeDataError, false, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, false, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
if connectorErrorResponse(c, err) {
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// DeleteConnector delete connector
@@ -432,19 +432,19 @@ func (h *ConnectorHandler) TestConnector(c *gin.Context) {
func (h *ConnectorHandler) DeleteConnector(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
- ok, code, err := h.connectorService.DeleteConnector(ctx, c.Param("connector_id"), user.ID)
+ _, code, err := h.connectorService.DeleteConnector(ctx, c.Param("connector_id"), user.ID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, ok, "success")
+ common.RespondSuccess(c, nil, "success")
}
// RebuildConnector rebuild connector
@@ -458,7 +458,7 @@ func (h *ConnectorHandler) DeleteConnector(c *gin.Context) {
func (h *ConnectorHandler) RebuildConnector(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -467,23 +467,23 @@ func (h *ConnectorHandler) RebuildConnector(c *gin.Context) {
KbID string `json:"kb_id" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "required argument is missing: kb_id")
+ common.RespondError(c, common.CodeDataError, "required argument is missing: kb_id")
return
}
if strings.TrimSpace(req.KbID) == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "kb_id cannot be empty")
+ common.RespondError(c, common.CodeDataError, "kb_id cannot be empty")
return
}
ctx := c.Request.Context()
- ok, code, err := h.connectorService.RebuildConnector(ctx, c.Param("connector_id"), user.ID, req.KbID)
+ _, code, err := h.connectorService.RebuildConnector(ctx, c.Param("connector_id"), user.ID, req.KbID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, ok, "success")
+ common.RespondSuccess(c, nil, "success")
}
// ResumeFailedSync resumes a failed connector sync task from checkpoint. (when network outage)
@@ -497,35 +497,35 @@ func (h *ConnectorHandler) RebuildConnector(c *gin.Context) {
func (h *ConnectorHandler) ResumeFailedSync(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.ResumeFailedSyncRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "required argument is missing: kb_id or task_id")
+ common.RespondError(c, common.CodeDataError, "required argument is missing: kb_id or task_id")
return
}
ctx := c.Request.Context()
- ok, code, err := h.connectorService.ResumeFailedSync(ctx, c.Param("connector_id"), user.ID, &req)
+ _, code, err := h.connectorService.ResumeFailedSync(ctx, c.Param("connector_id"), user.ID, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, ok, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *ConnectorHandler) StartGoogleWebOAuth(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.StartGoogleWebOAuthRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -533,23 +533,23 @@ func (h *ConnectorHandler) StartGoogleWebOAuth(c *gin.Context) {
data, code, err := h.connectorService.StartGoogleWebOAuth(ctx, user.ID, c.DefaultQuery("type", "google-drive"), &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
func (h *ConnectorHandler) PollGoogleWebOAuthResult(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.PollGoogleWebOAuthResultRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
return
}
@@ -557,11 +557,11 @@ func (h *ConnectorHandler) PollGoogleWebOAuthResult(c *gin.Context) {
data, code, err := h.connectorService.PollGoogleWebOAuthResult(ctx, user.ID, c.Query("type"), &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
func (h *ConnectorHandler) GoogleWebOAuthCallback(c *gin.Context) {
@@ -592,22 +592,22 @@ func (h *ConnectorHandler) googleWebOAuthCallback(c *gin.Context, source string)
func (h *ConnectorHandler) StartBoxWebOAuth(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.StartBoxWebOAuthRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
ctx := c.Request.Context()
resp, code, err := h.connectorService.StartBoxWebOAuth(ctx, user.ID, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.ResponseWithCodeData(c, code, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
func (h *ConnectorHandler) BoxWebOAuthCallback(c *gin.Context) {
@@ -626,20 +626,20 @@ func (h *ConnectorHandler) BoxWebOAuthCallback(c *gin.Context) {
func (h *ConnectorHandler) PollBoxWebOAuthResult(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.PollBoxWebOAuthResultRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
ctx := c.Request.Context()
resp, code, err := h.connectorService.PollBoxWebOAuthResult(ctx, user.ID, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.ResponseWithCodeData(c, code, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
diff --git a/internal/handler/connector_test.go b/internal/handler/connector_test.go
index 8a8296511e..b47cefbccb 100644
--- a/internal/handler/connector_test.go
+++ b/internal/handler/connector_test.go
@@ -461,20 +461,17 @@ func TestConnectorHandlerDeleteConnector(t *testing.T) {
name string
service fakeConnectorService
wantCode common.ErrorCode
- wantData interface{}
wantMsg string
}{
{
name: "success",
service: fakeConnectorService{},
wantCode: common.CodeSuccess,
- wantData: true,
},
{
name: "unauthorized",
service: fakeConnectorService{code: common.CodeAuthenticationError, err: fmt.Errorf("no authorization")},
wantCode: common.CodeAuthenticationError,
- wantData: nil,
wantMsg: "no authorization",
},
}
@@ -502,8 +499,8 @@ func TestConnectorHandlerDeleteConnector(t *testing.T) {
if body["code"] != float64(tt.wantCode) {
t.Fatalf("code=%v body=%v", body["code"], body)
}
- if body["data"] != tt.wantData {
- t.Fatalf("data=%v body=%v", body["data"], body)
+ if data, exists := body["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
if tt.wantMsg != "" && body["message"] != tt.wantMsg {
t.Fatalf("message=%v", body["message"])
diff --git a/internal/handler/dataset.go b/internal/handler/dataset.go
index fbb7dfbb85..c25bf862a2 100644
--- a/internal/handler/dataset.go
+++ b/internal/handler/dataset.go
@@ -72,7 +72,7 @@ func NewDatasetsHandler(datasetsService *dataset.DatasetService, metadataService
func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -80,17 +80,17 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
ctx := c.Request.Context()
data, code, err := h.datasetsService.ListDatasetFilters(ctx, user.ID, c.Query("canvas_id"))
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
return
}
// Mirror pydantic's extra="forbid" on ListDatasetReq.
for param := range c.Request.URL.Query() {
if !listDatasetsAllowedParams[param] {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("Extra inputs are not permitted: %s", param))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("Extra inputs are not permitted: %s", param))
return
}
}
@@ -100,11 +100,11 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
if pageStr := c.Query("page"); pageStr != "" {
p, err := strconv.Atoi(pageStr)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Input should be a valid integer, unable to parse string as an integer")
+ common.RespondError(c, common.CodeArgumentError, "Input should be a valid integer, unable to parse string as an integer")
return
}
if p < 1 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Input should be greater than or equal to 1")
+ common.RespondError(c, common.CodeArgumentError, "Input should be greater than or equal to 1")
return
}
page = p
@@ -114,11 +114,11 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
ps, err := strconv.Atoi(pageSizeStr)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Input should be a valid integer, unable to parse string as an integer")
+ common.RespondError(c, common.CodeArgumentError, "Input should be a valid integer, unable to parse string as an integer")
return
}
if ps < 1 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Input should be greater than or equal to 1")
+ common.RespondError(c, common.CodeArgumentError, "Input should be greater than or equal to 1")
return
}
pageSize = ps
@@ -131,7 +131,7 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
if queryOrderby, exists := c.GetQuery("orderby"); exists {
if queryOrderby != "create_time" && queryOrderby != "update_time" {
if len(sortTerms) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Input should be 'create_time' or 'update_time'")
+ common.RespondError(c, common.CodeArgumentError, "Input should be 'create_time' or 'update_time'")
return
}
} else {
@@ -144,7 +144,7 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
parsed, ok := parsePythonBool(descStr)
if !ok {
if len(sortTerms) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Input should be a valid boolean, unable to interpret input")
+ common.RespondError(c, common.CodeArgumentError, "Input should be a valid boolean, unable to interpret input")
return
}
} else {
@@ -167,7 +167,7 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
// Mirror pydantic: a present-but-empty id fails UUID validation.
if rawID, exists := c.GetQuery("id"); exists {
if _, err := dataset.NormalizeDatasetID(strings.TrimSpace(rawID)); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
}
@@ -184,7 +184,7 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
}
normalizedID, err := dataset.NormalizeDatasetID(strings.TrimSpace(value))
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
seen[normalizedID]++
@@ -200,7 +200,7 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
}
}
if len(duplicates) > 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("duplicate ids: '%s'", strings.Join(duplicates, ", ")))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("duplicate ids: '%s'", strings.Join(duplicates, ", ")))
return
}
}
@@ -221,7 +221,7 @@ func (h *DatasetsHandler) ListDatasets(c *gin.Context) {
c.Query("canvas_id"),
)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
@@ -250,7 +250,7 @@ func (h *DatasetsHandler) CreateDataset(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -265,7 +265,7 @@ func (h *DatasetsHandler) CreateDataset(c *gin.Context) {
}
if _, exists := raw["ext"]; exists {
err = fmt.Errorf("extra inputs are not permitted: ext")
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = err
return
@@ -273,7 +273,7 @@ func (h *DatasetsHandler) CreateDataset(c *gin.Context) {
for field := range raw {
if !createDatasetAllowedFields[field] {
err = fmt.Errorf("extra inputs are not permitted: %s", field)
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = err
return
@@ -282,7 +282,7 @@ func (h *DatasetsHandler) CreateDataset(c *gin.Context) {
var req service.CreateDatasetRequest
if err = json.Unmarshal(bodyBytes, &req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
operationLog.Code = int(common.CodeDataError)
operationLog.Error = err
return
@@ -293,7 +293,7 @@ func (h *DatasetsHandler) CreateDataset(c *gin.Context) {
if req.Name == "" || (len(bodyBytes) > 0 && jsonNullValue(bodyBytes, "name")) {
err = fmt.Errorf("field validation for 'name' failed on the 'required' tag")
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
operationLog.Code = int(common.CodeDataError)
operationLog.Error = err
return
@@ -312,16 +312,16 @@ func (h *DatasetsHandler) CreateDataset(c *gin.Context) {
if quotaErr := billingService.CheckResources(ctx, tenantID, billing.ResourceDelta{Apps: 1}); quotaErr != nil {
var insufficient *billing.InsufficientResourceError
if errors.As(quotaErr, &insufficient) {
- common.ResponseWithDetail(c, common.CodeBillingAppsInsufficient, quotaErr.Error(), gin.H{
+ common.RespondError(c, common.CodeBillingAppsInsufficient, quotaErr.Error(), common.ResponseOptions{Detail: gin.H{
"resource": "apps",
"current": insufficient.Current,
"limit": insufficient.Limit,
- })
+ }})
operationLog.Code = int(common.CodeBillingAppsInsufficient)
operationLog.Error = insufficient
return
}
- common.ErrorWithCode(c, common.CodeServerError, quotaErr.Error())
+ common.RespondError(c, common.CodeServerError, quotaErr.Error())
operationLog.Code = int(common.CodeServerError)
operationLog.Error = quotaErr
return
@@ -330,20 +330,20 @@ func (h *DatasetsHandler) CreateDataset(c *gin.Context) {
result, code, err := h.datasetsService.CreateDataset(ctx, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetDataset handles GET /api/v1/datasets/:dataset_id.
func (h *DatasetsHandler) GetDataset(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -352,11 +352,11 @@ func (h *DatasetsHandler) GetDataset(c *gin.Context) {
datasetID := c.Param("dataset_id")
result, code, err := h.datasetsService.GetDataset(ctx, datasetID, user.ID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// UpdateDataset Update a dataset.
@@ -377,24 +377,24 @@ func parsePythonBool(s string) (bool, bool) {
// writes the error response and returns ok=false.
func parseJSONRequestObject(c *gin.Context) ([]byte, map[string]interface{}, error) {
if c.ContentType() != "application/json" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("Unsupported content type: Expected application/json, got %s", c.GetHeader("Content-Type")))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("Unsupported content type: Expected application/json, got %s", c.GetHeader("Content-Type")))
return nil, nil, fmt.Errorf("unsupported content type: Expected application/json, got %s", c.GetHeader("Content-Type"))
}
body, err := c.GetRawData()
if err != nil || len(body) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Malformed JSON syntax: Missing commas/brackets or invalid encoding")
+ common.RespondError(c, common.CodeArgumentError, "Malformed JSON syntax: Missing commas/brackets or invalid encoding")
return nil, nil, fmt.Errorf("malformed JSON syntax: Missing commas/brackets or invalid encoding")
}
var payload interface{}
if err = json.Unmarshal(body, &payload); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Malformed JSON syntax: Missing commas/brackets or invalid encoding")
+ common.RespondError(c, common.CodeArgumentError, "Malformed JSON syntax: Missing commas/brackets or invalid encoding")
return nil, nil, err
}
raw, isObject := payload.(map[string]interface{})
if !isObject {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("Invalid request payload: expected object, got %s", pythonJSONTypeName(payload)))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("Invalid request payload: expected object, got %s", pythonJSONTypeName(payload)))
return nil, nil, fmt.Errorf("invalid request payload: expected object, got %s", pythonJSONTypeName(payload))
}
return body, raw, nil
@@ -473,7 +473,7 @@ func (h *DatasetsHandler) UpdateDataset(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -481,7 +481,7 @@ func (h *DatasetsHandler) UpdateDataset(c *gin.Context) {
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "user id is required")
+ common.RespondError(c, common.CodeDataError, "user id is required")
operationLog.Code = int(common.CodeDataError)
operationLog.Error = errors.New("user id is required")
return
@@ -489,14 +489,14 @@ func (h *DatasetsHandler) UpdateDataset(c *gin.Context) {
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "dataset id is required")
+ common.RespondError(c, common.CodeBadRequest, "dataset id is required")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("dataset id is required")
return
}
if _, err := dataset.NormalizeDatasetID(datasetID); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = err
return
@@ -512,7 +512,7 @@ func (h *DatasetsHandler) UpdateDataset(c *gin.Context) {
var req service.UpdateDatasetRequest
if err = json.Unmarshal(bodyBytes, &req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
operationLog.Code = int(common.CodeDataError)
operationLog.Error = err
return
@@ -526,7 +526,7 @@ func (h *DatasetsHandler) UpdateDataset(c *gin.Context) {
// Mirror pydantic's extra="forbid" on UpdateDatasetReq.
for field := range providedFields {
if !updateDatasetAllowedFields[field] {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("Extra inputs are not permitted: %s", field))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("Extra inputs are not permitted: %s", field))
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = fmt.Errorf("extra inputs are not permitted: %s", field)
return
@@ -536,7 +536,7 @@ func (h *DatasetsHandler) UpdateDataset(c *gin.Context) {
var config map[string]interface{}
if json.Unmarshal(parserConfig, &config) == nil {
if _, ok = config["ext"]; ok {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "parser_config.ext is not supported; send parser configuration fields directly")
+ common.RespondError(c, common.CodeArgumentError, "parser_config.ext is not supported; send parser configuration fields directly")
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = errors.New("parser_config.ext is not supported; send parser configuration fields directly")
return
@@ -549,25 +549,25 @@ func (h *DatasetsHandler) UpdateDataset(c *gin.Context) {
result, code, err := h.datasetsService.UpdateDataset(ctx, datasetID, userID, req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
}
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, "dataset updated failed")
+ common.RespondError(c, code, "dataset updated failed")
operationLog.Code = int(code)
operationLog.Error = errors.New("dataset updated failed")
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func (h *DatasetsHandler) GetMetadataConfig(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -576,24 +576,24 @@ func (h *DatasetsHandler) GetMetadataConfig(c *gin.Context) {
datasetID := c.Param("dataset_id")
result, code, err := h.datasetsService.GetMetadataConfig(ctx, datasetID, user.ID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func (h *DatasetsHandler) UpdateMetadataConfig(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := c.Param("dataset_id")
var req service.MetadataConfigRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -601,29 +601,29 @@ func (h *DatasetsHandler) UpdateMetadataConfig(c *gin.Context) {
result, code, err := h.datasetsService.UpdateMetadataConfig(ctx, datasetID, user.ID, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetIngestionSummary handles GET /api/v1/datasets/:dataset_id/ingestions/summary.
func (h *DatasetsHandler) GetIngestionSummary(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
datasetID := c.Param("dataset_id")
result, code, err := h.datasetsService.GetIngestionSummary(ctx, datasetID, user.ID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// ListIngestionLogs handles GET /api/v1/datasets/:dataset_id/ingestions.
@@ -631,7 +631,7 @@ func (h *DatasetsHandler) GetIngestionSummary(c *gin.Context) {
func (h *DatasetsHandler) ListIngestionLogs(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -641,8 +641,7 @@ func (h *DatasetsHandler) ListIngestionLogs(c *gin.Context) {
if pageStr := c.Query("page"); pageStr != "" {
p, err := strconv.Atoi(pageStr)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "page must be an integer")
+ common.RespondError(c, common.CodeArgumentError, "page must be an integer")
return
}
page = p
@@ -652,8 +651,7 @@ func (h *DatasetsHandler) ListIngestionLogs(c *gin.Context) {
if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
ps, err := strconv.Atoi(pageSizeStr)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "page_size must be an integer")
+ common.RespondError(c, common.CodeArgumentError, "page_size must be an integer")
return
}
pageSize = ps
@@ -663,10 +661,10 @@ func (h *DatasetsHandler) ListIngestionLogs(c *gin.Context) {
if strings.EqualFold(strings.TrimSpace(c.Query("log_type")), "datasource") {
result, code, err := h.datasetsService.ListSyncLogs(ctx, datasetID, user.ID, page, pageSize)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
@@ -685,18 +683,18 @@ func (h *DatasetsHandler) ListIngestionLogs(c *gin.Context) {
result, code, err := h.datasetsService.ListIngestionLogs(ctx, datasetID, user.ID, page, pageSize, terms, operationStatus, createDateFrom, createDateTo, logType, keywords, documentID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetIngestionLog handles GET /api/v1/datasets/:dataset_id/ingestions/:log_id.
func (h *DatasetsHandler) GetIngestionLog(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -706,11 +704,11 @@ func (h *DatasetsHandler) GetIngestionLog(c *gin.Context) {
logID := c.Param("log_id")
result, code, err := h.datasetsService.GetIngestionLog(ctx, datasetID, user.ID, logID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// ListIngestionMessages handles GET
@@ -718,7 +716,7 @@ func (h *DatasetsHandler) GetIngestionLog(c *gin.Context) {
func (h *DatasetsHandler) ListIngestionMessages(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -726,7 +724,7 @@ func (h *DatasetsHandler) ListIngestionMessages(c *gin.Context) {
if rawLimit := c.Query("limit"); rawLimit != "" {
parsed, err := strconv.Atoi(rawLimit)
if err != nil || parsed <= 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "limit must be a positive integer")
+ common.RespondError(c, common.CodeArgumentError, "limit must be a positive integer")
return
}
limit = parsed
@@ -744,10 +742,10 @@ func (h *DatasetsHandler) ListIngestionMessages(c *gin.Context) {
c.Request.Context(), c.Param("dataset_id"), user.ID, c.Param("log_id"), limit, afterID, beforeID,
)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func ingestionEventCursor(c *gin.Context, name string) (*int, bool) {
@@ -757,7 +755,7 @@ func ingestionEventCursor(c *gin.Context, name string) (*int, bool) {
}
value, err := strconv.Atoi(raw)
if err != nil || value <= 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, name+" must be a positive integer")
+ common.RespondError(c, common.CodeArgumentError, name+" must be a positive integer")
return nil, false
}
return &value, true
@@ -779,7 +777,7 @@ func (h *DatasetsHandler) DeleteDatasets(c *gin.Context) {
}()
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -798,7 +796,7 @@ func (h *DatasetsHandler) DeleteDatasets(c *gin.Context) {
for field := range rawPayload {
if field != "ids" && field != "delete_all" {
err = fmt.Errorf("extra inputs are not permitted: %s", field)
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = err
return
@@ -810,7 +808,7 @@ func (h *DatasetsHandler) DeleteDatasets(c *gin.Context) {
DeleteAll bool `json:"delete_all,omitempty"`
}
if err = json.Unmarshal(bodyBytes, &req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
operationLog.Code = int(common.CodeDataError)
operationLog.Error = err
return
@@ -828,7 +826,7 @@ func (h *DatasetsHandler) DeleteDatasets(c *gin.Context) {
}
if len(duplicates) > 0 {
err = fmt.Errorf("duplicate ids: '%s'", strings.Join(duplicates, ", "))
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = err
return
@@ -843,45 +841,45 @@ func (h *DatasetsHandler) DeleteDatasets(c *gin.Context) {
ctx := c.Request.Context()
result, code, err := h.datasetsService.DeleteDatasets(ctx, ids, req.DeleteAll)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetKnowledgeGraph handles GET /api/v1/datasets/:dataset_id/graph.
func (h *DatasetsHandler) GetKnowledgeGraph(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeDataError, "dataset_id is required")
return
}
ctx := c.Request.Context()
datasetInstance, code, err := h.datasetsService.GetDataset(ctx, datasetID, user.ID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
tenantID, _ := datasetInstance["tenant_id"].(string)
if tenantID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "tenant_id is required")
+ common.RespondError(c, common.CodeDataError, "tenant_id is required")
return
}
docEngine := engine.Get()
if docEngine == nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Document engine is not initialized")
+ common.RespondError(c, common.CodeServerError, "Document engine is not initialized")
return
}
@@ -897,7 +895,7 @@ func (h *DatasetsHandler) GetKnowledgeGraph(c *gin.Context) {
"mind_map": map[string]interface{}{},
}
if !exists {
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
@@ -917,7 +915,7 @@ func (h *DatasetsHandler) GetKnowledgeGraph(c *gin.Context) {
return
}
if searchResult == nil || len(searchResult.Chunks) == 0 {
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
@@ -928,17 +926,17 @@ func (h *DatasetsHandler) GetKnowledgeGraph(c *gin.Context) {
}
contentWithWeight, _ := chunk["content_with_weight"].(string)
if strings.TrimSpace(contentWithWeight) == "" {
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
var graphData map[string]interface{}
if err = json.Unmarshal([]byte(contentWithWeight), &graphData); err != nil {
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
if len(graphData) == 0 {
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
@@ -952,39 +950,39 @@ func (h *DatasetsHandler) GetKnowledgeGraph(c *gin.Context) {
result[graphType] = graphData
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// DeleteKnowledgeGraph handles DELETE /api/v1/datasets/:dataset_id/graph.
func (h *DatasetsHandler) DeleteKnowledgeGraph(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeDataError, "dataset_id is required")
return
}
ctx := c.Request.Context()
datasetInstance, code, err := h.datasetsService.GetDataset(ctx, datasetID, user.ID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
tenantID, _ := datasetInstance["tenant_id"].(string)
if tenantID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "tenant_id is required")
+ common.RespondError(c, common.CodeDataError, "tenant_id is required")
return
}
docEngine := engine.Get()
if docEngine == nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Document engine is not initialized")
+ common.RespondError(c, common.CodeServerError, "Document engine is not initialized")
return
}
@@ -997,7 +995,7 @@ func (h *DatasetsHandler) DeleteKnowledgeGraph(c *gin.Context) {
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// CheckEmbedding Check embedding model compatibility by sampling random chunks,
@@ -1005,43 +1003,39 @@ func (h *DatasetsHandler) DeleteKnowledgeGraph(c *gin.Context) {
func (h *DatasetsHandler) CheckEmbedding(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeDataError, "dataset_id is required")
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "user_id is required")
+ common.RespondError(c, common.CodeDataError, "user_id is required")
return
}
var req service.CheckEmbeddingRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if strings.TrimSpace(req.EmbeddingID) == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "`embd_id` is required.")
+ common.RespondError(c, common.CodeDataError, "`embd_id` is required.")
return
}
ctx := c.Request.Context()
data, code, err := h.datasetsService.CheckEmbedding(ctx, userID, datasetID, &req)
if err != nil {
- if code == common.CodeNotEffective {
- common.ResponseWithCodeData(c, code, data, err.Error())
- return
- }
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
// AggregateTags handles GET /api/v1/datasets/tags/aggregation.
@@ -1056,7 +1050,7 @@ func (h *DatasetsHandler) CheckEmbedding(c *gin.Context) {
func (h *DatasetsHandler) AggregateTags(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -1070,7 +1064,7 @@ func (h *DatasetsHandler) AggregateTags(c *gin.Context) {
}
}
if len(datasetIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Lack of dataset_ids in query parameters")
+ common.RespondError(c, common.CodeDataError, "Lack of dataset_ids in query parameters")
return
}
@@ -1078,10 +1072,10 @@ func (h *DatasetsHandler) AggregateTags(c *gin.Context) {
result, code, err := h.datasetsService.AggregateTags(ctx, datasetIDs, user.ID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccessList(c, result, "success")
}
// GetCompilationStatus returns the dataset-level knowledge-compile lifecycle
@@ -1090,12 +1084,12 @@ func (h *DatasetsHandler) AggregateTags(c *gin.Context) {
func (h *DatasetsHandler) GetCompilationStatus(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeDataError, "dataset_id is required")
return
}
userID := strings.TrimSpace(user.ID)
@@ -1103,10 +1097,10 @@ func (h *DatasetsHandler) GetCompilationStatus(c *gin.Context) {
kind := strings.TrimSpace(c.Query("kind"))
st, code, err := h.datasetsService.GetDatasetCompilationStatus(ctx, userID, datasetID, kind)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, st, "success")
+ common.RespondSuccess(c, st, "success")
}
// ListMetadataFlattened handles GET /api/v1/datasets/metadata/flattened.
@@ -1121,13 +1115,13 @@ func (h *DatasetsHandler) GetCompilationStatus(c *gin.Context) {
func (h *DatasetsHandler) ListMetadataFlattened(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetIDsStr := c.Query("dataset_ids")
if datasetIDsStr == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset_ids is required")
+ common.RespondError(c, common.CodeDataError, "dataset_ids is required")
return
}
@@ -1140,7 +1134,7 @@ func (h *DatasetsHandler) ListMetadataFlattened(c *gin.Context) {
}
}
if len(datasetIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset_ids is required")
+ common.RespondError(c, common.CodeDataError, "dataset_ids is required")
return
}
@@ -1155,50 +1149,50 @@ func (h *DatasetsHandler) ListMetadataFlattened(c *gin.Context) {
flattenedMeta, err := h.metadataService.GetFlattedMetaByKBs(ctx, datasetIDs)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Failed to get metadata: "+err.Error())
+ common.RespondError(c, common.CodeServerError, "Failed to get metadata: "+err.Error())
return
}
- common.SuccessWithData(c, flattenedMeta, "success")
+ common.RespondSuccess(c, flattenedMeta, "success")
}
func (h *DatasetsHandler) UpdateDocumentMetadataConfig(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeArgumentError, "dataset_id is required")
return
}
documentID := strings.TrimSpace(c.Param("document_id"))
if documentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "document_id is required")
+ common.RespondError(c, common.CodeArgumentError, "document_id is required")
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "user_id is required")
+ common.RespondError(c, common.CodeArgumentError, "user_id is required")
return
}
var req map[string]interface{}
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
ctx := c.Request.Context()
data, code, err := h.datasetsService.UpdateDocumentMetadataConfig(ctx, userID, datasetID, documentID, req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.ResponseWithCodeData(c, code, data, "success")
+ common.RespondSuccess(c, data, "success")
}
// SearchDatasets searches chunks across datasets based on a question
@@ -1211,13 +1205,13 @@ func (h *DatasetsHandler) UpdateDocumentMetadataConfig(c *gin.Context) {
func (h *DatasetsHandler) SearchDatasets(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.SearchDatasetsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
@@ -1244,20 +1238,20 @@ func (h *DatasetsHandler) SearchDatasets(c *gin.Context) {
req.Question = strings.TrimSpace(req.Question)
if req.Question == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "question is required")
+ common.RespondError(c, common.CodeArgumentError, "question is required")
return
}
if req.DatasetIDs == nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "dataset_ids is required")
+ common.RespondError(c, common.CodeArgumentError, "dataset_ids is required")
return
}
if len(req.DatasetIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "dataset_ids array cannot be empty")
+ common.RespondError(c, common.CodeArgumentError, "dataset_ids array cannot be empty")
return
}
if err := validateSearchDatasetsRequest(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
@@ -1266,7 +1260,7 @@ func (h *DatasetsHandler) SearchDatasets(c *gin.Context) {
searchService = h.datasetsService
}
if searchService == nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset service is not initialized")
+ common.RespondError(c, common.CodeDataError, "dataset service is not initialized")
return
}
@@ -1277,11 +1271,11 @@ func (h *DatasetsHandler) SearchDatasets(c *gin.Context) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
// SearchDataset searches chunks within a single dataset based on a question.
@@ -1295,28 +1289,28 @@ func (h *DatasetsHandler) SearchDatasets(c *gin.Context) {
func (h *DatasetsHandler) SearchDataset(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := c.Param("dataset_id")
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeDataError, "dataset_id is required")
return
}
var req service.SearchDatasetRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
req.Question = strings.TrimSpace(req.Question)
if req.Question == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "question is required")
+ common.RespondError(c, common.CodeArgumentError, "question is required")
return
}
if err := validateSearchDatasetRequest(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
@@ -1325,7 +1319,7 @@ func (h *DatasetsHandler) SearchDataset(c *gin.Context) {
searchService = h.datasetsService
}
if searchService == nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "dataset service is not initialized")
+ common.RespondError(c, common.CodeDataError, "dataset service is not initialized")
return
}
@@ -1336,11 +1330,11 @@ func (h *DatasetsHandler) SearchDataset(c *gin.Context) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
func validateSearchDatasetsRequest(req *service.SearchDatasetsRequest) error {
diff --git a/internal/handler/dataset_artifact.go b/internal/handler/dataset_artifact.go
index c2fddb5bc3..56f54a9b94 100644
--- a/internal/handler/dataset_artifact.go
+++ b/internal/handler/dataset_artifact.go
@@ -57,20 +57,20 @@ func NewDatasetArtifactHandler(svc *service.DatasetArtifactService, datasetSvc *
func (h *DatasetArtifactHandler) datasetOwner(c *gin.Context, datasetID string) (*entity.User, string, string) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, msg)
+ common.RespondError(c, code, msg)
return nil, "", ""
}
kb, err := h.datasetSvc.GetKnowledgebaseByID(c.Request.Context(), datasetID)
if err != nil {
if dao.IsNotFoundErr(err) {
- common.ErrorWithCode(c, common.CodeNotFound, "dataset not found")
+ common.RespondError(c, common.CodeNotFound, "dataset not found")
} else {
- common.ErrorWithCode(c, common.CodeServerError, "failed to resolve dataset")
+ common.RespondError(c, common.CodeServerError, "failed to resolve dataset")
}
return nil, "", ""
}
if kb == nil {
- common.ErrorWithCode(c, common.CodeNotFound, "dataset not found")
+ common.RespondError(c, common.CodeNotFound, "dataset not found")
return nil, "", ""
}
if err := permission.NewDatabaseChecker(dao.DB).CheckResource(c.Request.Context(), permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: datasetID}, permission.OperationRead); err != nil {
@@ -88,7 +88,7 @@ func (h *DatasetArtifactHandler) AnyArtifact(c *gin.Context) {
}
has, err := h.svc.HasWiki(c.Request.Context(), tenantID, c.Param("dataset_id"))
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if has {
@@ -121,12 +121,12 @@ func (h *DatasetArtifactHandler) ListArtifacts(c *gin.Context) {
}
items, total, err := h.svc.ListWikiPages(c.Request.Context(), tenantID, datasetID, pageType, topic, keywords, page, pageSize)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
// Python's list_wiki_pages returns {total, items}; align the Go port so the
// shared frontend (which reads data.items) stays compatible.
- common.SuccessWithData(c, gin.H{"total": total, "items": items}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "items": items}, "success")
}
// UpdateArtifact handles PUT /artifacts/<page_type>/<slug> — edit a wiki page.
@@ -146,7 +146,7 @@ func (h *DatasetArtifactHandler) UpdateArtifact(c *gin.Context) {
Outlinks []string `json:"outlinks"`
}
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
@@ -168,11 +168,11 @@ func (h *DatasetArtifactHandler) UpdateArtifact(c *gin.Context) {
detail, err := h.svc.UpdateWikiPage(c.Request.Context(), tenantID, datasetID, pageType, slug, req.ContentMd, req.Title, req.Outlinks)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if detail == nil {
- common.ErrorWithCode(c, common.CodeNotFound, "page not found")
+ common.RespondError(c, common.CodeNotFound, "page not found")
return
}
@@ -198,7 +198,7 @@ func (h *DatasetArtifactHandler) UpdateArtifact(c *gin.Context) {
}
}
- common.SuccessWithData(c, detail, "success")
+ common.RespondSuccess(c, detail, "success")
}
// GetArtifact handles GET /artifacts/<page_type>/<slug> — single wiki page.
@@ -213,14 +213,14 @@ func (h *DatasetArtifactHandler) GetArtifact(c *gin.Context) {
slug := strings.TrimPrefix(c.Param("slug"), "/")
detail, err := h.svc.GetWikiPage(c.Request.Context(), tenantID, datasetID, pageType, slug)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if detail == nil {
- common.ErrorWithCode(c, common.CodeNotFound, "page not found")
+ common.RespondError(c, common.CodeNotFound, "page not found")
return
}
- common.SuccessWithData(c, detail, "success")
+ common.RespondSuccess(c, detail, "success")
}
// ListArtifactTopics handles GET /artifacts/topics — list wiki topics.
@@ -233,12 +233,12 @@ func (h *DatasetArtifactHandler) ListArtifactTopics(c *gin.Context) {
keywords := strings.TrimSpace(c.Query("keywords"))
items, total, err := h.svc.ListWikiTopics(c.Request.Context(), tenantID, datasetID, keywords)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
// Python's list_wiki_topics returns {total, items}; align the Go port so the
// shared frontend (which reads data.items) stays compatible.
- common.SuccessWithData(c, gin.H{"total": total, "items": items}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "items": items}, "success")
}
// GetArtifactAlteration handles GET /artifacts/alteration — wiki alteration summary.
@@ -250,10 +250,10 @@ func (h *DatasetArtifactHandler) GetArtifactAlteration(c *gin.Context) {
datasetID := c.Param("dataset_id")
alt, err := h.svc.GetWikiAlteration(c.Request.Context(), tenantID, datasetID)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, alt, "success")
+ common.RespondSuccess(c, alt, "success")
}
// GetArtifactGraph handles GET /artifacts/graph — wiki entity/relation graph.
@@ -278,17 +278,17 @@ func (h *DatasetArtifactHandler) GetArtifactGraph(c *gin.Context) {
// budget the route never actually applied.
value, parseErr := strconv.Atoi(topNValue)
if parseErr != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, fmt.Sprintf("top_n must be an integer (got %q)", topNValue))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("top_n must be an integer (got %q)", topNValue))
return
}
topN = &value
}
graph, err := h.svc.GetWikiGraph(c.Request.Context(), tenantID, datasetID, keywords, topN)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, graph, "success")
+ common.RespondSuccess(c, graph, "success")
}
// ListStructures handles GET /artifacts/structure?kind=<kind>&keywords=<query> —
@@ -304,7 +304,7 @@ func (h *DatasetArtifactHandler) ListStructures(c *gin.Context) {
datasetID := c.Param("dataset_id")
kind := c.Query("kind")
if kind == "" {
- common.ErrorWithCode(c, common.CodeArgumentError, "kind is required")
+ common.RespondError(c, common.CodeArgumentError, "kind is required")
return
}
in := service.DatasetStructureGraphInput{
@@ -316,13 +316,13 @@ func (h *DatasetArtifactHandler) ListStructures(c *gin.Context) {
resp, err := h.svc.GetDatasetStructure(c.Request.Context(), in)
if err != nil {
if errors.Is(err, service.ErrInvalidStructureKind) {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
} else {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
}
return
}
- common.SuccessWithData(c, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
// AnySkill handles HEAD /skills — any skill artifact present?
@@ -333,7 +333,7 @@ func (h *DatasetArtifactHandler) AnySkill(c *gin.Context) {
}
has, err := h.svc.HasSkill(c.Request.Context(), tenantID, c.Param("dataset_id"))
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if has {
@@ -353,12 +353,12 @@ func (h *DatasetArtifactHandler) ListNavigation(c *gin.Context) {
keywords := strings.TrimSpace(c.Query("keywords"))
items, total, err := h.svc.ListNavClusters(c.Request.Context(), tenantID, c.Param("dataset_id"), keywords)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
// Response key is "items" (not "nav") — the frontend DatasetNavList reads
// data.items and Python list_nav_clusters/_nav_search return {"total","items"}.
- common.SuccessWithData(c, gin.H{"total": total, "items": items}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "items": items}, "success")
}
// ListNavigationChildren handles GET /navigation/<name>/children — list
@@ -371,12 +371,12 @@ func (h *DatasetArtifactHandler) ListNavigationChildren(c *gin.Context) {
keywords := strings.TrimSpace(c.Query("keywords"))
items, total, err := h.svc.ListNavChildren(c.Request.Context(), tenantID, c.Param("dataset_id"), c.Param("name"), keywords)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
// Same contract as the top-level nav list: Python list_nav_children returns
// {"total","items"} and the frontend reads data.items for child expansion.
- common.SuccessWithData(c, gin.H{"total": total, "items": items}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "items": items}, "success")
}
// GetSkillTree handles GET /skills — skill tree.
@@ -388,10 +388,10 @@ func (h *DatasetArtifactHandler) GetSkillTree(c *gin.Context) {
kwd := c.Query("kwd")
items, total, err := h.svc.GetSkillTree(c.Request.Context(), tenantID, c.Param("dataset_id"), kwd)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"total": total, "tree": items}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "tree": items}, "success")
}
// DeleteSkills handles DELETE /skills — delete all skills.
@@ -402,10 +402,10 @@ func (h *DatasetArtifactHandler) DeleteSkills(c *gin.Context) {
}
n, err := h.svc.DeleteSkills(c.Request.Context(), tenantID, c.Param("dataset_id"), "")
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"deleted": n}, "success")
+ common.RespondSuccess(c, gin.H{"deleted": n}, "success")
}
// GetSkillPage handles GET /skills/<skill_kwd> — single skill page.
@@ -416,14 +416,14 @@ func (h *DatasetArtifactHandler) GetSkillPage(c *gin.Context) {
}
detail, err := h.svc.GetSkillPage(c.Request.Context(), tenantID, c.Param("dataset_id"), c.Param("skill_kwd"))
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if detail == nil {
- common.ErrorWithCode(c, common.CodeNotFound, "skill not found")
+ common.RespondError(c, common.CodeNotFound, "skill not found")
return
}
- common.SuccessWithData(c, detail, "success")
+ common.RespondSuccess(c, detail, "success")
}
// DeleteSkill handles DELETE /skills/<skill_kwd> — delete a single skill.
@@ -434,10 +434,10 @@ func (h *DatasetArtifactHandler) DeleteSkill(c *gin.Context) {
}
n, err := h.svc.DeleteSkills(c.Request.Context(), tenantID, c.Param("dataset_id"), c.Param("skill_kwd"))
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"deleted": n}, "success")
+ common.RespondSuccess(c, gin.H{"deleted": n}, "success")
}
// GetDocumentGraph handles GET /documents/<document_id>/structure/graph — document structure graph.
@@ -455,13 +455,13 @@ func (h *DatasetArtifactHandler) GetDocumentGraph(c *gin.Context) {
Keywords: c.Query("keywords"),
})
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if resp == nil {
resp = &service.DocumentStructureGraphResponse{Templates: []service.DocumentStructureGraphTemplate{}}
}
- common.SuccessWithData(c, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
// GetDocumentClaims handles GET /documents/<document_id>/structure/claims —
@@ -501,10 +501,10 @@ func (h *DatasetArtifactHandler) GetDocumentClaims(c *gin.Context) {
claims, total, err := h.svc.ListDocumentStructureClaims(c.Request.Context(), tenantID, datasetID, documentID, templateID, chunkIDs, offset, limit)
if err != nil {
- common.ErrorWithCode(c, common.CodeExceptionError, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"claims": claims, "total": total, "offset": offset, "limit": limit}, "success")
+ common.RespondSuccess(c, gin.H{"claims": claims, "total": total, "offset": offset, "limit": limit}, "success")
}
// DeleteDocumentGraph handles DELETE /documents/<document_id>/structure/graph — delete document structure graph.
@@ -517,8 +517,8 @@ func (h *DatasetArtifactHandler) DeleteDocumentGraph(c *gin.Context) {
documentID := c.Param("document_id")
n, err := h.svc.DeleteDocumentGraph(c.Request.Context(), tenantID, datasetID, documentID)
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"deleted": n}, "success")
+ common.RespondSuccess(c, gin.H{"deleted": n}, "success")
}
diff --git a/internal/handler/dataset_error_response_test.go b/internal/handler/dataset_error_response_test.go
index e0fdde94db..977b3fab6a 100644
--- a/internal/handler/dataset_error_response_test.go
+++ b/internal/handler/dataset_error_response_test.go
@@ -29,11 +29,8 @@ import (
"ragflow/internal/entity"
)
-// The datasets API mirrors the Python contract, whose error bodies always
-// carry the three keys `code`, `data` and `message` (api/utils/api_utils.py
-// get_json_result). These tests pin the `data` key on CreateDataset error
-// branches and keep UpdateDataset from writing a second response after
-// parseJSONRequestObject already answered.
+// Dataset errors omit absent data. Malformed requests must receive exactly
+// one JSON response, including when parseJSONRequestObject already answered.
func newDatasetErrorResponseRouter(method, path string, handlerFn func(*gin.Context)) *gin.Engine {
gin.SetMode(gin.TestMode)
@@ -45,7 +42,7 @@ func newDatasetErrorResponseRouter(method, path string, handlerFn func(*gin.Cont
return r
}
-func assertDatasetErrorBodyHasDataKey(t *testing.T, r *gin.Engine, method, target, body string, wantCode common.ErrorCode) map[string]interface{} {
+func assertDatasetErrorBodyOmitsData(t *testing.T, r *gin.Engine, method, target, body string, wantCode common.ErrorCode) map[string]interface{} {
t.Helper()
resp := httptest.NewRecorder()
@@ -64,8 +61,8 @@ func assertDatasetErrorBodyHasDataKey(t *testing.T, r *gin.Engine, method, targe
if gotCode, ok := parsed["code"].(float64); !ok || int(gotCode) != int(wantCode) {
t.Fatalf("code=%v want=%d body=%s", parsed["code"], int(wantCode), resp.Body.String())
}
- if _, ok := parsed["data"]; !ok {
- t.Fatalf("error body lost the `data` key (Python get_json_result always sends it): body=%s", resp.Body.String())
+ if _, ok := parsed["data"]; ok {
+ t.Fatalf("error body must omit absent data: body=%s", resp.Body.String())
}
if _, ok := parsed["message"].(string); !ok {
t.Fatalf("error body lost the `message` key: body=%s", resp.Body.String())
@@ -73,49 +70,49 @@ func assertDatasetErrorBodyHasDataKey(t *testing.T, r *gin.Engine, method, targe
return parsed
}
-func TestCreateDatasetExtraFieldKeepsDataInBody(t *testing.T) {
+func TestCreateDatasetExtraFieldOmitsData(t *testing.T) {
r := newDatasetErrorResponseRouter(http.MethodPost, "/api/v1/datasets", func(c *gin.Context) {
h := &DatasetsHandler{}
h.CreateDataset(c)
})
- body := assertDatasetErrorBodyHasDataKey(t, r, http.MethodPost, "/api/v1/datasets",
+ body := assertDatasetErrorBodyOmitsData(t, r, http.MethodPost, "/api/v1/datasets",
`{"name":"kb","ext":{}}`, common.CodeArgumentError)
if body["message"] != "extra inputs are not permitted: ext" {
t.Fatalf("message=%v", body["message"])
}
}
-func TestCreateDatasetUnknownFieldKeepsDataInBody(t *testing.T) {
+func TestCreateDatasetUnknownFieldOmitsData(t *testing.T) {
r := newDatasetErrorResponseRouter(http.MethodPost, "/api/v1/datasets", func(c *gin.Context) {
h := &DatasetsHandler{}
h.CreateDataset(c)
})
- body := assertDatasetErrorBodyHasDataKey(t, r, http.MethodPost, "/api/v1/datasets",
+ body := assertDatasetErrorBodyOmitsData(t, r, http.MethodPost, "/api/v1/datasets",
`{"name":"kb","bogus_field":1}`, common.CodeArgumentError)
if body["message"] != "extra inputs are not permitted: bogus_field" {
t.Fatalf("message=%v", body["message"])
}
}
-func TestCreateDatasetMalformedJSONKeepsDataInBody(t *testing.T) {
+func TestCreateDatasetMalformedJSONOmitsData(t *testing.T) {
r := newDatasetErrorResponseRouter(http.MethodPost, "/api/v1/datasets", func(c *gin.Context) {
h := &DatasetsHandler{}
h.CreateDataset(c)
})
- assertDatasetErrorBodyHasDataKey(t, r, http.MethodPost, "/api/v1/datasets",
+ assertDatasetErrorBodyOmitsData(t, r, http.MethodPost, "/api/v1/datasets",
`{"name":`, common.CodeArgumentError)
}
-func TestCreateDatasetMissingNameKeepsDataInBody(t *testing.T) {
+func TestCreateDatasetMissingNameOmitsData(t *testing.T) {
r := newDatasetErrorResponseRouter(http.MethodPost, "/api/v1/datasets", func(c *gin.Context) {
h := &DatasetsHandler{}
h.CreateDataset(c)
})
- assertDatasetErrorBodyHasDataKey(t, r, http.MethodPost, "/api/v1/datasets",
+ assertDatasetErrorBodyOmitsData(t, r, http.MethodPost, "/api/v1/datasets",
`{"parser_config":{}}`, common.CodeDataError)
}
@@ -139,31 +136,31 @@ func TestUpdateDatasetRespondsExactlyOnceOnMalformedRequest(t *testing.T) {
if gotCode, ok := parsed["code"].(float64); !ok || int(gotCode) != int(common.CodeArgumentError) {
t.Fatalf("code=%v want=%d body=%s", parsed["code"], int(common.CodeArgumentError), resp.Body.String())
}
- if _, ok := parsed["data"]; !ok {
- t.Fatalf("error body lost the `data` key: body=%s", resp.Body.String())
+ if _, ok := parsed["data"]; ok {
+ t.Fatalf("error body must omit absent data: body=%s", resp.Body.String())
}
}
-func TestDeleteDatasetsExtraFieldKeepsDataInBody(t *testing.T) {
+func TestDeleteDatasetsExtraFieldOmitsData(t *testing.T) {
r := newDatasetErrorResponseRouter(http.MethodDelete, "/api/v1/datasets", func(c *gin.Context) {
h := &DatasetsHandler{}
h.DeleteDatasets(c)
})
- body := assertDatasetErrorBodyHasDataKey(t, r, http.MethodDelete, "/api/v1/datasets",
+ body := assertDatasetErrorBodyOmitsData(t, r, http.MethodDelete, "/api/v1/datasets",
`{"ids":["a"],"bogus":1}`, common.CodeArgumentError)
if body["message"] != "extra inputs are not permitted: bogus" {
t.Fatalf("message=%v", body["message"])
}
}
-func TestDeleteDatasetsDuplicateIDsKeepsDataInBody(t *testing.T) {
+func TestDeleteDatasetsDuplicateIDsOmitsData(t *testing.T) {
r := newDatasetErrorResponseRouter(http.MethodDelete, "/api/v1/datasets", func(c *gin.Context) {
h := &DatasetsHandler{}
h.DeleteDatasets(c)
})
- body := assertDatasetErrorBodyHasDataKey(t, r, http.MethodDelete, "/api/v1/datasets",
+ body := assertDatasetErrorBodyOmitsData(t, r, http.MethodDelete, "/api/v1/datasets",
`{"ids":["a","a"]}`, common.CodeArgumentError)
if body["message"] != "duplicate ids: 'a'" {
t.Fatalf("message=%v", body["message"])
@@ -187,7 +184,7 @@ func TestDeleteDatasetsRespondsExactlyOnceOnMalformedRequest(t *testing.T) {
if err := json.Unmarshal(resp.Body.Bytes(), &parsed); err != nil {
t.Fatalf("response body is not one JSON object (a second response was appended): %v body=%s", err, resp.Body.String())
}
- if _, ok := parsed["data"]; !ok {
- t.Fatalf("error body lost the `data` key: body=%s", resp.Body.String())
+ if _, ok := parsed["data"]; ok {
+ t.Fatalf("error body must omit absent data: body=%s", resp.Body.String())
}
}
diff --git a/internal/handler/dify_retrieval_handler.go b/internal/handler/dify_retrieval_handler.go
index bfc366633d..874c4b04e3 100644
--- a/internal/handler/dify_retrieval_handler.go
+++ b/internal/handler/dify_retrieval_handler.go
@@ -171,14 +171,14 @@ func NewDifyRetrievalHandler(
func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
user, errCode, errMsg := GetUser(c)
if errCode != common.CodeSuccess {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, errCode, nil, errMsg)
+ common.Respond(c, http.StatusUnauthorized, errCode, nil, errMsg)
return
}
var req difyRetrievalRequest
if c.Request.Method == http.MethodGet {
if err := c.ShouldBindQuery(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "invalid query parameters")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "invalid query parameters")
return
}
// Manually extract top_k and score_threshold from query (flat params, not nested)
@@ -200,13 +200,13 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
}
} else {
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "invalid request body")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "invalid request body")
return
}
}
if req.KnowledgeID == "" || req.Query == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "knowledge_id and query are required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "knowledge_id and query are required")
return
}
@@ -214,9 +214,9 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
kb, err := h.kbSvc.GetKnowledgebaseByID(ctx, req.KnowledgeID)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
- common.ResponseWithHttpCodeData(c, http.StatusNotFound, common.CodeNotFound, nil, "Knowledge base not found!")
+ common.Respond(c, http.StatusNotFound, common.CodeNotFound, nil, "Knowledge base not found!")
} else {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, "failed to query knowledge base")
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, "failed to query knowledge base")
}
return
}
@@ -238,7 +238,7 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
pageSize := 1024
if topK != nil {
if *topK < 1 || *topK > 1024 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "top_k must be between 1 and 1024")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "top_k must be between 1 and 1024")
return
}
pageSize = *topK
@@ -248,7 +248,7 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
access := service.Identity{UserID: user.ID, TenantID: kb.TenantID}
embModel, err := h.modelFactory.NewEmbeddingModel(ctx, access, kb.EmbdID)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, fmt.Sprintf("failed to get embedding model: %v", err))
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, fmt.Sprintf("failed to get embedding model: %v", err))
return
}
@@ -298,10 +298,10 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
result, err := h.retrievalSvc.Retrieval(c.Request.Context(), sr)
if err != nil {
if strings.Contains(err.Error(), "not_found") {
- common.ResponseWithHttpCodeData(c, http.StatusNotFound, common.CodeNotFound, nil, "No chunk found! Check the chunk status please!")
+ common.Respond(c, http.StatusNotFound, common.CodeNotFound, nil, "No chunk found! Check the chunk status please!")
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
return
}
@@ -347,7 +347,7 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
var docs []*entity.Document
docs, err = h.docDAO.GetByIDs(ctx, dao.DB, allDocIDs)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, fmt.Sprintf("failed to load documents: %v", err))
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, fmt.Sprintf("failed to load documents: %v", err))
return
}
for _, d := range docs {
@@ -409,5 +409,5 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
// HealthCheck Health check returns a simple health check response.
func (h *DifyRetrievalHandler) HealthCheck(c *gin.Context) {
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
diff --git a/internal/handler/dify_retrieval_handler_test.go b/internal/handler/dify_retrieval_handler_test.go
index 574b5ab2b0..80a35a48b5 100644
--- a/internal/handler/dify_retrieval_handler_test.go
+++ b/internal/handler/dify_retrieval_handler_test.go
@@ -207,8 +207,11 @@ func TestDifyRetrieval_HealthCheck(t *testing.T) {
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatal(err)
}
- if resp["data"] != true {
- t.Errorf("expected data=true, got %v", resp["data"])
+ if resp["code"] != float64(common.CodeSuccess) {
+ t.Fatalf("expected success, got %v", resp)
+ }
+ if data, exists := resp["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
}
diff --git a/internal/handler/document.go b/internal/handler/document.go
index 94992b6ad8..3e670733e3 100644
--- a/internal/handler/document.go
+++ b/internal/handler/document.go
@@ -123,20 +123,20 @@ func NewDocumentHandler(documentService documentServiceIface, datasetService *da
func (h *DocumentHandler) GetDocumentByID(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
id := c.Param("id")
if id == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "invalid document id")
+ common.RespondError(c, common.CodeBadRequest, "invalid document id")
return
}
ctx := c.Request.Context()
doc, err := h.documentService.GetDocumentByID(ctx, id)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "document not found")
+ common.RespondError(c, common.CodeNotFound, "document not found")
return
}
@@ -145,31 +145,31 @@ func (h *DocumentHandler) GetDocumentByID(c *gin.Context) {
return
}
- common.SuccessWithData(c, doc, "")
+ common.RespondSuccess(c, doc, "")
}
// GetThumbnail Get thumbnails for documents.
func (h *DocumentHandler) GetThumbnail(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
docIDs := parseThumbnailDocIDs(c)
if len(docIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, `Lack of "Document ID"`)
+ common.RespondError(c, common.CodeArgumentError, `Lack of "Document ID"`)
return
}
ctx := c.Request.Context()
result, err := h.documentService.GetThumbnails(ctx, user.ID, docIDs)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func parseThumbnailDocIDs(c *gin.Context) []string {
@@ -196,14 +196,14 @@ func parseThumbnailDocIDs(c *gin.Context) []string {
func (h *DocumentHandler) GetDocumentImage(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
imageID := c.Param("image_id")
ctx := c.Request.Context()
data, err := h.documentService.GetDocumentImage(ctx, user.ID, imageID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Image not found.")
+ common.RespondError(c, common.CodeDataError, "Image not found.")
return
}
h.writeDocumentImage(c, data)
@@ -212,12 +212,12 @@ func (h *DocumentHandler) GetDocumentImage(c *gin.Context) {
func (h *DocumentHandler) GetDocumentImageForDocument(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
data, err := h.documentService.GetDocumentImageForDocument(c.Request.Context(), user.ID, c.Param("id"), c.Param("image_id"))
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Image not found.")
+ common.RespondError(c, common.CodeDataError, "Image not found.")
return
}
h.writeDocumentImage(c, data)
@@ -226,12 +226,12 @@ func (h *DocumentHandler) GetDocumentImageForDocument(c *gin.Context) {
func (h *DocumentHandler) GetDocumentThumbnail(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
data, err := h.documentService.GetDocumentThumbnail(c.Request.Context(), c.Param("id"))
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Image not found.")
+ common.RespondError(c, common.CodeDataError, "Image not found.")
return
}
h.writeDocumentImage(c, data)
@@ -240,7 +240,7 @@ func (h *DocumentHandler) GetDocumentThumbnail(c *gin.Context) {
func (h *DocumentHandler) writeDocumentImage(c *gin.Context, data []byte) {
contentType := documentImageContentType(data)
if contentType == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Image not found.")
+ common.RespondError(c, common.CodeDataError, "Image not found.")
return
}
c.Header("Cache-Control", "no-store")
@@ -267,7 +267,7 @@ func documentImageContentType(data []byte) string {
func (h *DocumentHandler) GetDocumentArtifact(c *gin.Context) {
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
filename := c.Param("filename")
@@ -278,10 +278,10 @@ func (h *DocumentHandler) GetDocumentArtifact(c *gin.Context) {
case errors.Is(err, document.ErrArtifactInvalidFilename),
errors.Is(err, document.ErrArtifactInvalidFileType),
errors.Is(err, document.ErrArtifactNotFound):
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
default:
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
}
return
}
@@ -299,14 +299,14 @@ func (h *DocumentHandler) GetDocumentArtifact(c *gin.Context) {
func (h *DocumentHandler) GetDocumentPreview(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
docID := c.Param("id")
if docID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "id is required")
+ common.RespondError(c, common.CodeParamError, "id is required")
return
}
@@ -315,9 +315,9 @@ func (h *DocumentHandler) GetDocumentPreview(c *gin.Context) {
if err != nil {
switch {
case errors.Is(err, document.ErrPreviewDocumentNotFound):
- common.ErrorWithCode(c, common.CodeDataError, "document not found")
+ common.RespondError(c, common.CodeDataError, "document not found")
case errors.Is(err, document.ErrPreviewFileEmpty):
- common.ErrorWithCode(c, common.CodeDataError, "This file is empty.")
+ common.RespondError(c, common.CodeDataError, "This file is empty.")
default:
// Surface the failure as a distinct server error (storage
// unreachable, missing object, bad address) instead of masking
@@ -326,7 +326,7 @@ func (h *DocumentHandler) GetDocumentPreview(c *gin.Context) {
// log only.
common.Error("GetDocumentPreview failed", err,
zap.String("doc_id", docID), zap.String("user_id", permission.UserIDFromContext(ctx)))
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Failed to load document preview")
+ common.RespondError(c, common.CodeServerError, "Failed to load document preview")
}
return
}
@@ -355,7 +355,7 @@ func (h *DocumentHandler) GetDocumentPreview(c *gin.Context) {
func (h *DocumentHandler) UpdateDocument(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -370,7 +370,7 @@ func (h *DocumentHandler) UpdateDocument(c *gin.Context) {
ctx := c.Request.Context()
doc, err := h.documentService.GetDocumentByID(ctx, id)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 1, nil, "document not found!")
+ common.Respond(c, http.StatusBadRequest, 1, nil, "document not found!")
return
}
if err := service.CheckDocumentAccess(ctx, doc.ID, doc.KbID, permission.OperationUpdate); err != nil {
@@ -388,14 +388,14 @@ func (h *DocumentHandler) UpdateDocument(c *gin.Context) {
if errorCode, err = h.documentService.UpdateDocument(ctx, id, &req); err != nil {
if errorCode == common.CodeServerError {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, errorCode, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, errorCode, nil, err.Error())
} else {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
}
return
}
- common.SuccessWithMessage(c, "updated successfully")
+ common.RespondSuccess(c, nil, "updated successfully")
}
// DeleteDocument delete document
@@ -410,7 +410,7 @@ func (h *DocumentHandler) UpdateDocument(c *gin.Context) {
func (h *DocumentHandler) DeleteDocument(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -425,7 +425,7 @@ func (h *DocumentHandler) DeleteDocument(c *gin.Context) {
ctx := c.Request.Context()
doc, err := h.documentService.GetDocumentByID(ctx, id)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 1, nil, "document not found!")
+ common.Respond(c, http.StatusBadRequest, 1, nil, "document not found!")
return
}
if err := service.CheckDocumentAccess(ctx, doc.ID, doc.KbID, permission.OperationDeleteContent); err != nil {
@@ -462,7 +462,7 @@ func (h *DocumentHandler) DeleteDocuments(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -471,7 +471,7 @@ func (h *DocumentHandler) DeleteDocuments(c *gin.Context) {
datasetID := c.Param("dataset_id")
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeArgumentError, "dataset_id is required")
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = errors.New("dataset_id is required")
return
@@ -489,7 +489,7 @@ func (h *DocumentHandler) DeleteDocuments(c *gin.Context) {
DeleteAll bool `json:"delete_all,omitempty"`
}
if err = json.Unmarshal(bodyBytes, &req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
operationLog.Code = int(common.CodeDataError)
operationLog.Error = err
return
@@ -506,7 +506,7 @@ func (h *DocumentHandler) DeleteDocuments(c *gin.Context) {
}
}
if len(duplicates) > 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("field: <ids> - message: <duplicate ids: '%s'> - value: <%s>", strings.Join(duplicates, ", "), string(bodyBytes)))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("field: <ids> - message: <duplicate ids: '%s'> - value: <%s>", strings.Join(duplicates, ", "), string(bodyBytes)))
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = fmt.Errorf("field: <ids> - message: <duplicate ids: '%s'> - value: <%s>", strings.Join(duplicates, ", "), string(bodyBytes))
return
@@ -518,13 +518,13 @@ func (h *DocumentHandler) DeleteDocuments(c *gin.Context) {
ids = *req.IDs
}
if len(ids) > 0 && req.DeleteAll {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "should not provide both ids and delete_all")
+ common.RespondError(c, common.CodeDataError, "should not provide both ids and delete_all")
operationLog.Code = int(common.CodeDataError)
operationLog.Error = errors.New("should not provide both ids and delete_all")
return
}
if len(ids) == 0 && !req.DeleteAll {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "should either provide doc ids or set delete_all(true)")
+ common.RespondError(c, common.CodeDataError, "should either provide doc ids or set delete_all(true)")
operationLog.Code = int(common.CodeDataError)
operationLog.Error = errors.New("should either provide doc ids or set delete_all(true)")
return
@@ -550,32 +550,32 @@ func (h *DocumentHandler) DeleteDocuments(c *gin.Context) {
operationLog.Error = err
return
}
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
operationLog.Code = int(common.CodeDataError)
operationLog.Error = err
return
}
- common.SuccessWithData(c, map[string]interface{}{"deleted": deleted}, "success")
+ common.RespondSuccess(c, map[string]interface{}{"deleted": deleted}, "success")
}
// BatchUpdateDocumentStatus Batch update status of documents within a dataset.
func (h *DocumentHandler) BatchUpdateDocumentStatus(c *gin.Context) {
user, code, errorMessage := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, errorMessage)
+ common.RespondError(c, code, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "invalid user id")
+ common.RespondError(c, common.CodeArgumentError, "invalid user id")
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeArgumentError, "dataset_id is required")
return
}
@@ -584,20 +584,19 @@ func (h *DocumentHandler) BatchUpdateDocumentStatus(c *gin.Context) {
Status interface{} `json:"status"`
}
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if req.DocumentIDs == nil || len(req.DocumentIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, `"doc_ids" must be a non-empty list.`)
+ common.RespondError(c, common.CodeArgumentError, `"doc_ids" must be a non-empty list.`)
return
}
documentIDs := make([]string, 0, len(req.DocumentIDs))
for _, rawDocID := range req.DocumentIDs {
docID, ok := rawDocID.(string)
if !ok || strings.TrimSpace(docID) == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- `"doc_ids" must contain non-empty document IDs.`)
+ common.RespondError(c, common.CodeArgumentError, `"doc_ids" must contain non-empty document IDs.`)
return
}
documentIDs = append(documentIDs, docID)
@@ -608,7 +607,7 @@ func (h *DocumentHandler) BatchUpdateDocumentStatus(c *gin.Context) {
status = fmt.Sprint(req.Status)
}
if status != "0" && status != "1" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf(`"Status" must be either 0 or 1:%s!`, status))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf(`"Status" must be either 0 or 1:%s!`, status))
return
}
@@ -619,11 +618,11 @@ func (h *DocumentHandler) BatchUpdateDocumentStatus(c *gin.Context) {
if code == common.CodeServerError {
message = "Partial failure"
}
- common.ResponseWithCodeData(c, code, result, message)
+ common.RespondError(c, code, message)
return
}
- common.ResponseWithCodeData(c, code, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// ListDocuments document list
@@ -639,7 +638,7 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
switch orderby {
case "create_time", "update_time", "name":
default:
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("invalid orderby field: %s", orderby))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("invalid orderby field: %s", orderby))
return
}
}
@@ -659,22 +658,22 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
opts, errMsg := parseDocumentListOptions(c, datasetID)
if errMsg != "" {
- common.ResponseWithCodeData(c, common.CodeDataError, map[string]interface{}{"total": 0, "docs": []interface{}{}}, errMsg)
+ common.RespondError(c, common.CodeDataError, errMsg)
return
}
opts, errMsg = h.applyDocumentMetadataFilter(c, opts)
if errMsg != "" {
- common.ResponseWithCodeData(c, common.CodeDataError, map[string]interface{}{"total": 0, "docs": []interface{}{}}, errMsg)
+ common.RespondError(c, common.CodeDataError, errMsg)
return
}
if c.Query("type") == "filter" {
filters, total, err := h.documentService.GetDocumentFiltersByDatasetID(ctx, opts)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, map[string]interface{}{"total": 0, "filter": map[string]interface{}{}}, "failed to get document filters")
+ common.RespondError(c, common.CodeExceptionError, "failed to get document filters")
return
}
- common.SuccessWithData(c, gin.H{"total": total, "filter": filters}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "filter": filters}, "success")
return
}
@@ -683,7 +682,7 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
// so that total reflects the unfiltered count, matching the Python API contract.
documents, total, err := h.documentService.ListDocumentsByDatasetIDWithOptions(ctx, opts, page, pageSize)
if err != nil {
- common.ResponseWithCodeData(c, 1, map[string]interface{}{"total": 0, "docs": []interface{}{}}, "failed to get documents")
+ common.RespondError(c, 1, "failed to get documents")
return
}
@@ -693,7 +692,7 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
idOpts.Name = ""
_, idTotal, idErr := h.documentService.ListDocumentsByDatasetIDWithOptions(ctx, idOpts, 1, 1)
if idErr == nil && idTotal == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, map[string]interface{}{"total": 0, "docs": []interface{}{}}, fmt.Sprintf("you don't own the document %s", docID))
+ common.RespondError(c, common.CodeDataError, fmt.Sprintf("you don't own the document %s", docID))
return
}
}
@@ -703,7 +702,7 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
nameOpts.DocIDFilterApplied = false
_, nameTotal, nameErr := h.documentService.ListDocumentsByDatasetIDWithOptions(ctx, nameOpts, 1, 1)
if nameErr == nil && nameTotal == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, map[string]interface{}{"total": 0, "docs": []interface{}{}}, fmt.Sprintf("you don't own the document %s", opts.Name))
+ common.RespondError(c, common.CodeDataError, fmt.Sprintf("you don't own the document %s", opts.Name))
return
}
}
@@ -750,7 +749,7 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
// otherwise an active task on another page could be missed.
hasActiveTasks = true
}
- common.SuccessWithData(c, gin.H{"total": total, "docs": docs, "has_active_tasks": hasActiveTasks}, "success")
+ common.RespondSuccess(c, gin.H{"total": total, "docs": docs, "has_active_tasks": hasActiveTasks}, "success")
}
func parseDocumentListOptions(c *gin.Context, datasetID string) (dao.DocumentListOptions, string) {
@@ -1026,7 +1025,7 @@ func invalidRunStatuses(statuses []string) []string {
func (h *DocumentHandler) UploadDocuments(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
tenantID := user.ID
@@ -1036,7 +1035,7 @@ func (h *DocumentHandler) UploadDocuments(c *gin.Context) {
ctx := c.Request.Context()
kb, err := h.datasetService.GetKnowledgebaseByID(ctx, datasetID)
if err != nil || kb == nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, fmt.Sprintf("Can't find the dataset with ID %s!", datasetID))
+ common.RespondError(c, common.CodeDataError, fmt.Sprintf("Can't find the dataset with ID %s!", datasetID))
return
}
if err := permission.NewDatabaseChecker(dao.DB).CheckResource(ctx, permission.ResourceRef{Kind: permission.ResourceKindDataset, ID: kb.ID}, permission.OperationUpdate); err != nil {
@@ -1052,14 +1051,14 @@ func (h *DocumentHandler) UploadDocuments(c *gin.Context) {
case "local":
h.uploadLocalDocuments(c, kb, tenantID)
default:
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, `"type" must be one of "local", "web", or "empty".`)
+ common.RespondError(c, common.CodeArgumentError, `"type" must be one of "local", "web", or "empty".`)
}
}
func (h *DocumentHandler) uploadLocalDocuments(c *gin.Context, kb *entity.Knowledgebase, tenantID string) {
form, err := c.MultipartForm()
if err != nil || form == nil || len(form.File["file"]) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "No file part!")
+ common.RespondError(c, common.CodeArgumentError, "No file part!")
return
}
files := form.File["file"]
@@ -1074,13 +1073,11 @@ func (h *DocumentHandler) uploadLocalDocuments(c *gin.Context, kb *entity.Knowle
}
for _, fh := range files {
if fh == nil || fh.Filename == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "No file selected!")
+ common.RespondError(c, common.CodeArgumentError, "No file selected!")
return
}
if len([]byte(fh.Filename)) > 255 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "File name must be 255 bytes or less.")
+ common.RespondError(c, common.CodeArgumentError, "File name must be 255 bytes or less.")
return
}
}
@@ -1105,32 +1102,24 @@ func (h *DocumentHandler) uploadLocalDocuments(c *gin.Context, kb *entity.Knowle
}
ctx := c.Request.Context()
data, errMsgs := h.documentService.UploadLocalDocuments(ctx, kb, tenantID, files, c.PostForm("parent_path"), override)
- if len(data) == 0 && len(errMsgs) > 0 {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, strings.Join(errMsgs, "\n"))
+ if len(errMsgs) > 0 {
+ common.RespondError(c, common.CodeServerError, strings.Join(errMsgs, "\n"))
return
}
if len(data) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "There seems to be an issue with your file format. please verify it is correct and not corrupted.")
+ common.RespondError(c, common.CodeDataError, "There seems to be an issue with your file format. please verify it is correct and not corrupted.")
return
}
if strings.ToLower(c.DefaultQuery("return_raw_files", "false")) == "true" {
- if len(errMsgs) > 0 {
- common.ResponseWithCodeData(c, common.CodeServerError, data, strings.Join(errMsgs, "\n"))
- return
- }
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccessList(c, data, "success")
return
}
mapped := make([]map[string]interface{}, len(data))
for i, d := range data {
mapped[i] = mapDocKeysWithRunStatus(d)
}
- if len(errMsgs) > 0 {
- common.ResponseWithCodeData(c, common.CodeServerError, mapped, strings.Join(errMsgs, "\n"))
- return
- }
- common.SuccessWithData(c, mapped, "success")
+ common.RespondSuccessList(c, mapped, "success")
}
func (h *DocumentHandler) uploadEmptyDocument(c *gin.Context, kb *entity.Knowledgebase, tenantID string) {
@@ -1141,53 +1130,53 @@ func (h *DocumentHandler) uploadEmptyDocument(c *gin.Context, kb *entity.Knowled
// a non-empty but malformed body should report the syntax error, not a
// misleading "File name can't be empty."
if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid JSON body: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Invalid JSON body: "+err.Error())
return
}
name := strings.TrimSpace(req.Name)
if name == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "File name can't be empty.")
+ common.RespondError(c, common.CodeArgumentError, "File name can't be empty.")
return
}
if len([]byte(name)) > 255 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "File name must be 255 bytes or less.")
+ common.RespondError(c, common.CodeArgumentError, "File name must be 255 bytes or less.")
return
}
ctx := c.Request.Context()
data, code, err := h.documentService.UploadEmptyDocument(ctx, kb, tenantID, name)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, mapDocKeysWithRunStatus(data), "success")
+ common.RespondSuccess(c, mapDocKeysWithRunStatus(data), "success")
}
func (h *DocumentHandler) uploadWebDocument(c *gin.Context, kb *entity.Knowledgebase, tenantID string) {
name := strings.TrimSpace(c.PostForm("name"))
rawURL := c.PostForm("url")
if name == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, `Lack of "name"`)
+ common.RespondError(c, common.CodeArgumentError, `Lack of "name"`)
return
}
if rawURL == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, `Lack of "url"`)
+ common.RespondError(c, common.CodeArgumentError, `Lack of "url"`)
return
}
if len([]byte(name)) > 255 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "File name must be 255 bytes or less.")
+ common.RespondError(c, common.CodeArgumentError, "File name must be 255 bytes or less.")
return
}
if !isValidHTTPURL(rawURL) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "The URL format is invalid")
+ common.RespondError(c, common.CodeArgumentError, "The URL format is invalid")
return
}
ctx := c.Request.Context()
data, code, err := h.documentService.UploadWebDocument(ctx, kb, tenantID, name, rawURL)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, mapDocKeysWithRunStatus(data), "success")
+ common.RespondSuccess(c, mapDocKeysWithRunStatus(data), "success")
}
// mapDocKeysWithRunStatus renames a freshly-created document's raw keys to the
@@ -1226,7 +1215,7 @@ func isValidHTTPURL(raw string) bool {
func (h *DocumentHandler) DownloadDocument(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -1234,11 +1223,11 @@ func (h *DocumentHandler) DownloadDocument(c *gin.Context) {
docID := c.Param("document_id")
if docID == "" {
- common.ErrorWithCode(c, common.CodeDataError, "Specify document_id please.")
+ common.RespondError(c, common.CodeDataError, "Specify document_id please.")
return
}
if datasetID == "" {
- common.ErrorWithCode(c, common.CodeDataError, fmt.Sprintf("The dataset not own the document %s.", docID))
+ common.RespondError(c, common.CodeDataError, fmt.Sprintf("The dataset not own the document %s.", docID))
return
}
ctx := c.Request.Context()
@@ -1247,16 +1236,16 @@ func (h *DocumentHandler) DownloadDocument(c *gin.Context) {
doc, err := h.documentService.GetDocumentByID(ctx, docID)
if err != nil {
if dao.IsNotFoundErr(err) {
- common.ErrorWithCode(c, common.CodeNotFound, "Resource not found")
+ common.RespondError(c, common.CodeNotFound, "Resource not found")
return
}
common.Error("DownloadDocument failed to load document", err,
zap.String("dataset_id", datasetID), zap.String("document_id", docID), zap.String("user_id", user.ID))
- common.ErrorWithCode(c, common.CodeServerError, "Failed to download document")
+ common.RespondError(c, common.CodeServerError, "Failed to download document")
return
}
if doc == nil || doc.KbID != datasetID {
- common.ErrorWithCode(c, common.CodeNotFound, "Resource not found")
+ common.RespondError(c, common.CodeNotFound, "Resource not found")
return
}
if err := service.CheckDocumentAccess(ctx, doc.ID, doc.KbID, permission.OperationRead); err != nil {
@@ -1267,12 +1256,12 @@ func (h *DocumentHandler) DownloadDocument(c *gin.Context) {
if err != nil {
if errors.Is(err, document.ErrDocumentNotFound) {
- common.ErrorWithCode(c, common.CodeNotFound, "Resource not found")
+ common.RespondError(c, common.CodeNotFound, "Resource not found")
return
}
common.Error("DownloadDocument failed", err,
zap.String("dataset_id", datasetID), zap.String("document_id", docID), zap.String("user_id", user.ID))
- common.ErrorWithCode(c, common.CodeServerError, "Failed to download document")
+ common.RespondError(c, common.CodeServerError, "Failed to download document")
return
}
@@ -1382,28 +1371,28 @@ func stringValue(value *string) string {
func (h *DocumentHandler) Ingest(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeAuthenticationError, nil, "no authentication")
+ common.RespondError(c, common.CodeAuthenticationError, "no authentication")
return
}
var req document.IngestDocumentRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
ctx := c.Request.Context()
if code, err := h.documentService.Ingest(ctx, userID, &req); err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
type ListIngestionsRequest struct {
@@ -1413,7 +1402,7 @@ type ListIngestionsRequest struct {
func (h *DocumentHandler) ListIngestionTasks(c *gin.Context) {
var req ListIngestionsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -1430,11 +1419,11 @@ func (h *DocumentHandler) ListIngestionTasks(c *gin.Context) {
}
parseResult, err = h.documentService.ListIngestionTasks(ctx, userID, req.DatasetID, 0, 0)
if err != nil {
- common.ResponseWithCodeData(c, IngestionTaskErrorCode(err), nil, err.Error())
+ common.RespondError(c, IngestionTaskErrorCode(err), err.Error())
return
}
- common.SuccessWithData(c, parseResult, "success")
+ common.RespondSuccessList(c, parseResult, "success")
}
type StartParseDocumentsRequest struct {
@@ -1459,12 +1448,12 @@ func (h *DocumentHandler) StartIngestionTask(c *gin.Context) {
var req StartParseDocumentsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "`document_ids` is required")
+ common.RespondError(c, common.CodeDataError, "`document_ids` is required")
return
}
// Gin's `required` accepts an empty non-nil slice; reject it explicitly.
if len(req.DocumentIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "`document_ids` is required")
+ common.RespondError(c, common.CodeDataError, "`document_ids` is required")
return
}
@@ -1473,7 +1462,7 @@ func (h *DocumentHandler) StartIngestionTask(c *gin.Context) {
switch orderby {
case "create_time", "update_time", "name":
default:
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("invalid orderby field: %s", orderby))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("invalid orderby field: %s", orderby))
return
}
}
@@ -1488,7 +1477,7 @@ func (h *DocumentHandler) StartIngestionTask(c *gin.Context) {
parseResult, err := h.documentService.IngestDocuments(ctx, datasetID, userID, req.DocumentIDs)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
@@ -1498,7 +1487,7 @@ func (h *DocumentHandler) StartIngestionTask(c *gin.Context) {
successCount++
}
}
- common.SuccessWithData(c, map[string]interface{}{"success_count": successCount}, "success")
+ common.RespondSuccess(c, map[string]interface{}{"success_count": successCount}, "success")
}
type StopIngestionsRequest struct {
@@ -1508,7 +1497,7 @@ type StopIngestionsRequest struct {
func (h *DocumentHandler) StopIngestionTasks(c *gin.Context) {
var req StopIngestionsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -1516,10 +1505,10 @@ func (h *DocumentHandler) StopIngestionTasks(c *gin.Context) {
ctx := c.Request.Context()
parseResult, err := h.documentService.StopIngestionTasks(ctx, req.Tasks, userID)
if err != nil {
- common.ResponseWithCodeData(c, IngestionTaskErrorCode(err), nil, err.Error())
+ common.RespondError(c, IngestionTaskErrorCode(err), err.Error())
return
}
- common.SuccessWithData(c, parseResult, "success")
+ common.RespondSuccessList(c, parseResult, "success")
}
type RemoveIngestionsRequest struct {
@@ -1529,12 +1518,12 @@ type RemoveIngestionsRequest struct {
func (h *DocumentHandler) RemoveIngestionTasks(c *gin.Context) {
var req RemoveIngestionsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if req.Tasks == nil || len(req.Tasks) == 0 {
- common.ErrorWithCode(c, common.CodeLackResources, "task_ids is required")
+ common.RespondError(c, common.CodeLackResources, "task_ids is required")
return
}
@@ -1543,10 +1532,10 @@ func (h *DocumentHandler) RemoveIngestionTasks(c *gin.Context) {
deletedTasks, err := h.documentService.RemoveIngestionTasks(ctx, req.Tasks, userID)
if err != nil {
- common.ResponseWithCodeData(c, IngestionTaskErrorCode(err), nil, err.Error())
+ common.RespondError(c, IngestionTaskErrorCode(err), err.Error())
return
}
- common.SuccessWithData(c, deletedTasks, "success")
+ common.RespondSuccessList(c, deletedTasks, "success")
}
type ParseDocumentRequest struct {
@@ -1558,7 +1547,7 @@ func (h *DocumentHandler) ParseDocuments(c *gin.Context) {
var req ParseDocumentRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -1571,10 +1560,10 @@ func (h *DocumentHandler) ParseDocuments(c *gin.Context) {
parseResult, err := h.documentService.ParseDocuments(ctx, datasetID, userID, req.Documents)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
- common.SuccessWithData(c, parseResult, "success")
+ common.RespondSuccessList(c, parseResult, "success")
}
type StopParseDocumentRequest struct {
@@ -1588,7 +1577,12 @@ func (h *DocumentHandler) StopParseDocuments(c *gin.Context) {
var req StopParseDocumentRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeDataError, "`document_ids` is required")
+ common.RespondError(c, common.CodeDataError, "`document_ids` is required")
+ return
+ }
+
+ if !req.CancelAll && len(req.DocumentIDs) == 0 {
+ common.RespondError(c, common.CodeDataError, "`document_ids` is required")
return
}
@@ -1597,7 +1591,7 @@ func (h *DocumentHandler) StopParseDocuments(c *gin.Context) {
// (`document_ids: []`) is still rejected instead of silently falling through
// to a full-dataset cancel.
if req.CancelAll && req.DocumentIDs != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, "`cancel_all` and `document_ids` are mutually exclusive")
+ common.RespondError(c, common.CodeArgumentError, "`cancel_all` and `document_ids` are mutually exclusive")
return
}
@@ -1605,7 +1599,7 @@ func (h *DocumentHandler) StopParseDocuments(c *gin.Context) {
switch orderby {
case "create_time", "update_time", "name":
default:
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("invalid orderby field: %s", orderby))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("invalid orderby field: %s", orderby))
return
}
}
@@ -1619,42 +1613,42 @@ func (h *DocumentHandler) StopParseDocuments(c *gin.Context) {
if req.CancelAll {
for _, s := range req.RunStatuses {
if !common.IsValidRunStatus(s) {
- common.ErrorWithCode(c, common.CodeArgumentError, fmt.Sprintf("invalid run_status: %s", s))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("invalid run_status: %s", s))
return
}
}
result, err := h.documentService.StopParseDocumentsAll(ctx, datasetID, req.RunStatuses)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
if len(req.DocumentIDs) == 0 {
- common.ErrorWithCode(c, common.CodeDataError, "`document_ids` is required")
+ common.RespondError(c, common.CodeDataError, "`document_ids` is required")
return
}
result, err := h.documentService.StopParseDocuments(ctx, datasetID, req.DocumentIDs)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func (h *DocumentHandler) MetadataSummaryByDataset(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := c.Param("dataset_id")
if datasetID == "" {
- common.ErrorWithCode(c, common.CodeServerError, "dataset_id is required")
+ common.RespondError(c, common.CodeServerError, "dataset_id is required")
return
}
ctx := c.Request.Context()
@@ -1670,39 +1664,39 @@ func (h *DocumentHandler) MetadataSummaryByDataset(c *gin.Context) {
summary, err := h.documentService.GetMetadataSummary(ctx, datasetID, docIDS)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, "Failed to get metadata summary"+err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeServerError, nil, "Failed to get metadata summary"+err.Error())
return
}
- common.SuccessWithData(c, gin.H{"summary": summary}, "success")
+ common.RespondSuccess(c, gin.H{"summary": summary}, "success")
}
func (h *DocumentHandler) UpdateDatasetDocument(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeArgumentError, "dataset_id is required")
return
}
documentID := strings.TrimSpace(c.Param("document_id"))
if documentID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "document_id is required")
+ common.RespondError(c, common.CodeArgumentError, "document_id is required")
return
}
body, err := c.GetRawData()
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
var raw map[string]json.RawMessage
if err := json.Unmarshal(body, &raw); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
present := make(map[string]bool, len(raw))
@@ -1727,10 +1721,10 @@ func (h *DocumentHandler) UpdateDatasetDocument(c *gin.Context) {
}
}
}
- common.ResponseWithCodeData(c, common.CodeDataError, nil, fmt.Sprintf("Field: <%s> - Message: <Input should be a valid %s> - Value: <%s>", typeErr.Field, pythonJSONKindName(typeErr), value))
+ common.RespondError(c, common.CodeDataError, fmt.Sprintf("Field: <%s> - Message: <Input should be a valid %s> - Value: <%s>", typeErr.Field, pythonJSONKindName(typeErr), value))
return
}
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if present["parser_config"] && req.ParserConfig != nil {
@@ -1744,30 +1738,30 @@ func (h *DocumentHandler) UpdateDatasetDocument(c *gin.Context) {
)
}
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
}
ctx := c.Request.Context()
data, code, err := h.documentService.UpdateDatasetDocument(ctx, user.ID, datasetID, documentID, &req, present)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
func (h *DocumentHandler) UploadInfo(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
form, err := c.MultipartForm()
if err != nil && !strings.Contains(err.Error(), "request Content-Type isn't multipart/form-data") {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Failed to parse multipart form: "+err.Error())
+ common.RespondError(c, common.CodeArgumentError, "Failed to parse multipart form: "+err.Error())
return
}
@@ -1778,11 +1772,11 @@ func (h *DocumentHandler) UploadInfo(c *gin.Context) {
rawURL := strings.TrimSpace(c.Query("url"))
if len(fileHeaders) > 0 && rawURL != "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Provide either multipart file(s) or ?url=..., not both.")
+ common.RespondError(c, common.CodeArgumentError, "Provide either multipart file(s) or ?url=..., not both.")
return
}
if len(fileHeaders) == 0 && rawURL == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Missing input: provide multipart file(s) or url")
+ common.RespondError(c, common.CodeArgumentError, "Missing input: provide multipart file(s) or url")
return
}
@@ -1799,15 +1793,15 @@ func (h *DocumentHandler) UploadInfo(c *gin.Context) {
if quotaErr := billingService.CheckResources(ctx, user.ID, billing.ResourceDelta{Storage: totalSize}); quotaErr != nil {
var insufficient *billing.InsufficientResourceError
if errors.As(quotaErr, &insufficient) {
- common.ResponseWithDetail(c, common.CodeBillingStorageInsufficient, quotaErr.Error(), gin.H{
+ common.RespondError(c, common.CodeBillingStorageInsufficient, quotaErr.Error(), common.ResponseOptions{Detail: gin.H{
"resource": "storage",
"current": insufficient.Current,
"limit": insufficient.Limit,
"filename": fileHeaders[0].Filename,
- })
+ }})
return
}
- common.ErrorWithCode(c, common.CodeServerError, quotaErr.Error())
+ common.RespondError(c, common.CodeServerError, quotaErr.Error())
return
}
}
@@ -1817,16 +1811,16 @@ func (h *DocumentHandler) UploadInfo(c *gin.Context) {
if rawURL != "" {
data, code, err := h.fileService.UploadDocumentInfoByURL(ctx, user.ID, rawURL)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
return
}
data, code, err := h.fileService.UploadDocumentInfos(ctx, user.ID, fileHeaders)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
@@ -1836,7 +1830,7 @@ func (h *DocumentHandler) UploadInfo(c *gin.Context) {
} else {
payload = data
}
- common.SuccessWithData(c, payload, "success")
+ common.RespondSuccess(c, payload, "success")
}
type documentMetadataBatchRequest struct {
@@ -1856,13 +1850,13 @@ func (h *DocumentHandler) UpdateDocumentMetadatas(c *gin.Context) {
func (h *DocumentHandler) handleBatchUpdateDocumentMetadatas(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeArgumentError, "dataset_id is required")
return
}
ctx := c.Request.Context()
@@ -1873,23 +1867,23 @@ func (h *DocumentHandler) handleBatchUpdateDocumentMetadatas(c *gin.Context) {
var rawBody map[string]interface{}
if err := c.ShouldBindJSON(&rawBody); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Invalid request payload: expected object, got "+inferJSONType(err))
+ common.RespondError(c, common.CodeDataError, "Invalid request payload: expected object, got "+inferJSONType(err))
return
}
selector, errMsg := parseMetadataSelector(rawBody["selector"])
if errMsg != "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, errMsg)
+ common.RespondError(c, common.CodeDataError, errMsg)
return
}
updates, errMsg := parseMetadataUpdates(rawBody["updates"])
if errMsg != "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, errMsg)
+ common.RespondError(c, common.CodeDataError, errMsg)
return
}
deletes, errMsg := parseMetadataDeletes(rawBody["deletes"])
if errMsg != "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, errMsg)
+ common.RespondError(c, common.CodeDataError, errMsg)
return
}
@@ -1901,10 +1895,10 @@ func (h *DocumentHandler) handleBatchUpdateDocumentMetadatas(c *gin.Context) {
resp, code, err := h.documentService.BatchUpdateDocumentMetadatas(ctx, datasetID, req.Selector, req.Updates, req.Deletes)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
func inferJSONType(err error) string {
diff --git a/internal/handler/document_apply_parser_config.go b/internal/handler/document_apply_parser_config.go
index 92ef42d441..500c5ae5ba 100644
--- a/internal/handler/document_apply_parser_config.go
+++ b/internal/handler/document_apply_parser_config.go
@@ -12,18 +12,18 @@ import (
func (h *DocumentHandler) ApplyDatasetParserConfig(c *gin.Context) {
user, code, message := GetUser(c)
if code != common.CodeSuccess {
- common.ErrorWithCode(c, code, message)
+ common.RespondError(c, code, message)
return
}
datasetID := strings.TrimSpace(c.Param("dataset_id"))
if datasetID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "dataset_id is required")
+ common.RespondError(c, common.CodeArgumentError, "dataset_id is required")
return
}
result, code, err := h.documentService.ApplyDatasetParserConfig(c.Request.Context(), user.ID, datasetID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "Parser settings applied. Re-parse files manually to update their content.")
+ common.RespondSuccess(c, result, "Parser settings applied. Re-parse files manually to update their content.")
}
diff --git a/internal/handler/document_test.go b/internal/handler/document_test.go
index 8c07f4de77..7db97946e1 100644
--- a/internal/handler/document_test.go
+++ b/internal/handler/document_test.go
@@ -530,8 +530,8 @@ func TestDocumentReadHandlersForbidden(t *testing.T) {
if err := json.Unmarshal(w.Body.Bytes(), &responseFields); err != nil {
t.Fatal(err)
}
- if _, ok := responseFields["data"]; !ok {
- t.Fatalf("permission error response is missing data field: %s", w.Body.String())
+ if _, ok := responseFields["data"]; ok {
+ t.Fatalf("permission error response must omit absent data: %s", w.Body.String())
}
if fake.metadataKBID != "" {
t.Fatal("GetMetadataSummary should not be called without dataset access")
@@ -909,7 +909,7 @@ func TestUploadDocumentsHandler_LocalUsesFullKBAndIgnoresBadParserConfig(t *test
}
}
-func TestUploadDocumentsHandler_LocalReturnsPartialSuccess(t *testing.T) {
+func TestUploadDocumentsHandler_LocalPartialFailureOmitsData(t *testing.T) {
db := setupUploadHandlerDB(t, "normal")
orig := dao.DB
dao.DB = db
@@ -942,9 +942,8 @@ func TestUploadDocumentsHandler_LocalReturnsPartialSuccess(t *testing.T) {
if resp["code"] != float64(common.CodeServerError) {
t.Fatalf("expected server error code for partial upload, got %v", resp)
}
- data := resp["data"].([]interface{})
- if len(data) != 1 {
- t.Fatalf("expected one successful document, got %v", data)
+ if _, ok := resp["data"]; ok {
+ t.Fatalf("error response must omit data: %v", resp)
}
if !strings.Contains(resp["message"].(string), "bad.exe") {
t.Fatalf("expected failed file in message, got %v", resp["message"])
@@ -1122,11 +1121,8 @@ func TestDocumentHandlerIngestMatchesPythonResponseShape(t *testing.T) {
if resp["code"] != float64(common.CodeSuccess) {
t.Fatalf("expected top-level code 0, got %v", resp["code"])
}
- if resp["data"] != true {
- t.Fatalf("expected top-level data=true, got %#v", resp["data"])
- }
- if _, ok := resp["data"].(map[string]interface{}); ok {
- t.Fatalf("response must not nest code/message under data: %#v", resp["data"])
+ if data, exists := resp["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
if fake.ingestUserID != "user-1" {
t.Fatalf("expected user-1, got %q", fake.ingestUserID)
@@ -1152,7 +1148,7 @@ func TestDocumentIngestRoutePassesPythonBodyToService(t *testing.T) {
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatal(err)
}
- if resp["code"] != float64(common.CodeSuccess) || resp["data"] != true {
+ if _, exists := resp["data"]; resp["code"] != float64(common.CodeSuccess) || exists {
t.Fatalf("unexpected response: %s", w.Body.String())
}
if fake.ingestUserID != "user-1" {
@@ -1232,8 +1228,8 @@ func TestDocumentHandlerIngest_CancelDispatchesToService(t *testing.T) {
if resp["code"] != float64(common.CodeSuccess) {
t.Fatalf("expected code 0, got %v", resp["code"])
}
- if resp["data"] != true {
- t.Fatalf("expected data true, got %#v", resp["data"])
+ if data, exists := resp["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
if fake.ingestReq == nil || len(fake.ingestReq.DocIDs) != 1 || fake.ingestReq.DocIDs[0] != "doc-1" {
t.Fatalf("unexpected ingestReq: %#v", fake.ingestReq)
diff --git a/internal/handler/error.go b/internal/handler/error.go
index 3e0dfb34b2..5fe33b5d77 100644
--- a/internal/handler/error.go
+++ b/internal/handler/error.go
@@ -36,7 +36,7 @@ func jsonInternalError(c *gin.Context, err error) {
zap.String("method", c.Request.Method),
zap.String("path", c.Request.URL.Path),
)
- common.ResponseWithCodeData(c, common.CodeServerError, nil, common.CodeServerError.Message())
+ common.RespondError(c, common.CodeServerError, common.CodeServerError.Message())
}
// HandleNoRoute handles requests to undefined routes
@@ -48,7 +48,7 @@ func HandleNoRoute(c *gin.Context) {
if isOAuthLoginNoRoute(c) ||
(c.Request.Method == http.MethodPost && c.Request.URL.Path == "/api/v1/chats//sessions") ||
(c.Request.Method == http.MethodPatch && strings.HasSuffix(c.Request.URL.Path, "/sessions/")) {
- common.ResponseWithCodeData(c, common.CodeExceptionError, false, "<MethodNotAllowed '405: Method Not Allowed'>")
+ common.RespondError(c, common.CodeExceptionError, "<MethodNotAllowed '405: Method Not Allowed'>")
return
}
@@ -65,7 +65,6 @@ func HandleNoRoute(c *gin.Context) {
c.JSON(http.StatusNotFound, gin.H{
"code": 404,
"message": "Not Found: " + c.Request.URL.Path,
- "data": nil,
"error": "Not Found",
})
}
diff --git a/internal/handler/file.go b/internal/handler/file.go
index 12d67c98f1..82b7cafd4f 100644
--- a/internal/handler/file.go
+++ b/internal/handler/file.go
@@ -49,7 +49,7 @@ func respondFileServiceError(c *gin.Context, err error) {
}
var codedErr *common.CodedError
if errors.As(err, &codedErr) {
- common.ErrorWithCode(c, codedErr.Code, codedErr.Message)
+ common.RespondError(c, codedErr.Code, codedErr.Message)
return
}
jsonInternalError(c, err)
@@ -81,7 +81,7 @@ func NewFileHandler(fileService *file.FileService, userService *service.UserServ
func (h *FileHandler) ListFiles(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
@@ -98,7 +98,7 @@ func (h *FileHandler) ListFiles(c *gin.Context) {
if p, err := strconv.Atoi(pageStr); err == nil && p >= 1 {
page = p
} else if err != nil {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "Invalid page parameter: must be a positive integer")
+ common.RespondError(c, common.CodeParamError, "Invalid page parameter: must be a positive integer")
return
}
}
@@ -107,7 +107,7 @@ func (h *FileHandler) ListFiles(c *gin.Context) {
if pageSizeStr := c.Query("page_size"); pageSizeStr != "" {
if ps, err := strconv.Atoi(pageSizeStr); err == nil {
if ps < 1 {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "Invalid page_size parameter: must be at least 1")
+ common.RespondError(c, common.CodeParamError, "Invalid page_size parameter: must be at least 1")
return
}
if ps > 100 {
@@ -115,7 +115,7 @@ func (h *FileHandler) ListFiles(c *gin.Context) {
}
pageSize = ps
} else {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "Invalid page_size parameter: must be a positive integer")
+ common.RespondError(c, common.CodeParamError, "Invalid page_size parameter: must be a positive integer")
return
}
}
@@ -134,7 +134,7 @@ func (h *FileHandler) ListFiles(c *gin.Context) {
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetParentFolder gets parent folder of a file
@@ -147,14 +147,14 @@ func (h *FileHandler) ListFiles(c *gin.Context) {
func (h *FileHandler) GetParentFolder(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
fileID := c.Param("id")
if fileID == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "file_id is required")
+ common.RespondError(c, common.CodeBadRequest, "file_id is required")
return
}
@@ -166,7 +166,7 @@ func (h *FileHandler) GetParentFolder(c *gin.Context) {
return
}
- common.SuccessWithData(c, gin.H{"parent_folder": parentFolder}, common.CodeSuccess.Message())
+ common.RespondSuccess(c, gin.H{"parent_folder": parentFolder}, common.CodeSuccess.Message())
}
// GetFileAncestors gets all ancestor folders of a file (matches Python /files/<file_id>/ancestors)
@@ -180,14 +180,14 @@ func (h *FileHandler) GetParentFolder(c *gin.Context) {
func (h *FileHandler) GetFileAncestors(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
fileID := c.Param("id")
if fileID == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "file id is required")
+ common.RespondError(c, common.CodeBadRequest, "file id is required")
return
}
@@ -206,7 +206,7 @@ func (h *FileHandler) GetFileAncestors(c *gin.Context) {
return
}
- common.SuccessWithData(c, gin.H{"parent_folders": parentFolders}, common.CodeSuccess.Message())
+ common.RespondSuccess(c, gin.H{"parent_folders": parentFolders}, common.CodeSuccess.Message())
}
type CreateFolderRequest struct {
@@ -241,7 +241,7 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New(errorMessage)
return
@@ -259,13 +259,13 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
uploadLimit := file.DeploymentUploadMaxBytes()
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, uploadLimit)
if cl := c.Request.ContentLength; cl > uploadLimit {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "request body exceeds deployment upload limit")
+ common.RespondError(c, common.CodeBadRequest, "request body exceeds deployment upload limit")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("request body exceeds deployment upload limit")
return
}
if err := c.Request.ParseMultipartForm(32 << 20); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "Failed to parse multipart form: "+err.Error())
+ common.RespondError(c, common.CodeBadRequest, "Failed to parse multipart form: "+err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = fmt.Errorf("failed to parse multipart form: %w", err)
return
@@ -273,7 +273,7 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
form := c.Request.MultipartForm
if form == nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "No file part!")
+ common.RespondError(c, common.CodeBadRequest, "No file part!")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("no file part")
return
@@ -305,7 +305,7 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
files := form.File["file"]
if len(files) == 0 {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "No file selected!")
+ common.RespondError(c, common.CodeBadRequest, "No file selected!")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("no file selected")
return
@@ -313,7 +313,7 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
for _, fileHeader := range files {
if fileHeader.Filename == "" {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "No file selected!")
+ common.RespondError(c, common.CodeBadRequest, "No file selected!")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("no file selected")
return
@@ -326,13 +326,13 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
}
- common.SuccessWithData(c, result, common.CodeSuccess.Message())
+ common.RespondSuccessList(c, result, common.CodeSuccess.Message())
return
}
@@ -340,7 +340,7 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
operationLog.Operation = "create_directory"
var req CreateFolderRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, 400, nil, err.Error())
return
}
@@ -366,17 +366,17 @@ func (h *FileHandler) UploadFile(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
}
- common.SuccessWithData(c, result, common.CodeSuccess.Message())
+ common.RespondSuccess(c, result, common.CodeSuccess.Message())
return
}
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, "Unsupported content type")
+ common.RespondError(c, common.CodeBadRequest, "Unsupported content type")
return
}
@@ -409,7 +409,7 @@ func (h *FileHandler) DeleteFiles(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -418,7 +418,7 @@ func (h *FileHandler) DeleteFiles(c *gin.Context) {
var req DeleteFileRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
@@ -428,13 +428,13 @@ func (h *FileHandler) DeleteFiles(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
}
- common.SuccessWithData(c, true, common.CodeSuccess.Message())
+ common.RespondSuccess(c, nil, common.CodeSuccess.Message())
}
// MoveFileRequest represents the request body for move files operation
@@ -470,7 +470,7 @@ func (h *FileHandler) MoveFiles(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -479,7 +479,7 @@ func (h *FileHandler) MoveFiles(c *gin.Context) {
var req MoveFileRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
@@ -487,7 +487,7 @@ func (h *FileHandler) MoveFiles(c *gin.Context) {
// Validate: at least one of dest_file_id or new_name must be provided
if req.DestFileID == "" && req.NewName == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "at least one of dest_file_id or new_name must be provided")
+ common.RespondError(c, common.CodeParamError, "at least one of dest_file_id or new_name must be provided")
operationLog.Code = int(common.CodeParamError)
operationLog.Error = errors.New("at least one of dest_file_id or new_name must be provided")
return
@@ -495,7 +495,7 @@ func (h *FileHandler) MoveFiles(c *gin.Context) {
// Validate: new_name can only be used with a single file
if req.NewName != "" && len(req.SrcFileIDs) > 1 {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "new_name can only be used with a single file")
+ common.RespondError(c, common.CodeParamError, "new_name can only be used with a single file")
operationLog.Code = int(common.CodeParamError)
operationLog.Error = errors.New("new_name can only be used with a single file")
return
@@ -506,13 +506,13 @@ func (h *FileHandler) MoveFiles(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
}
- common.SuccessWithData(c, true, common.CodeSuccess.Message())
+ common.RespondSuccess(c, nil, common.CodeSuccess.Message())
}
// Download handles file download
@@ -538,7 +538,7 @@ func (h *FileHandler) Download(c *gin.Context) {
}()
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -547,7 +547,7 @@ func (h *FileHandler) Download(c *gin.Context) {
fileID := c.Param("id")
if fileID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "id is required")
+ common.RespondError(c, common.CodeParamError, "id is required")
operationLog.Code = int(common.CodeParamError)
operationLog.Error = errors.New("id is required")
return
@@ -562,7 +562,7 @@ func (h *FileHandler) Download(c *gin.Context) {
operationLog.Error = err
return
}
- common.ResponseWithCodeData(c, common.CodeUnauthorized, nil, err.Error())
+ common.RespondError(c, common.CodeUnauthorized, err.Error())
operationLog.Code = int(common.CodeUnauthorized)
operationLog.Error = err
return
@@ -571,7 +571,7 @@ func (h *FileHandler) Download(c *gin.Context) {
// Get storage
storageImpl := storage.GetStorageFactory().GetStorage()
if storageImpl == nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "storage not initialized")
+ common.RespondError(c, common.CodeServerError, "storage not initialized")
operationLog.Code = int(common.CodeServerError)
operationLog.Error = errors.New("storage not initialized")
return
@@ -589,7 +589,7 @@ func (h *FileHandler) Download(c *gin.Context) {
var storageAddr *file.StorageAddress
storageAddr, err = h.fileService.GetStorageAddress(ctx, fileID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Failed to get file storage address: "+err.Error())
+ common.RespondError(c, common.CodeServerError, "Failed to get file storage address: "+err.Error())
operationLog.Code = int(common.CodeServerError)
operationLog.Error = errors.New("failed to get file storage address")
return
@@ -603,7 +603,7 @@ func (h *FileHandler) Download(c *gin.Context) {
if getErr != nil {
errMsg += ": " + getErr.Error()
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, errMsg)
+ common.RespondError(c, common.CodeServerError, errMsg)
operationLog.Code = int(common.CodeServerError)
operationLog.Error = errors.New(errMsg)
return
@@ -647,7 +647,7 @@ func (h *FileHandler) LinkToDatasets(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -661,7 +661,7 @@ func (h *FileHandler) LinkToDatasets(c *gin.Context) {
_ = c.ShouldBindJSON(&req)
// Mirror Python @validate_request("file_ids", "kb_ids"): a key absent from
- // the body returns ARGUMENT_ERROR (101) with data=null and the aggregated
+ // the body returns ARGUMENT_ERROR (101) without data and with the aggregated
// message. Python's check is key-presence based, so an explicit empty list
// is valid — e.g. kb_ids: [] in replace mode unlinks all datasets.
var missing []string
@@ -673,7 +673,7 @@ func (h *FileHandler) LinkToDatasets(c *gin.Context) {
}
if len(missing) > 0 {
errorMessage = fmt.Sprintf("required argument are missing: %s; ", strings.Join(missing, ","))
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, errorMessage)
+ common.RespondError(c, common.CodeArgumentError, errorMessage)
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = errors.New(errorMessage)
return
@@ -682,7 +682,7 @@ func (h *FileHandler) LinkToDatasets(c *gin.Context) {
mode := strings.ToLower(c.DefaultQuery("mode", "replace"))
if mode != "add" && mode != "replace" {
errorMessage = "mode must be 'add' or 'replace'"
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, errorMessage)
+ common.RespondError(c, common.CodeArgumentError, errorMessage)
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = errors.New(errorMessage)
return
@@ -690,13 +690,13 @@ func (h *FileHandler) LinkToDatasets(c *gin.Context) {
ctx := c.Request.Context()
if err := h.file2DocumentService.LinkToDatasets(ctx, user.ID, &req, mode); err != nil {
errorCode = linkToDatasetsErrorCode(err)
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
operationLog.Code = int(errorCode)
operationLog.Error = err
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// linkToDatasetsErrorCode maps File2DocumentService sentinel errors to
diff --git a/internal/handler/file_commit.go b/internal/handler/file_commit.go
index 0d5dadbeb5..bf199da92d 100644
--- a/internal/handler/file_commit.go
+++ b/internal/handler/file_commit.go
@@ -83,14 +83,14 @@ func CommitFolderResolver(h *FileCommitHandler, entityType, urlParam string) gin
return func(c *gin.Context) {
id := c.Param(urlParam)
if id == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, fmt.Sprintf("%s is required", urlParam))
+ common.RespondError(c, common.CodeParamError, fmt.Sprintf("%s is required", urlParam))
c.Abort()
return
}
ctx := c.Request.Context()
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
c.Abort()
return
}
@@ -110,7 +110,7 @@ func CommitFolderResolver(h *FileCommitHandler, entityType, urlParam string) gin
}
folderID, err := h.ResolveFolderID(ctx, entityType, id)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, fmt.Sprintf("%s folder not found", entityType))
+ common.RespondError(c, common.CodeNotFound, fmt.Sprintf("%s folder not found", entityType))
c.Abort()
return
}
@@ -177,24 +177,24 @@ type CreateCommitRequest struct {
func (h *FileCommitHandler) CreateCommit(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
folderID := commitFolderID(c)
if folderID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "folder_id is required")
+ common.RespondError(c, common.CodeParamError, "folder_id is required")
return
}
if !h.folderAccessible(c, user.ID, folderID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Workspace not found")
+ common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
var req CreateCommitRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -204,7 +204,7 @@ func (h *FileCommitHandler) CreateCommit(c *gin.Context) {
// A delete change for a file that is still in the folder is caller
// input, not a server fault.
if errors.Is(err, file.ErrDeleteLiveFile) {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
jsonInternalError(c, err)
@@ -216,7 +216,7 @@ func (h *FileCommitHandler) CreateCommit(c *gin.Context) {
ct = *commit.CreateTime
}
- common.SuccessWithData(c, entity.CommitResponse{
+ common.RespondSuccess(c, entity.CommitResponse{
ID: commit.ID,
FolderID: commit.FolderID,
ParentID: commit.ParentID,
@@ -244,18 +244,18 @@ func (h *FileCommitHandler) CreateCommit(c *gin.Context) {
func (h *FileCommitHandler) ListCommits(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
folderID := commitFolderID(c)
if folderID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "folder_id is required")
+ common.RespondError(c, common.CodeParamError, "folder_id is required")
return
}
if !h.folderAccessible(c, user.ID, folderID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Workspace not found")
+ common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
page := 1
@@ -293,7 +293,7 @@ func (h *FileCommitHandler) ListCommits(c *gin.Context) {
if slug := c.Query("slug"); slug != "" {
datasetID := c.Param("dataset_id")
if datasetID == "" {
- common.ErrorWithCode(c, common.CodeArgumentError, "slug requires a dataset scope")
+ common.RespondError(c, common.CodeArgumentError, "slug requires a dataset scope")
return
}
pageType := c.Query("page_type")
@@ -309,7 +309,7 @@ func (h *FileCommitHandler) ListCommits(c *gin.Context) {
jsonInternalError(c, err)
return
}
- common.SuccessWithData(c, gin.H{
+ common.RespondSuccess(c, gin.H{
"total": total,
"page": page,
"page_size": pageSize,
@@ -341,7 +341,7 @@ func (h *FileCommitHandler) ListCommits(c *gin.Context) {
})
}
- common.SuccessWithData(c, gin.H{
+ common.RespondSuccess(c, gin.H{
"total": total,
"page": page,
"page_size": pageSize,
@@ -362,25 +362,25 @@ func (h *FileCommitHandler) ListCommits(c *gin.Context) {
func (h *FileCommitHandler) GetCommit(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
folderID := commitFolderID(c)
commitID := c.Param("commit_id")
if commitID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "commit_id is required")
+ common.RespondError(c, common.CodeParamError, "commit_id is required")
return
}
if !h.folderAccessible(c, user.ID, folderID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Workspace not found")
+ common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
ctx := c.Request.Context()
commit, err := h.commitService.GetCommit(ctx, commitID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found")
+ common.RespondError(c, common.CodeNotFound, "Commit not found")
return
}
@@ -389,16 +389,16 @@ func (h *FileCommitHandler) GetCommit(c *gin.Context) {
// the dataset id as the commit scope after the resolver has authorized it.
datasetID := c.Param("dataset_id")
if commit.FolderID != folderID && (datasetID == "" || commit.FolderID != datasetID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found in workspace")
+ common.RespondError(c, common.CodeNotFound, "Commit not found in workspace")
return
}
if datasetID != "" && commit.Title != nil {
detail, err := h.commitService.GetPageCommitDetail(ctx, datasetID, commitID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found")
+ common.RespondError(c, common.CodeNotFound, "Commit not found")
return
}
- common.SuccessWithData(c, detail, common.CodeSuccess.Message())
+ common.RespondSuccess(c, detail, common.CodeSuccess.Message())
return
}
@@ -412,7 +412,7 @@ func (h *FileCommitHandler) GetCommit(c *gin.Context) {
ct = *commit.CreateTime
}
- common.SuccessWithData(c, gin.H{
+ common.RespondSuccess(c, gin.H{
"id": commit.ID,
"folder_id": commit.FolderID,
"parent_id": commit.ParentID,
@@ -437,29 +437,29 @@ func (h *FileCommitHandler) GetCommit(c *gin.Context) {
func (h *FileCommitHandler) ListCommitFiles(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
folderID := commitFolderID(c)
commitID := c.Param("commit_id")
if commitID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "commit_id is required")
+ common.RespondError(c, common.CodeParamError, "commit_id is required")
return
}
if !h.folderAccessible(c, user.ID, folderID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Workspace not found")
+ common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
ctx := c.Request.Context()
commit, err := h.commitService.GetCommit(ctx, commitID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found")
+ common.RespondError(c, common.CodeNotFound, "Commit not found")
return
}
if commit.FolderID != folderID {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found in workspace")
+ common.RespondError(c, common.CodeNotFound, "Commit not found in workspace")
return
}
@@ -469,7 +469,7 @@ func (h *FileCommitHandler) ListCommitFiles(c *gin.Context) {
return
}
- common.SuccessWithData(c, items, common.CodeSuccess.Message())
+ common.RespondSuccessList(c, items, common.CodeSuccess.Message())
}
// DiffCommits compares two commits
@@ -486,7 +486,7 @@ func (h *FileCommitHandler) ListCommitFiles(c *gin.Context) {
func (h *FileCommitHandler) DiffCommits(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -494,27 +494,27 @@ func (h *FileCommitHandler) DiffCommits(c *gin.Context) {
fromID := c.Query("from")
toID := c.Query("to")
if fromID == "" || toID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "'from' and 'to' query parameters are required")
+ common.RespondError(c, common.CodeParamError, "'from' and 'to' query parameters are required")
return
}
if !h.folderAccessible(c, user.ID, folderID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Workspace not found")
+ common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
ctx := c.Request.Context()
fromCommit, err := h.commitService.GetCommit(ctx, fromID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found")
+ common.RespondError(c, common.CodeNotFound, "Commit not found")
return
}
toCommit, err := h.commitService.GetCommit(ctx, toID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found")
+ common.RespondError(c, common.CodeNotFound, "Commit not found")
return
}
if fromCommit.FolderID != folderID || toCommit.FolderID != folderID {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found in workspace")
+ common.RespondError(c, common.CodeNotFound, "Commit not found in workspace")
return
}
@@ -524,7 +524,7 @@ func (h *FileCommitHandler) DiffCommits(c *gin.Context) {
return
}
- common.SuccessWithData(c, diff, common.CodeSuccess.Message())
+ common.RespondSuccessList(c, diff, common.CodeSuccess.Message())
}
// GetUncommittedChanges gets uncommitted changes
@@ -539,18 +539,18 @@ func (h *FileCommitHandler) DiffCommits(c *gin.Context) {
func (h *FileCommitHandler) GetUncommittedChanges(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
folderID := commitFolderID(c)
if folderID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "folder_id is required")
+ common.RespondError(c, common.CodeParamError, "folder_id is required")
return
}
if !h.folderAccessible(c, user.ID, folderID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Workspace not found")
+ common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
ctx := c.Request.Context()
@@ -560,7 +560,7 @@ func (h *FileCommitHandler) GetUncommittedChanges(c *gin.Context) {
return
}
- common.SuccessWithData(c, changes, common.CodeSuccess.Message())
+ common.RespondSuccessList(c, changes, common.CodeSuccess.Message())
}
// GetCommitTree gets the folder tree snapshot for a commit
@@ -576,29 +576,29 @@ func (h *FileCommitHandler) GetUncommittedChanges(c *gin.Context) {
func (h *FileCommitHandler) GetCommitTree(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
folderID := commitFolderID(c)
commitID := c.Param("commit_id")
if commitID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "commit_id is required")
+ common.RespondError(c, common.CodeParamError, "commit_id is required")
return
}
if !h.folderAccessible(c, user.ID, folderID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Workspace not found")
+ common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
ctx := c.Request.Context()
commit, err := h.commitService.GetCommit(ctx, commitID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found")
+ common.RespondError(c, common.CodeNotFound, "Commit not found")
return
}
if commit.FolderID != folderID {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found in workspace")
+ common.RespondError(c, common.CodeNotFound, "Commit not found in workspace")
return
}
@@ -608,7 +608,7 @@ func (h *FileCommitHandler) GetCommitTree(c *gin.Context) {
return
}
- common.SuccessWithData(c, tree, common.CodeSuccess.Message())
+ common.RespondSuccess(c, tree, common.CodeSuccess.Message())
}
// GetCommitFileContent gets file content as it existed in a given commit
@@ -625,7 +625,7 @@ func (h *FileCommitHandler) GetCommitTree(c *gin.Context) {
func (h *FileCommitHandler) GetCommitFileContent(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -634,32 +634,32 @@ func (h *FileCommitHandler) GetCommitFileContent(c *gin.Context) {
fileID := c.Param("file_id")
if folderID == "" || commitID == "" || fileID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "folder_id, commit_id, and file_id are required")
+ common.RespondError(c, common.CodeParamError, "folder_id, commit_id, and file_id are required")
return
}
if !h.folderAccessible(c, user.ID, folderID) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Workspace not found")
+ common.RespondError(c, common.CodeNotFound, "Workspace not found")
return
}
ctx := c.Request.Context()
commit, err := h.commitService.GetCommit(ctx, commitID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found")
+ common.RespondError(c, common.CodeNotFound, "Commit not found")
return
}
if commit.FolderID != folderID {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Commit not found in workspace")
+ common.RespondError(c, common.CodeNotFound, "Commit not found in workspace")
return
}
content, err := h.commitService.GetCommitFileContent(ctx, folderID, commitID, fileID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, err.Error())
+ common.RespondError(c, common.CodeNotFound, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"content": string(content)}, common.CodeSuccess.Message())
+ common.RespondSuccess(c, gin.H{"content": string(content)}, common.CodeSuccess.Message())
}
// GetFileVersionHistory gets version history for a specific file
@@ -674,13 +674,13 @@ func (h *FileCommitHandler) GetCommitFileContent(c *gin.Context) {
func (h *FileCommitHandler) GetFileVersionHistory(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
fileID := c.Param("file_id")
if fileID == "" {
- common.ResponseWithCodeData(c, common.CodeParamError, nil, "file_id is required")
+ common.RespondError(c, common.CodeParamError, "file_id is required")
return
}
@@ -690,7 +690,7 @@ func (h *FileCommitHandler) GetFileVersionHistory(c *gin.Context) {
Kind: permission.ResourceKindFile,
ID: fileID,
}, permission.OperationRead) != nil {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, "File not found")
+ common.RespondError(c, common.CodeNotFound, "File not found")
return
}
@@ -700,5 +700,5 @@ func (h *FileCommitHandler) GetFileVersionHistory(c *gin.Context) {
return
}
- common.SuccessWithData(c, versions, common.CodeSuccess.Message())
+ common.RespondSuccessList(c, versions, common.CodeSuccess.Message())
}
diff --git a/internal/handler/langfuse.go b/internal/handler/langfuse.go
index 164fd24c83..2e1e6a26fe 100644
--- a/internal/handler/langfuse.go
+++ b/internal/handler/langfuse.go
@@ -61,25 +61,25 @@ type SetLangfuseRequest struct {
func (h *LangfuseHandler) SetAPIKey(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req SetLangfuseRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Invalid request: "+err.Error())
+ common.RespondError(c, common.CodeDataError, "Invalid request: "+err.Error())
return
}
ctx := c.Request.Context()
row, code, err := h.langfuseService.SetAPIKey(ctx, user.ID, req.SecretKey, req.PublicKey, req.Host)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
// Echo back the stored keys, matching the Python langfuse_keys payload.
- common.SuccessWithData(c, gin.H{
+ common.RespondSuccess(c, gin.H{
"tenant_id": row.TenantID,
"secret_key": row.SecretKey,
"public_key": row.PublicKey,
@@ -91,37 +91,32 @@ func (h *LangfuseHandler) SetAPIKey(c *gin.Context) {
func (h *LangfuseHandler) GetAPIKey(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
data, code, message, err := h.langfuseService.GetAPIKey(ctx, user.ID)
if err != nil {
- common.ResponseWithCodeData(c, code, nil, message)
+ common.RespondError(c, code, message)
return
}
- common.ResponseWithCodeData(c, code, data, message)
+ common.RespondSuccess(c, data, message)
}
// DeleteAPIKey handles DELETE /langfuse/api-key.
func (h *LangfuseHandler) DeleteAPIKey(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
- ok, code, message, err := h.langfuseService.DeleteAPIKey(ctx, user.ID)
+ _, code, message, err := h.langfuseService.DeleteAPIKey(ctx, user.ID)
if err != nil {
- common.ResponseWithCodeData(c, code, nil, message)
+ common.RespondError(c, code, message)
return
}
- // No record: mirror get_json_result(message=...) with data=nil.
- if message != "" {
- common.SuccessWithData(c, nil, message)
- return
- }
- common.SuccessWithData(c, ok, "success")
+ common.RespondSuccess(c, nil, message)
}
diff --git a/internal/handler/langfuse_test.go b/internal/handler/langfuse_test.go
index b4f0d69892..021b567540 100644
--- a/internal/handler/langfuse_test.go
+++ b/internal/handler/langfuse_test.go
@@ -236,8 +236,8 @@ func TestLangfuseHandler_DeleteAPIKey_Success(t *testing.T) {
if payload["code"] != float64(common.CodeSuccess) {
t.Fatalf("payload=%v", payload)
}
- if payload["data"] != true {
- t.Fatalf("expected data true, got %v", payload["data"])
+ if data, exists := payload["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
}
diff --git a/internal/handler/mcp.go b/internal/handler/mcp.go
index 60e7d0bf13..ce68a56d85 100644
--- a/internal/handler/mcp.go
+++ b/internal/handler/mcp.go
@@ -72,42 +72,42 @@ func NewMCPHandler(mcpService *service.MCPService) *MCPHandler {
func (h *MCPHandler) CreateMCPServer(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.CreateMCPServerRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
ctx := c.Request.Context()
result, code, err := h.mcpService.CreateMCPServer(ctx, user.ID, req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// ListMCPServers lists MCP servers for an owned tenant or a requested tenant the caller belongs to.
func (h *MCPHandler) ListMCPServers(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
page, err := parseMCPServerPage(c.Query("page"))
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
pageSize, err := parseMCPServerPageSize(c.Query("page_size"))
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
ctx := c.Request.Context()
@@ -120,20 +120,20 @@ func (h *MCPHandler) ListMCPServers(c *gin.Context) {
result, code, err := h.mcpService.ListMCPServers(ctx, user.ID, tenantID, mcpIDs, keywords, page, pageSize, orderby, desc)
if err != nil {
if code == common.CodeServerError {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, code, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, code, nil, err.Error())
return
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func (h *MCPHandler) GetMCPServer(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
@@ -144,7 +144,7 @@ func (h *MCPHandler) GetMCPServer(c *gin.Context) {
mcpDetailError(c, code, err)
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
@@ -153,56 +153,56 @@ func (h *MCPHandler) GetMCPServer(c *gin.Context) {
mcpDetailError(c, code, err)
return
}
- common.SuccessWithData(c, newMCPServerResponse(result), "success")
+ common.RespondSuccess(c, newMCPServerResponse(result), "success")
}
func mcpDetailError(c *gin.Context, code common.ErrorCode, err error) {
if code == common.CodeDataError || code == common.CodeUnauthorized || code == common.CodeForbidden || code == common.CodeNotFound {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
}
// UpdateMCPServer updates an MCP server for the current user.
func (h *MCPHandler) UpdateMCPServer(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
mcpID := c.Param("mcp_id")
var req service.UpdateMCPServerRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
ctx := c.Request.Context()
result, code, err := h.mcpService.UpdateMCPServer(ctx, user.ID, mcpID, req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, newMCPServerResponse(result), "success")
+ common.RespondSuccess(c, newMCPServerResponse(result), "success")
}
// DeleteMCPServer deletes an MCP server for the current user.
func (h *MCPHandler) DeleteMCPServer(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
- result, code, err := h.mcpService.DeleteMCPServer(ctx, user.ID, c.Param("mcp_id"))
+ _, code, err := h.mcpService.DeleteMCPServer(ctx, user.ID, c.Param("mcp_id"))
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, nil, "success")
}
// mcpErrorResponse maps the import / test sentinel errors to the response
@@ -213,7 +213,7 @@ func mcpErrorResponse(c *gin.Context, err error) bool {
}
if permissionresponse.IsPermissionError(err) {
code, normalized := permissionresponse.NormalizeHidden(err)
- common.ErrorWithCode(c, code, normalized.Error())
+ common.RespondError(c, code, normalized.Error())
return true
}
switch {
@@ -221,9 +221,9 @@ func mcpErrorResponse(c *gin.Context, err error) bool {
errors.Is(err, service.ErrMCPInvalidName),
errors.Is(err, service.ErrMCPInvalidURL),
errors.Is(err, service.ErrMCPTestFailed):
- common.ResponseWithCodeData(c, common.CodeDataError, nil, mcpErrorMessage(err))
+ common.RespondError(c, common.CodeDataError, mcpErrorMessage(err))
default:
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
}
return true
}
@@ -286,19 +286,19 @@ type ImportMCPRequest struct {
func (h *MCPHandler) ImportMCPServers(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
body, err := io.ReadAll(c.Request.Body)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
var raw map[string]json.RawMessage
if len(body) > 0 {
if err = json.Unmarshal(body, &raw); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
}
@@ -307,17 +307,17 @@ func (h *MCPHandler) ImportMCPServers(c *gin.Context) {
if !hasServers {
// Match Python validate_request: code 101, message includes the
// trailing "; " separator the Python decorator emits.
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "required argument are missing: mcpServers; ")
+ common.RespondError(c, common.CodeArgumentError, "required argument are missing: mcpServers; ")
return
}
var servers map[string]map[string]interface{}
if err = json.Unmarshal(rawServers, &servers); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
if len(servers) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "No MCP servers provided.")
+ common.RespondError(c, common.CodeDataError, "No MCP servers provided.")
return
}
@@ -333,14 +333,14 @@ func (h *MCPHandler) ImportMCPServers(c *gin.Context) {
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalized := permissionresponse.Normalize(err)
- common.ErrorWithCode(c, code, normalized.Error())
+ common.RespondError(c, code, normalized.Error())
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeBadRequest, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeBadRequest, nil, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"results": results}, "success")
+ common.RespondSuccess(c, gin.H{"results": results}, "success")
}
// TestMCPServer opens a live MCP session and returns the tools the server advertises.
@@ -354,19 +354,19 @@ func (h *MCPHandler) ImportMCPServers(c *gin.Context) {
func (h *MCPHandler) TestMCPServer(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
mcpID := c.Param("mcp_id")
if mcpID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "mcp_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "mcp_id is required")
return
}
var req service.TestServerRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
@@ -378,7 +378,7 @@ func (h *MCPHandler) TestMCPServer(c *gin.Context) {
missingFields = append(missingFields, "server_type")
}
if len(missingFields) > 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "required argument are missing: "+strings.Join(missingFields, ", ")+"; ")
+ common.RespondError(c, common.CodeArgumentError, "required argument are missing: "+strings.Join(missingFields, ", ")+"; ")
return
}
@@ -387,7 +387,7 @@ func (h *MCPHandler) TestMCPServer(c *gin.Context) {
if mcpErrorResponse(c, err) {
return
}
- common.SuccessWithData(c, tools, "success")
+ common.RespondSuccessList(c, tools, "success")
}
func newMCPServerResponse(server *entity.MCPServer) *mcpServerResponse {
diff --git a/internal/handler/mcp_server.go b/internal/handler/mcp_server.go
index 385a2aeedd..cfcfdf54a4 100644
--- a/internal/handler/mcp_server.go
+++ b/internal/handler/mcp_server.go
@@ -98,7 +98,7 @@ func (h *MCPServerHandler) NewStandalone(ctx context.Context, auth *AuthHandler,
func (h *MCPServerHandler) HandleMCP(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
diff --git a/internal/handler/mcp_test.go b/internal/handler/mcp_test.go
index e0258e13a9..e6eaddf33f 100644
--- a/internal/handler/mcp_test.go
+++ b/internal/handler/mcp_test.go
@@ -79,7 +79,7 @@ func TestNewMCPServerResponsePreservesNullDescriptionAndFormatsDates(t *testing.
}
}
-func TestMCPDetailDataErrorOmitsDataFieldLikePython(t *testing.T) {
+func TestMCPDetailDataErrorOmitsData(t *testing.T) {
gin.SetMode(gin.TestMode)
recorder := httptest.NewRecorder()
c, _ := gin.CreateTestContext(recorder)
@@ -100,6 +100,6 @@ func TestMCPDetailDataErrorOmitsDataFieldLikePython(t *testing.T) {
t.Fatalf("message = %v", body["message"])
}
if _, ok := body["data"]; ok {
- t.Fatalf("body unexpectedly contains data field: %s", recorder.Body.String())
+ t.Fatalf("expected data to be omitted: %s", recorder.Body.String())
}
}
diff --git a/internal/handler/memory.go b/internal/handler/memory.go
index c7db153ce4..1d080809ac 100644
--- a/internal/handler/memory.go
+++ b/internal/handler/memory.go
@@ -84,7 +84,7 @@ func NewMemoryHandler(memoryService *service.MemoryService) *MemoryHandler {
func (h *MemoryHandler) CreateMemory(c *gin.Context) {
user, errorCode, err := billingQuotaUser(c)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
if !billingEnforceApps(c, user.ID) {
@@ -95,7 +95,7 @@ func (h *MemoryHandler) CreateMemory(c *gin.Context) {
// GetUser is a context value set by the authentication middleware
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
@@ -103,31 +103,31 @@ func (h *MemoryHandler) CreateMemory(c *gin.Context) {
// Parse JSON request body
var req service.CreateMemoryRequest
if err = c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
// Validate required field: name
if strings.TrimSpace(req.Name) == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "name is required")
+ common.RespondError(c, common.CodeArgumentError, "name is required")
return
}
// Validate required field: memory_type (must be non-empty array)
if len(req.MemoryType) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "memory type is required and must be a list")
+ common.RespondError(c, common.CodeArgumentError, "memory type is required and must be a list")
return
}
// Validate required field: embd_id
if req.EmbdID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "embedding model ID is required")
+ common.RespondError(c, common.CodeArgumentError, "embedding model ID is required")
return
}
// Validate required field: llm_id
if req.LLMID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "language model ID is required")
+ common.RespondError(c, common.CodeArgumentError, "language model ID is required")
return
}
@@ -140,17 +140,17 @@ func (h *MemoryHandler) CreateMemory(c *gin.Context) {
errMsg := err.Error()
// Determine if it's an argument error and return appropriate error code
if isArgumentError(errMsg) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, errMsg)
+ common.RespondError(c, common.CodeArgumentError, errMsg)
return
}
// Other errors return server error
- common.ResponseWithCodeData(c, common.CodeServerError, nil, errMsg)
+ common.RespondError(c, common.CodeServerError, errMsg)
return
}
// Return success response
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// UpdateMemory handles PUT request for updating Memory
@@ -184,14 +184,14 @@ func (h *MemoryHandler) UpdateMemory(c *gin.Context) {
// Get memory_id from URL path
memoryID := c.Param("memory_id")
if memoryID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "memory ID is required")
+ common.RespondError(c, common.CodeArgumentError, "memory ID is required")
return
}
// Get current logged-in user information
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := user.ID
@@ -199,7 +199,7 @@ func (h *MemoryHandler) UpdateMemory(c *gin.Context) {
// Parse JSON request body
var req service.UpdateMemoryRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, nil, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -214,23 +214,23 @@ func (h *MemoryHandler) UpdateMemory(c *gin.Context) {
errMsg := err.Error()
// Check if it's a "not found" error
if strings.Contains(errMsg, "not found") {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, errMsg)
+ common.RespondError(c, common.CodeNotFound, errMsg)
return
}
// Check if it's an argument error
if isArgumentError(errMsg) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, errMsg)
+ common.RespondError(c, common.CodeArgumentError, errMsg)
return
}
// Other errors return server error
- common.ResponseWithCodeData(c, common.CodeServerError, nil, errMsg)
+ common.RespondError(c, common.CodeServerError, errMsg)
return
}
// Return success response
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// DeleteMemory handles DELETE request for deleting Memory
@@ -248,14 +248,14 @@ func (h *MemoryHandler) DeleteMemory(c *gin.Context) {
// Get memory_id from URL path
memoryID := c.Param("memory_id")
if memoryID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "memory ID is required")
+ common.RespondError(c, common.CodeArgumentError, "memory ID is required")
return
}
// Get current logged-in user for access control
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
@@ -269,17 +269,17 @@ func (h *MemoryHandler) DeleteMemory(c *gin.Context) {
errMsg := err.Error()
// Check if it's a "not found" error
if strings.Contains(errMsg, "not found") {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, errMsg)
+ common.RespondError(c, common.CodeNotFound, errMsg)
return
}
// Other errors return server error
- common.ResponseWithCodeData(c, common.CodeServerError, nil, errMsg)
+ common.RespondError(c, common.CodeServerError, errMsg)
return
}
// Return success response
- common.SuccessNoData(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
// splitQueryValues returns every value sent under the repeated query key,
@@ -322,16 +322,16 @@ func (h *MemoryHandler) ListMemories(c *gin.Context) {
// Get current logged-in user information
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
if c.Query("type") == "filter" {
result, err := h.memoryService.ListMemoryFilters(c.Request.Context(), user.ID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
return
}
@@ -370,12 +370,12 @@ func (h *MemoryHandler) ListMemories(c *gin.Context) {
errors.Is(err, permission.ErrMembershipNotFound) || errors.Is(err, permission.ErrResourceNotFound) {
code, err = permissionresponse.Normalize(err)
}
- common.ResponseWithCodeData(c, code, nil, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
// Return success response
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetMemoryConfig handles GET request for getting Memory configuration
@@ -393,14 +393,14 @@ func (h *MemoryHandler) GetMemoryConfig(c *gin.Context) {
// Get memory_id from URL path
memoryID := c.Param("memory_id")
if memoryID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "memory ID is required")
+ common.RespondError(c, common.CodeArgumentError, "memory ID is required")
return
}
// Get current logged-in user for access control
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
@@ -414,17 +414,17 @@ func (h *MemoryHandler) GetMemoryConfig(c *gin.Context) {
errMsg := err.Error()
// Check if it's a "not found" error
if strings.Contains(errMsg, "not found") {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, errMsg)
+ common.RespondError(c, common.CodeNotFound, errMsg)
return
}
// Other errors return server error
- common.ResponseWithCodeData(c, common.CodeServerError, nil, errMsg)
+ common.RespondError(c, common.CodeServerError, errMsg)
return
}
// Return success response
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetMemoryMessages handles GET request for getting Memory messages
@@ -449,19 +449,19 @@ func (h *MemoryHandler) GetMemoryConfig(c *gin.Context) {
func (h *MemoryHandler) GetMemoryMessages(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeAuthenticationError, nil, "user id is required")
+ common.RespondError(c, common.CodeAuthenticationError, "user id is required")
return
}
memoryID := strings.TrimSpace(c.Param("memory_id"))
if memoryID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "memory_id is required")
+ common.RespondError(c, common.CodeArgumentError, "memory_id is required")
return
}
@@ -470,16 +470,16 @@ func (h *MemoryHandler) GetMemoryMessages(c *gin.Context) {
keywords := strings.TrimSpace(c.DefaultQuery("keywords", ""))
page, err := strconv.Atoi(c.DefaultQuery("page", "1"))
if err != nil || page <= 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "page must be a positive integer")
+ common.RespondError(c, common.CodeArgumentError, "page must be a positive integer")
return
}
pageSize, err := strconv.Atoi(c.DefaultQuery("page_size", "50"))
if err != nil || pageSize <= 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "page_size must be a positive integer")
+ common.RespondError(c, common.CodeArgumentError, "page_size must be a positive integer")
return
}
if pageSize > 100 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "page_size must be less than or equal to 100")
+ common.RespondError(c, common.CodeArgumentError, "page_size must be less than or equal to 100")
return
}
@@ -489,14 +489,14 @@ func (h *MemoryHandler) GetMemoryMessages(c *gin.Context) {
return
}
if isMemoryServiceNotFound(err) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, err.Error())
+ common.RespondError(c, common.CodeNotFound, err.Error())
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Internal server error")
+ common.RespondError(c, common.CodeServerError, "Internal server error")
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
type messageMemoryIDs []string
@@ -545,23 +545,23 @@ type AddMessageRequest struct {
func (h *MemoryHandler) AddMessage(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
currentUserID := strings.TrimSpace(user.ID)
if currentUserID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "user_id is required")
+ common.RespondError(c, common.CodeArgumentError, "user_id is required")
return
}
var reqBody AddMessageRequest
if err := c.ShouldBindJSON(&reqBody); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "body arguments is required")
+ common.RespondError(c, common.CodeArgumentError, "body arguments is required")
return
}
if len(reqBody.MemoryIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "memory_id is required")
+ common.RespondError(c, common.CodeArgumentError, "memory_id is required")
return
}
@@ -570,8 +570,7 @@ func (h *MemoryHandler) AddMessage(c *gin.Context) {
if authViaAPIToken, ok := v.(bool); authViaAPIToken && ok {
effectiveUserID = strings.TrimSpace(reqBody.UserID)
if effectiveUserID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "user_id is required")
+ common.RespondError(c, common.CodeArgumentError, "user_id is required")
return
}
}
@@ -587,11 +586,11 @@ func (h *MemoryHandler) AddMessage(c *gin.Context) {
ok, message, err := h.memoryService.AddMessage(c.Request.Context(), currentUserID, []string(reqBody.MemoryIDs), msg)
if err != nil || !ok {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Some messages failed to add. Detail:"+message)
+ common.RespondError(c, common.CodeServerError, "Some messages failed to add. Detail:"+message)
return
}
- common.SuccessNoData(c, message)
+ common.RespondSuccess(c, nil, message)
}
// ForgetMessage handles DELETE request for forgetting messages.
@@ -607,13 +606,13 @@ func (h *MemoryHandler) AddMessage(c *gin.Context) {
func (h *MemoryHandler) ForgetMessage(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
memoryID, messageID, err := parseMemoryMessagePath(c.Param("memory_message"))
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
@@ -623,15 +622,15 @@ func (h *MemoryHandler) ForgetMessage(c *gin.Context) {
}
errMsg := err.Error()
if isMemoryServiceNotFound(err) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, errMsg)
+ common.RespondError(c, common.CodeNotFound, errMsg)
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Internal server error:"+errMsg)
+ common.RespondError(c, common.CodeServerError, "Internal server error:"+errMsg)
return
}
- common.SuccessNoData(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func isMemoryServiceNotFound(err error) bool {
@@ -679,31 +678,31 @@ func parseMemoryMessagePath(memoryMessage string) (string, int64, error) {
func (h *MemoryHandler) UpdateMessage(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeAuthenticationError, nil, "user id is required")
+ common.RespondError(c, common.CodeAuthenticationError, "user id is required")
return
}
memoryID, messageID, err := parseMemoryMessagePath(c.Param("memory_message"))
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
var req map[string]interface{}
if err = json.NewDecoder(c.Request.Body).Decode(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
status, ok := req["status"].(bool)
if !ok {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Status must be a boolean.")
+ common.RespondError(c, common.CodeArgumentError, "Status must be a boolean.")
return
}
@@ -713,14 +712,14 @@ func (h *MemoryHandler) UpdateMessage(c *gin.Context) {
return
}
if isMemoryServiceNotFound(err) {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, err.Error())
+ common.RespondError(c, common.CodeNotFound, err.Error())
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "Internal server error:"+err.Error())
+ common.RespondError(c, common.CodeServerError, "Internal server error:"+err.Error())
return
}
- common.SuccessNoData(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
// GetMessageContent handles GET request for getting message content
@@ -738,19 +737,19 @@ func (h *MemoryHandler) UpdateMessage(c *gin.Context) {
func (h *MemoryHandler) GetMessageContent(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeAuthenticationError, nil, "user id is required")
+ common.RespondError(c, common.CodeAuthenticationError, "user id is required")
return
}
memoryID, messageID, err := parseMemoryMessagePath(c.Param("memory_message"))
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
@@ -760,14 +759,14 @@ func (h *MemoryHandler) GetMessageContent(c *gin.Context) {
return
}
if _, ok := err.(*service.ResourceNotFoundError); ok {
- common.ResponseWithCodeData(c, common.CodeNotFound, nil, err.Error())
+ common.RespondError(c, common.CodeNotFound, err.Error())
return
}
- common.ResponseWithCodeData(c, common.CodeServerError, nil, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccess(c, data, "success")
}
// SearchMessage handles GET request for searching messages
@@ -790,13 +789,13 @@ func (h *MemoryHandler) GetMessageContent(c *gin.Context) {
func (h *MemoryHandler) SearchMessage(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeAuthenticationError, nil, "user id is required")
+ common.RespondError(c, common.CodeAuthenticationError, "user id is required")
return
}
@@ -806,17 +805,17 @@ func (h *MemoryHandler) SearchMessage(c *gin.Context) {
similarityThreshold, err := strconv.ParseFloat(c.DefaultQuery("similarity_threshold", "0.2"), 64)
if err != nil || math.IsNaN(similarityThreshold) || math.IsInf(similarityThreshold, 0) || similarityThreshold < 0 || similarityThreshold > 1 {
- common.ErrorWithCode(c, common.CodeArgumentError, "similarity_threshold must be a finite number between 0 and 1")
+ common.RespondError(c, common.CodeArgumentError, "similarity_threshold must be a finite number between 0 and 1")
return
}
keywordsSimilarityWeight, err := strconv.ParseFloat(c.DefaultQuery("keywords_similarity_weight", "0.7"), 64)
if err != nil || math.IsNaN(keywordsSimilarityWeight) || math.IsInf(keywordsSimilarityWeight, 0) || keywordsSimilarityWeight < 0 || keywordsSimilarityWeight > 1 {
- common.ErrorWithCode(c, common.CodeArgumentError, "keywords_similarity_weight must be a finite number between 0 and 1")
+ common.RespondError(c, common.CodeArgumentError, "keywords_similarity_weight must be a finite number between 0 and 1")
return
}
topN, _ := strconv.Atoi(c.DefaultQuery("top_n", "5"))
if topN <= 0 || topN > 100 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "top_n must be between 1 and 100")
+ common.RespondError(c, common.CodeArgumentError, "top_n must be between 1 and 100")
return
}
@@ -839,11 +838,11 @@ func (h *MemoryHandler) SearchMessage(c *gin.Context) {
res, code, err := h.memoryService.SearchMessage(c.Request.Context(), userID, filterDict, params)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, res, "success")
+ common.RespondSuccessList(c, res, "success")
}
// GetMessages handles GET request for getting message list
@@ -861,13 +860,13 @@ func (h *MemoryHandler) SearchMessage(c *gin.Context) {
func (h *MemoryHandler) GetMessages(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
userID := strings.TrimSpace(user.ID)
if userID == "" {
- common.ResponseWithCodeData(c, common.CodeAuthenticationError, nil, "user id is required")
+ common.RespondError(c, common.CodeAuthenticationError, "user id is required")
return
}
@@ -877,21 +876,21 @@ func (h *MemoryHandler) GetMessages(c *gin.Context) {
sessionID := c.DefaultQuery("session_id", "")
limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
if limit <= 0 || limit > 100 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "limit must be between 1 and 100")
+ common.RespondError(c, common.CodeArgumentError, "limit must be between 1 and 100")
return
}
if len(memoryIDs) == 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "memory_ids is required.")
+ common.RespondError(c, common.CodeArgumentError, "memory_ids is required.")
return
}
data, code, err := h.memoryService.GetMessages(c.Request.Context(), memoryIDs, userID, agentID, sessionID, limit)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, data, "success")
+ common.RespondSuccessList(c, data, "success")
}
// isArgumentError determines if an error message is an argument error
diff --git a/internal/handler/models.go b/internal/handler/models.go
index e47877d73b..84ab934256 100644
--- a/internal/handler/models.go
+++ b/internal/handler/models.go
@@ -55,37 +55,37 @@ func (h *ModelHandler) ListAllModels(c *gin.Context) {
// list tenant models
models, err := h.modelProviderService.ListAllModels(page, pageSize)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, models, "success")
+ common.RespondSuccessList(c, models, "success")
return
}
func (h *ModelHandler) ShowModel(c *gin.Context) {
encodedModelName := c.Param("model_name")
if encodedModelName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Encoded model name is empty")
+ common.RespondError(c, common.CodeBadRequest, "Encoded model name is empty")
return
}
decodedModelName, err := common.DecodeFromBase64(encodedModelName)
if err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if decodedModelName == "" {
- common.ErrorWithCode(c, common.CodeBadRequest, "Decoded model name is empty")
+ common.RespondError(c, common.CodeBadRequest, "Decoded model name is empty")
return
}
// Get model
model, err := h.modelProviderService.ShowModel(decodedModelName)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, model, "success")
+ common.RespondSuccess(c, model, "success")
}
diff --git a/internal/handler/openai_chat.go b/internal/handler/openai_chat.go
index a4aff9bc60..ccf7f74b35 100644
--- a/internal/handler/openai_chat.go
+++ b/internal/handler/openai_chat.go
@@ -46,32 +46,32 @@ func NewOpenAIChatHandler(svc *service.OpenAIChatService) *OpenAIChatHandler {
func (h *OpenAIChatHandler) OpenAIChatCompletions(c *gin.Context) {
chatID := c.Param("chat_id")
if chatID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "You don't own the chat "+chatID)
+ common.RespondError(c, common.CodeDataError, "You don't own the chat "+chatID)
return
}
user, code, msg := GetUser(c)
if code != common.CodeSuccess {
- common.ResponseWithCodeData(c, code, nil, msg)
+ common.RespondError(c, code, msg)
return
}
bodyBytes, err := io.ReadAll(c.Request.Body)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
// Parse body into the typed request
var req service.OpenAIChatRequest
if err := json.Unmarshal(bodyBytes, &req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
question, err := service.ResolveCompletionQuestion(req.Question, req.Query, req.Messages)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
if req.Question != "" || req.Query != "" {
@@ -80,14 +80,14 @@ func (h *OpenAIChatHandler) OpenAIChatCompletions(c *gin.Context) {
// Messages presence
if len(req.Messages) == 0 {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "You have to provide messages.")
+ common.RespondError(c, common.CodeDataError, "You have to provide messages.")
return
}
// extra_body shape validation
extraBody, extraBodyOK := req.ExtraBody.(map[string]interface{})
if req.ExtraBody != nil && !extraBodyOK {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "extra_body must be an object.")
+ common.RespondError(c, common.CodeArgumentError, "extra_body must be an object.")
return
}
@@ -96,14 +96,12 @@ func (h *OpenAIChatHandler) OpenAIChatCompletions(c *gin.Context) {
if rm, ok := extraBody["reference_metadata"].(map[string]interface{}); ok {
if rawFields, has := rm["fields"]; has {
if rawArr, ok := rawFields.([]interface{}); !ok {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "reference_metadata.fields must be an array.")
+ common.RespondError(c, common.CodeArgumentError, "reference_metadata.fields must be an array.")
return
} else {
for _, item := range rawArr {
if _, ok = item.(string); !ok {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "reference_metadata.fields must be an array.")
+ common.RespondError(c, common.CodeArgumentError, "reference_metadata.fields must be an array.")
return
}
}
@@ -116,8 +114,7 @@ func (h *OpenAIChatHandler) OpenAIChatCompletions(c *gin.Context) {
if extraBody != nil {
if mc, ok := extraBody["metadata_condition"]; ok && mc != nil {
if _, ok := mc.(map[string]interface{}); !ok {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "metadata_condition must be an object.")
+ common.RespondError(c, common.CodeArgumentError, "metadata_condition must be an object.")
return
}
}
@@ -126,7 +123,7 @@ func (h *OpenAIChatHandler) OpenAIChatCompletions(c *gin.Context) {
// Last message must be from the user
if last := req.Messages[len(req.Messages)-1]; last != nil {
if role, _ := last["role"].(string); role != "user" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "The last content of this conversation is not from user.")
+ common.RespondError(c, common.CodeDataError, "The last content of this conversation is not from user.")
return
}
}
diff --git a/internal/handler/pipeline.go b/internal/handler/pipeline.go
index 9200713231..98e3aeb2b8 100644
--- a/internal/handler/pipeline.go
+++ b/internal/handler/pipeline.go
@@ -62,7 +62,7 @@ func NewPipelineHandler() *PipelineHandler {
// templates themselves are static data with no tenant scoping.
func (h *PipelineHandler) ListPipelines(c *gin.Context) {
if h == nil || h.registry == nil {
- common.SuccessWithData(c, &pipelinepkg.BuiltinPipelineListResponse{
+ common.RespondSuccess(c, &pipelinepkg.BuiltinPipelineListResponse{
BuiltinPipelines: []*pipelinepkg.BuiltinPipelineMeta{},
Total: 0,
}, "success")
@@ -74,7 +74,7 @@ func (h *PipelineHandler) ListPipelines(c *gin.Context) {
// When type is empty or "builtin", return the builtin catalog.
_ = pipelineType
- common.SuccessWithData(c, h.registry.List(), "success")
+ common.RespondSuccess(c, h.registry.List(), "success")
}
// GetPipeline GET /api/v1/pipelines/:id
@@ -83,16 +83,16 @@ func (h *PipelineHandler) ListPipelines(c *gin.Context) {
// templates are static data with no tenant scoping.
func (h *PipelineHandler) GetPipeline(c *gin.Context) {
if h == nil || h.registry == nil {
- common.ErrorWithCode(c, common.CodeDataError, "pipeline not found")
+ common.RespondError(c, common.CodeDataError, "pipeline not found")
return
}
id := c.Param("id")
tpl, ok := h.registry.Get(id)
if !ok || tpl == nil {
- common.ErrorWithCode(c, common.CodeDataError, "pipeline not found")
+ common.RespondError(c, common.CodeDataError, "pipeline not found")
return
}
- common.SuccessWithData(c, map[string]any{"dsl": tpl.DSL}, "success")
+ common.RespondSuccess(c, map[string]any{"dsl": tpl.DSL}, "success")
}
diff --git a/internal/handler/plugin.go b/internal/handler/plugin.go
index 9c8543c2aa..f3bce3d97b 100644
--- a/internal/handler/plugin.go
+++ b/internal/handler/plugin.go
@@ -47,9 +47,9 @@ func NewPluginHandler(pluginService *service.PluginService) *PluginHandler {
// @Router /v1/plugin/tools [get]
func (h *PluginHandler) ListLLMTools(c *gin.Context) {
if _, errorCode, errorMessage := GetUser(c); errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
- common.SuccessWithData(c, h.pluginService.ListLLMTools(), "success")
+ common.RespondSuccessList(c, h.pluginService.ListLLMTools(), "success")
}
diff --git a/internal/handler/providers.go b/internal/handler/providers.go
index f5147a0135..bb8627a68a 100644
--- a/internal/handler/providers.go
+++ b/internal/handler/providers.go
@@ -85,7 +85,7 @@ func (h *ProviderHandler) ListProviders(c *gin.Context) {
// list pool providers
providers, err := dao.GetModelProviderManager().ListProviders()
if err != nil {
- common.ErrorWithCode(c, common.CodeNotFound, err.Error())
+ common.RespondError(c, common.CodeNotFound, err.Error())
return
}
@@ -95,7 +95,7 @@ func (h *ProviderHandler) ListProviders(c *gin.Context) {
delete(provider, "tags")
}
- common.SuccessWithData(c, providers, "success")
+ common.RespondSuccessList(c, providers, "success")
return
}
@@ -105,11 +105,11 @@ func (h *ProviderHandler) ListProviders(c *gin.Context) {
// list tenant providers
providers, errorCode, err := h.modelProviderService.ListProvidersOfTenant(ctx, userID)
if err != nil {
- common.ResponseWithCodeData(c, errorCode, nil, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, providers, "success")
+ common.RespondSuccessList(c, providers, "success")
return
}
@@ -121,7 +121,7 @@ func (h *ProviderHandler) AddProvider(c *gin.Context) {
var req AddProviderRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, false, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -130,17 +130,17 @@ func (h *ProviderHandler) AddProvider(c *gin.Context) {
errorCode, err := h.modelProviderService.AddModelProvider(ctx, req.ProviderName, userID)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *ProviderHandler) DeleteProvider(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
@@ -149,32 +149,32 @@ func (h *ProviderHandler) DeleteProvider(c *gin.Context) {
errorCode, err := h.modelProviderService.DeleteModelProvider(ctx, userID, providerName)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *ProviderHandler) ShowProvider(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
provider, err := dao.GetModelProviderManager().GetProviderByName(providerName)
if err != nil {
- common.ErrorWithCode(c, common.CodeNotFound, err.Error())
+ common.RespondError(c, common.CodeNotFound, err.Error())
return
}
- common.SuccessWithData(c, provider, "success")
+ common.RespondSuccess(c, provider, "success")
}
func (h *ProviderHandler) ListModels(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
@@ -185,7 +185,7 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
instanceName := strings.TrimSpace(c.Query("instance_name"))
if strings.EqualFold(c.Query("use_saved_credentials"), "true") {
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Saved credentials require an instance name")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Saved credentials require an instance name")
return
}
var baseURLOverride, regionOverride *string
@@ -202,10 +202,10 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
Region: regionOverride,
})
if err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, instanceModels, "success")
+ common.RespondSuccessList(c, instanceModels, "success")
return
}
_, baseURLProvided := c.GetQuery("base_url")
@@ -213,11 +213,11 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
if instanceName != "" && !apiKeyProvided && !baseURLProvided && !regionProvided {
instanceModels, err := h.fetchSavedProviderModels(c.Request.Context(), providerName, instanceName, c.GetString("user_id"), service.SavedProviderModelOptions{})
if err == nil {
- common.SuccessWithData(c, instanceModels, "success")
+ common.RespondSuccessList(c, instanceModels, "success")
return
}
if apiKey == "" && baseURL == "" && region == "" {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
}
@@ -226,13 +226,13 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
if err != nil {
var codedErr *common.CodedError
if errors.As(err, &codedErr) {
- common.ErrorWithCode(c, codedErr.Code, codedErr.Message)
+ common.RespondError(c, codedErr.Code, codedErr.Message)
} else {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
}
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccessList(c, result, "success")
}
func (h *ProviderHandler) fetchSavedProviderModels(ctx context.Context, providerName, instanceName, userID string, options service.SavedProviderModelOptions) ([]map[string]interface{}, error) {
@@ -479,39 +479,39 @@ func providerModelMapTypes(model map[string]interface{}) []string {
func (h *ProviderHandler) ShowModel(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
modelName := c.Param("model_name")
if modelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model name is required")
return
}
model, err := dao.GetModelProviderManager().GetModelByName(providerName, modelName)
if err != nil {
- common.ErrorWithCode(c, common.CodeNotFound, err.Error())
+ common.RespondError(c, common.CodeNotFound, err.Error())
return
}
- common.SuccessWithData(c, model, "success")
+ common.RespondSuccess(c, model, "success")
}
func (h *ProviderHandler) CreateProviderInstance(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
ctx := c.Request.Context()
var req service.CreateProviderInstanceRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if err := service.ValidateProviderInstanceName(req.InstanceName); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -524,26 +524,26 @@ func (h *ProviderHandler) CreateProviderInstance(c *gin.Context) {
if apiKey == "" && req.BaseURL == "" && req.Region == "" && len(req.ModelInfo) == 0 {
code, err := h.modelProviderService.CreateNameOnlyProviderInstance(ctx, providerName, req.InstanceName, userID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
return
}
code, err := h.modelProviderService.CreateProviderInstance(ctx, providerName, req.InstanceName, apiKey, req.BaseURL, req.Region, userID, req.ModelInfo)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *ProviderHandler) ListProviderInstances(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
@@ -552,23 +552,23 @@ func (h *ProviderHandler) ListProviderInstances(c *gin.Context) {
instances, errorCode, err := h.modelProviderService.ListProviderInstances(ctx, providerName, userID)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, instances, "success")
+ common.RespondSuccessList(c, instances, "success")
}
func (h *ProviderHandler) ShowProviderInstance(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceIDOrName := c.Param("instance_id_or_name")
if instanceIDOrName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
@@ -577,23 +577,23 @@ func (h *ProviderHandler) ShowProviderInstance(c *gin.Context) {
instance, errorCode, err := h.modelProviderService.ShowProviderInstance(ctx, providerName, instanceIDOrName, userID)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, instance, "success")
+ common.RespondSuccess(c, instance, "success")
}
func (h *ProviderHandler) ShowInstanceBalance(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceName := c.Param("instance_id_or_name")
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
@@ -603,55 +603,55 @@ func (h *ProviderHandler) ShowInstanceBalance(c *gin.Context) {
// Get tenant ID from user
balance, errorCode, err := h.modelProviderService.ShowInstanceBalance(ctx, providerName, instanceName, userID)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, balance, "success")
+ common.RespondSuccess(c, balance, "success")
}
func (h *ProviderHandler) CheckConnection(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
ctx := c.Request.Context()
var req service.CheckConnectionRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, 400, nil, err.Error())
return
}
userID := c.GetString("user_id")
errCode, err := h.modelProviderService.CheckConnection(ctx, providerName, req, userID)
if err != nil {
- common.ErrorWithCode(c, errCode, err.Error())
+ common.RespondError(c, errCode, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *ProviderHandler) CheckInstanceConnection(c *gin.Context) {
ctx := c.Request.Context()
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceName := c.Param("instance_id_or_name")
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
userID := c.GetString("user_id")
instanceInfo, code, err := h.modelProviderService.ShowProviderInstance(ctx, providerName, instanceName, userID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
@@ -662,24 +662,24 @@ func (h *ProviderHandler) CheckInstanceConnection(c *gin.Context) {
InstanceID: instanceID,
}, userID)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *ProviderHandler) ListTasks(c *gin.Context) {
ctx := c.Request.Context()
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceName := c.Param("instance_id_or_name")
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
@@ -688,30 +688,30 @@ func (h *ProviderHandler) ListTasks(c *gin.Context) {
// Get tenant ID from user
listTaskResponse, errorCode, err := h.modelProviderService.ListTasks(ctx, providerName, instanceName, userID)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, listTaskResponse, "success")
+ common.RespondSuccessList(c, listTaskResponse, "success")
}
func (h *ProviderHandler) ShowTask(c *gin.Context) {
ctx := c.Request.Context()
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceName := c.Param("instance_id_or_name")
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
taskID := c.Param("task_id")
if taskID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Task ID is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Task ID is required")
return
}
@@ -720,57 +720,57 @@ func (h *ProviderHandler) ShowTask(c *gin.Context) {
// Get tenant ID from user
taskResponse, errorCode, err := h.modelProviderService.ShowTask(ctx, providerName, instanceName, taskID, userID)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, taskResponse, "success")
+ common.RespondSuccess(c, taskResponse, "success")
}
func (h *ProviderHandler) AlterProviderInstance(c *gin.Context) {
ctx := c.Request.Context()
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceName := c.Param("instance_id_or_name")
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
var req service.AlterProviderInstanceRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
return
}
userID := c.GetString("user_id")
if userID == "" {
- common.ErrorWithCode(c, common.CodeUnauthorized, "Unauthorized")
+ common.RespondError(c, common.CodeUnauthorized, "Unauthorized")
return
}
code, err := h.modelProviderService.AlterProviderInstance(ctx, userID, providerName, instanceName, req.InstanceName, req.APIKey, req.ClearAPIKey, req.BaseURL, req.Region, *req.ModelInfo)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *ProviderHandler) DropProviderInstance(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
var req service.DropProviderInstanceRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -779,23 +779,23 @@ func (h *ProviderHandler) DropProviderInstance(c *gin.Context) {
code, err := h.modelProviderService.DropProviderInstances(ctx, providerName, userID, req.Instances)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func (h *ProviderHandler) ListInstanceModels(c *gin.Context) {
ctx := c.Request.Context()
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceName := c.Param("instance_id_or_name")
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
@@ -811,38 +811,38 @@ func (h *ProviderHandler) ListInstanceModels(c *gin.Context) {
modelList, err := h.fetchSavedProviderModels(ctx, providerName, instanceName, c.GetString("user_id"), service.SavedProviderModelOptions{})
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, modelList, "success")
+ common.RespondSuccessList(c, modelList, "success")
return
}
modelInstances, err := h.modelProviderService.ListInstanceModels(ctx, providerName, instanceName, c.GetString("user_id"))
if err != nil {
- common.ErrorWithCode(c, common.CodeNotFound, err.Error())
+ common.RespondError(c, common.CodeNotFound, err.Error())
return
}
- common.SuccessWithData(c, modelInstances, "success")
+ common.RespondSuccessList(c, modelInstances, "success")
}
func (h *ProviderHandler) AlterModel(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceName := c.Param("instance_id_or_name")
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
var req service.AlterModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
@@ -852,13 +852,13 @@ func (h *ProviderHandler) AlterModel(c *gin.Context) {
modelID := strings.TrimSpace(req.ModelID)
if modelName == "" && modelID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "model_name or model_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "model_name or model_id is required")
return
}
status := strings.TrimSpace(req.Status)
if status != "" && status != "active" && status != "inactive" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "status must be 'active' or 'inactive'")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "status must be 'active' or 'inactive'")
return
}
@@ -877,18 +877,18 @@ func (h *ProviderHandler) AlterModel(c *gin.Context) {
}
if len(updateDict) == 0 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "at least one update field is required besides model_name or model_id")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "at least one update field is required besides model_name or model_id")
return
}
ctx := c.Request.Context()
code, err := h.modelProviderService.AlterModel(ctx, providerName, instanceName, modelName, userID, modelID, updateDict)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
func prepareProviderInstance(providerName, instanceName, reqProviderName, reqInstanceName string) error {
@@ -915,7 +915,7 @@ func (h *ProviderHandler) AddModel(c *gin.Context) {
var req service.AddModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, err.Error())
return
}
@@ -923,12 +923,12 @@ func (h *ProviderHandler) AddModel(c *gin.Context) {
req.InstanceName = c.Param("instance_id_or_name")
if req.ProviderName == "" || req.InstanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "provider_name and instance_name are required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "provider_name and instance_name are required")
return
}
if req.ModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "model_name is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "model_name is required")
return
}
@@ -937,32 +937,32 @@ func (h *ProviderHandler) AddModel(c *gin.Context) {
code, err := h.modelProviderService.AddModel(ctx, &req, userID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.ErrorWithCode(c, code, "success")
+ common.RespondError(c, code, "success")
}
func (h *ProviderHandler) DropInstanceModels(c *gin.Context) {
providerName := c.Param("provider_id_or_name")
if providerName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
instanceName := c.Param("instance_id_or_name")
if instanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
var req service.DropInstanceModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if len(req.ModelNames) == 0 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "model_name is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "model_name is required")
return
}
@@ -971,11 +971,11 @@ func (h *ProviderHandler) DropInstanceModels(c *gin.Context) {
code, err := h.modelProviderService.DropInstanceModels(ctx, providerName, instanceName, userID, req.ModelNames)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithMessage(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
type ChatToModelRequest struct {
@@ -997,13 +997,13 @@ func (h *ProviderHandler) ChatToModel(c *gin.Context) {
var req ChatToModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
question, err := service.ResolveCompletionQuestion(req.Question, req.Query, req.Messages)
if err != nil {
- common.ErrorWithCode(c, common.CodeArgumentError, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
if req.Question != "" || req.Query != "" {
@@ -1014,22 +1014,22 @@ func (h *ProviderHandler) ChatToModel(c *gin.Context) {
}
if req.ModelID == nil {
if req.ProviderName == nil || *req.ProviderName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
if req.InstanceName == nil || *req.InstanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
if req.ModelName == nil || *req.ModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model name is required")
return
}
} else {
if *req.ModelID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
return
}
}
@@ -1147,7 +1147,7 @@ func (h *ProviderHandler) ChatToModel(c *gin.Context) {
)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
@@ -1173,28 +1173,28 @@ func (h *ProviderHandler) EmbedText(c *gin.Context) {
var req EmbedTextRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if req.ModelID == nil {
if req.ProviderName == nil || *req.ProviderName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
if req.InstanceName == nil || *req.InstanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
if req.ModelName == nil || *req.ModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model name is required")
return
}
} else {
if *req.ModelID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
return
}
}
@@ -1217,11 +1217,11 @@ func (h *ProviderHandler) EmbedText(c *gin.Context) {
response, errorCode, err = h.modelCallService.EmbedText(ctx, modelRef, req.Texts, &embeddingConfig)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, response, "success")
+ common.RespondSuccessList(c, response, "success")
}
type RerankDocumentRequest struct {
@@ -1239,28 +1239,28 @@ func (h *ProviderHandler) RerankDocument(c *gin.Context) {
var req RerankDocumentRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if req.ModelID == nil {
if req.ProviderName == nil || *req.ProviderName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
if req.InstanceName == nil || *req.InstanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
if req.ModelName == nil || *req.ModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model name is required")
return
}
} else {
if *req.ModelID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
return
}
}
@@ -1283,10 +1283,10 @@ func (h *ProviderHandler) RerankDocument(c *gin.Context) {
response, errorCode, err = h.modelCallService.RerankDocument(ctx, modelRef, req.Query, req.Documents, &rerankConfig)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, response.Data, "success")
+ common.RespondSuccessList(c, response.Data, "success")
}
type TranscribeAudioRequest struct {
@@ -1306,28 +1306,28 @@ func (h *ProviderHandler) TranscribeAudio(c *gin.Context) {
var req TranscribeAudioRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if req.ModelID == nil {
if req.ProviderName == nil || *req.ProviderName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
if req.InstanceName == nil || *req.InstanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
if req.ModelName == nil || *req.ModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model name is required")
return
}
} else {
if *req.ModelID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
return
}
}
@@ -1392,11 +1392,11 @@ func (h *ProviderHandler) TranscribeAudio(c *gin.Context) {
response, errorCode, err = h.modelCallService.TranscribeAudio(ctx, modelRef, req.File, &asrConfig)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, response, "success")
+ common.RespondSuccess(c, response, "success")
}
type AudioSpeechRequest struct {
@@ -1414,28 +1414,28 @@ func (h *ProviderHandler) AudioSpeech(c *gin.Context) {
var req AudioSpeechRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if req.ModelID == nil {
if req.ProviderName == nil || *req.ProviderName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
if req.InstanceName == nil || *req.InstanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
if req.ModelName == nil || *req.ModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model name is required")
return
}
} else {
if *req.ModelID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
return
}
}
@@ -1500,11 +1500,11 @@ func (h *ProviderHandler) AudioSpeech(c *gin.Context) {
response, errorCode, err = h.modelCallService.AudioSpeech(ctx, modelRef, req.Text, &ttsConfig)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, response, "success")
+ common.RespondSuccess(c, response, "success")
}
type OCRFileRequest struct {
@@ -1521,28 +1521,28 @@ func (h *ProviderHandler) OCRFile(c *gin.Context) {
var req OCRFileRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if req.ModelID == nil {
if req.ProviderName == nil || *req.ProviderName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
if req.InstanceName == nil || *req.InstanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
if req.ModelName == nil || *req.ModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model name is required")
return
}
} else {
if *req.ModelID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
return
}
}
@@ -1563,11 +1563,11 @@ func (h *ProviderHandler) OCRFile(c *gin.Context) {
response, errorCode, err = h.modelCallService.OCRFile(ctx, modelRef, req.Content, req.URL, &OCRConfig)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, response, "success")
+ common.RespondSuccess(c, response, "success")
}
type ParseFileRequest struct {
@@ -1587,28 +1587,28 @@ func (h *ProviderHandler) ParseFile(c *gin.Context) {
var req ParseFileRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
- common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
if req.ModelID == nil {
if req.ProviderName == nil || *req.ProviderName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Provider name is required")
return
}
if req.InstanceName == nil || *req.InstanceName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Instance name is required")
return
}
if req.ModelName == nil || *req.ModelName == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model name is required")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model name is required")
return
}
} else {
if *req.ModelID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
+ common.Respond(c, http.StatusBadRequest, 400, nil, "Model ID is empty")
return
}
}
@@ -1635,11 +1635,11 @@ func (h *ProviderHandler) ParseFile(c *gin.Context) {
response, errorCode, err = h.modelCallService.ParseFile(ctx, modelRef, req.Content, req.URL, &parseFileConfig)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
- common.SuccessWithData(c, response, "success")
+ common.RespondSuccess(c, response, "success")
}
// ListModelsForUserInTenant handles GET /api/v1/models for the authenticated
@@ -1647,7 +1647,7 @@ func (h *ProviderHandler) ParseFile(c *gin.Context) {
func (h *ProviderHandler) ListModelsForUserInTenant(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -1657,9 +1657,9 @@ func (h *ProviderHandler) ListModelsForUserInTenant(c *gin.Context) {
models, code, err := h.modelProviderService.ListModelsForUserInTenant(ctx, user.ID, tenantID, modelType)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, models, "success")
+ common.RespondSuccessList(c, models, "success")
}
diff --git a/internal/handler/search.go b/internal/handler/search.go
index 0b976c266b..aee46669f8 100644
--- a/internal/handler/search.go
+++ b/internal/handler/search.go
@@ -87,7 +87,7 @@ func getOwnerIDs(c *gin.Context) []string {
func (h *SearchHandler) ListSearches(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -123,7 +123,7 @@ func (h *SearchHandler) ListSearches(c *gin.Context) {
var req service.ListSearchAppsRequest
if len(ownerIDs) == 0 && c.Request.ContentLength > 0 {
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, 400, nil, err.Error())
return
}
ownerIDs = req.OwnerIDs
@@ -136,11 +136,11 @@ func (h *SearchHandler) ListSearches(c *gin.Context) {
if respondPermissionErrorIf(c, err, false) {
return
}
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, 500, nil, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// CreateSearch create a new search app
@@ -161,7 +161,7 @@ type CreateSearchRequest struct {
func (h *SearchHandler) CreateSearch(c *gin.Context) {
user, errorCode, err := billingQuotaUser(c)
if err != nil {
- common.ErrorWithCode(c, errorCode, err.Error())
+ common.RespondError(c, errorCode, err.Error())
return
}
if !billingEnforceApps(c, user.ID) {
@@ -171,19 +171,19 @@ func (h *SearchHandler) CreateSearch(c *gin.Context) {
// Get current user from context (same as Python current_user)
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
// Parse request body (same as Python get_request_json())
var req CreateSearchRequest
if err = c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
if err = common.ValidateName(req.Name); err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -191,12 +191,12 @@ func (h *SearchHandler) CreateSearch(c *gin.Context) {
ctx := c.Request.Context()
result, err := h.searchService.CreateSearch(ctx, req.Name, req.Description)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeBadRequest, nil, err.Error())
+ common.Respond(c, http.StatusInternalServerError, common.CodeBadRequest, nil, err.Error())
return
}
// Return success response (same as Python get_json_result(data={"search_id": req["id"]}))
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetSearch get search app detail
@@ -212,14 +212,14 @@ func (h *SearchHandler) GetSearch(c *gin.Context) {
// Get current user from context (same as Python current_user)
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
// Get search_id from path parameter (same as Python <search_id>)
searchID := c.Param("search_id")
if searchID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "search_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "search_id is required")
return
}
@@ -231,7 +231,7 @@ func (h *SearchHandler) GetSearch(c *gin.Context) {
return
}
// Not found error
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -252,7 +252,7 @@ func (h *SearchHandler) GetSearch(c *gin.Context) {
}
// Return success response
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// DeleteSearch delete a search app
@@ -268,14 +268,14 @@ func (h *SearchHandler) DeleteSearch(c *gin.Context) {
// Get current user from context (same as Python current_user)
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
// Get search_id from path parameter (same as Python <search_id>)
searchID := c.Param("search_id")
if searchID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "search_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "search_id is required")
return
}
@@ -287,12 +287,11 @@ func (h *SearchHandler) DeleteSearch(c *gin.Context) {
return
}
// Delete failed error
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- // Return success response (same as Python get_json_result(data=True))
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// UpdateSearch update a search app
@@ -309,27 +308,27 @@ func (h *SearchHandler) UpdateSearch(c *gin.Context) {
// Get current user from context (same as Python current_user)
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
// Get search_id from path parameter (same as Python <search_id>)
searchID := c.Param("search_id")
if searchID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "search_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "search_id is required")
return
}
// Parse request body
var req service.UpdateSearchRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
// Validate name (same as Python validation)
if err := common.ValidateName(req.Name); err != nil {
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -343,13 +342,13 @@ func (h *SearchHandler) UpdateSearch(c *gin.Context) {
errMsg := err.Error()
switch errMsg {
case "duplicated search name":
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "Duplicated search name.")
+ common.RespondError(c, common.CodeDataError, "Duplicated search name.")
default:
// Check if it's a "cannot find search" error
if len(errMsg) > 18 && errMsg[:18] == "cannot find search" {
- common.ResponseWithCodeData(c, common.CodeDataError, false, errMsg)
+ common.RespondError(c, common.CodeDataError, errMsg)
} else {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, errMsg)
+ common.RespondError(c, common.CodeDataError, errMsg)
}
}
return
@@ -373,20 +372,19 @@ func (h *SearchHandler) UpdateSearch(c *gin.Context) {
}
// Return success response
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
func (h *SearchHandler) Completion(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.SearchCompletionsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil,
- "question is required")
+ common.RespondError(c, common.CodeArgumentError, "question is required")
return
}
@@ -404,11 +402,11 @@ func (h *SearchHandler) Completion(c *gin.Context) {
jsonInternalError(c, err)
return
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
if plan == nil {
- common.ResponseWithCodeData(c, common.CodeServerError, nil, "completion plan is nil")
+ common.RespondError(c, common.CodeServerError, "completion plan is nil")
return
}
diff --git a/internal/handler/searchbot.go b/internal/handler/searchbot.go
index 266f9a878e..8b0b8d979b 100644
--- a/internal/handler/searchbot.go
+++ b/internal/handler/searchbot.go
@@ -133,18 +133,18 @@ func (h *SearchBotHandler) Handle(c *gin.Context) {
ctx := c.Request.Context()
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req SearchBotRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, err.Error())
+ common.RespondError(c, common.CodeArgumentError, err.Error())
return
}
if req.Question == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "question is required")
+ common.RespondError(c, common.CodeArgumentError, "question is required")
return
}
@@ -154,11 +154,11 @@ func (h *SearchBotHandler) Handle(c *gin.Context) {
return
}
common.Warn("searchbot related questions failed", zap.String("error", err.Error()))
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
+ common.RespondError(c, common.CodeOperatingError, err.Error())
return
}
- common.SuccessWithData(c, questions, "success")
+ common.RespondSuccessList(c, questions, "success")
}
// RetrievalTest performs a retrieval test against specified knowledge bases.
@@ -171,13 +171,13 @@ func (h *SearchBotHandler) Handle(c *gin.Context) {
func (h *SearchBotHandler) RetrievalTest(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, errorCode, nil, errorMessage)
+ common.Respond(c, http.StatusUnauthorized, errorCode, nil, errorMessage)
return
}
var req SearchBotRetrievalTestRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
@@ -191,13 +191,13 @@ func (h *SearchBotHandler) RetrievalTest(c *gin.Context) {
req.KbIDs = filtered
if len(req.KbIDs) == 0 || req.Question == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_id and question are required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_id and question are required")
return
}
vectorSimilarityWeight, err := service.ResolveVectorSimilarityWeight(req.KeywordsSimilarityWeight, req.VectorSimilarityWeight)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
req.VectorSimilarityWeight = vectorSimilarityWeight
@@ -205,7 +205,7 @@ func (h *SearchBotHandler) RetrievalTest(c *gin.Context) {
applyRetrievalDefaults(&req)
if req.TopK != nil && *req.TopK <= 0 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "top_k must be greater than 0")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "top_k must be greater than 0")
return
}
@@ -217,11 +217,11 @@ func (h *SearchBotHandler) RetrievalTest(c *gin.Context) {
return
}
common.Warn("search bot retrieval test failed", zap.String("error", err.Error()))
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// Ask performs a retrieval-augmented Q&A with streaming SSE response.
@@ -236,19 +236,19 @@ func (h *SearchBotHandler) RetrievalTest(c *gin.Context) {
func (h *SearchBotHandler) Ask(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req SearchBotAskRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
question, err := service.ResolveCompletionQuestion(req.Question, req.Query, req.Messages)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
req.Question = question
@@ -262,7 +262,7 @@ func (h *SearchBotHandler) Ask(c *gin.Context) {
filtered = append(filtered, id)
}
if len(filtered) == 0 || strings.TrimSpace(req.Question) == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_ids and question are required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_ids and question are required")
return
}
@@ -288,7 +288,7 @@ func (h *SearchBotHandler) Ask(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ErrorWithCode(c, common.CodeDataError, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
searchConfig := searchConfigFromDetail(detail)
@@ -362,13 +362,13 @@ func (h *SearchBotHandler) Ask(c *gin.Context) {
func (h *SearchBotHandler) MindMap(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req SearchBotMindMapRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, err.Error())
return
}
@@ -379,7 +379,7 @@ func (h *SearchBotHandler) MindMap(c *gin.Context) {
}
}
if len(filtered) == 0 || strings.TrimSpace(req.Question) == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_ids and question are required")
+ common.Respond(c, http.StatusBadRequest, common.CodeArgumentError, nil, "kb_ids and question are required")
return
}
if h.chunkSvc == nil {
@@ -424,10 +424,10 @@ func (h *SearchBotHandler) MindMap(c *gin.Context) {
return
}
common.Warn("searchbot mindmap failed", zap.String("error", err.Error()))
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
+ common.RespondError(c, common.CodeOperatingError, err.Error())
return
}
- common.SuccessWithData(c, mindMap, "success")
+ common.RespondSuccess(c, mindMap, "success")
}
// SearchBotDetail returns the public share-page bootstrap payload for a
@@ -437,14 +437,14 @@ func (h *SearchBotHandler) SearchBotDetail(c *gin.Context) {
ctx := c.Request.Context()
searchID := strings.TrimSpace(c.Query("search_id"))
if searchID == "" {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "search_id is required")
+ common.RespondError(c, common.CodeArgumentError, "search_id is required")
return
}
userSvc := service.NewUserService()
identity, code, err := userSvc.ResolveBetaAPIToken(ctx, c.GetHeader("Authorization"))
if err != nil {
- common.ResponseWithCodeData(c, code, nil, "Authentication error: API key is invalid!")
+ common.RespondError(c, code, "Authentication error: API key is invalid!")
return
}
setAuthIdentity(c, identity)
@@ -463,7 +463,7 @@ func (h *SearchBotHandler) SearchBotDetail(c *gin.Context) {
return
}
- common.SuccessWithData(c, detail, "success")
+ common.RespondSuccess(c, detail, "success")
}
// ---- SSE helpers ----
diff --git a/internal/handler/skill_search.go b/internal/handler/skill_search.go
index bdb1e78107..7a578a7ff6 100644
--- a/internal/handler/skill_search.go
+++ b/internal/handler/skill_search.go
@@ -59,7 +59,7 @@ func NewSkillSearchHandler(docEngine engine.DocEngine, spaceRemover file.DocRemo
func (h *SkillSearchHandler) GetConfig(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -69,11 +69,11 @@ func (h *SkillSearchHandler) GetConfig(c *gin.Context) {
ctx := c.Request.Context()
result, code, err := h.searchService.GetConfig(ctx, user.ID, spaceID, embdID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// UpdateConfig handles the update skill search config request
@@ -87,24 +87,24 @@ func (h *SkillSearchHandler) GetConfig(c *gin.Context) {
func (h *SkillSearchHandler) UpdateConfig(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.UpdateConfigRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
ctx := c.Request.Context()
result, code, err := h.searchService.UpdateConfig(ctx, user.ID, &req)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// Search handles the skill search request
@@ -118,23 +118,23 @@ func (h *SkillSearchHandler) UpdateConfig(c *gin.Context) {
func (h *SkillSearchHandler) Search(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req service.SearchRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
result, code, err := h.searchService.Search(c.Request.Context(), user.ID, &req, h.docEngine)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// IndexSkillsRequest represents the request to index skills
@@ -155,13 +155,13 @@ type IndexSkillsRequest struct {
func (h *SkillSearchHandler) IndexSkills(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req IndexSkillsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -171,12 +171,12 @@ func (h *SkillSearchHandler) IndexSkills(c *gin.Context) {
ctx := c.Request.Context()
config, code, err := h.searchService.GetConfig(ctx, user.ID, req.SpaceID, "")
if err != nil {
- common.ResponseWithCodeData(c, code, nil, "failed to get skill search config: "+err.Error())
+ common.RespondError(c, code, "failed to get skill search config: "+err.Error())
return
}
val, ok := config["embd_id"].(string)
if !ok || val == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "no embedding model configured in skill search config")
+ common.RespondError(c, common.CodeDataError, "no embedding model configured in skill search config")
return
}
embdID = val
@@ -194,7 +194,7 @@ func (h *SkillSearchHandler) IndexSkills(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
+ common.RespondError(c, common.CodeOperatingError, err.Error())
return
}
}
@@ -204,7 +204,7 @@ func (h *SkillSearchHandler) IndexSkills(c *gin.Context) {
return
}
common.Error(fmt.Sprintf("Failed to batch index skills: tenantID=%s, spaceID=%s, error=%v", user.ID, req.SpaceID, err), err)
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
+ common.RespondError(c, common.CodeOperatingError, err.Error())
return
}
@@ -213,7 +213,7 @@ func (h *SkillSearchHandler) IndexSkills(c *gin.Context) {
zap.String("spaceID", req.SpaceID),
zap.Int("indexedCount", len(req.Skills)))
- common.SuccessWithData(c, gin.H{
+ common.RespondSuccess(c, gin.H{
"indexed_count": len(req.Skills),
}, "success")
}
@@ -235,13 +235,13 @@ type ReindexRequest struct {
func (h *SkillSearchHandler) Reindex(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req ReindexRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -251,12 +251,12 @@ func (h *SkillSearchHandler) Reindex(c *gin.Context) {
ctx := c.Request.Context()
config, code, err := h.searchService.GetConfig(ctx, user.ID, req.SpaceID, "")
if err != nil {
- common.ResponseWithCodeData(c, code, nil, "failed to get skill search config: "+err.Error())
+ common.RespondError(c, code, "failed to get skill search config: "+err.Error())
return
}
val, ok := config["embd_id"].(string)
if !ok || val == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "no embedding model configured in skill search config")
+ common.RespondError(c, common.CodeDataError, "no embedding model configured in skill search config")
return
}
embdID = val
@@ -267,11 +267,11 @@ func (h *SkillSearchHandler) Reindex(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
+ common.RespondError(c, common.CodeOperatingError, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// DeleteSkillIndex handles the delete skill index request
@@ -288,14 +288,14 @@ func (h *SkillSearchHandler) Reindex(c *gin.Context) {
func (h *SkillSearchHandler) DeleteSkillIndex(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
skillID := c.Query("skill_id")
spaceID := c.Query("space_id")
if skillID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "skill_id is required")
+ common.RespondError(c, common.CodeDataError, "skill_id is required")
return
}
@@ -304,11 +304,11 @@ func (h *SkillSearchHandler) DeleteSkillIndex(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, "failed to delete skill index")
+ common.RespondError(c, common.CodeOperatingError, "failed to delete skill index")
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// InitializeIndex handles the initialize skill search index request
@@ -325,14 +325,14 @@ func (h *SkillSearchHandler) DeleteSkillIndex(c *gin.Context) {
func (h *SkillSearchHandler) InitializeIndex(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
embdID := c.Query("embd_id")
spaceID := c.Query("space_id")
if embdID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "embd_id is required")
+ common.RespondError(c, common.CodeDataError, "embd_id is required")
return
}
@@ -340,11 +340,11 @@ func (h *SkillSearchHandler) InitializeIndex(c *gin.Context) {
if respondPermissionErrorIf(c, err, true) {
return
}
- common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
+ common.RespondError(c, common.CodeOperatingError, err.Error())
return
}
- common.SuccessWithData(c, gin.H{"initialized": true}, "success")
+ common.RespondSuccess(c, gin.H{"initialized": true}, "success")
}
// ==================== Skill Space Management ====================
@@ -359,18 +359,18 @@ func (h *SkillSearchHandler) InitializeIndex(c *gin.Context) {
func (h *SkillSearchHandler) ListSpaces(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
result, code, err := h.spaceService.ListSpaces(ctx, user.ID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// CreateSpaceRequest represents the request to create a skill space
@@ -394,13 +394,13 @@ type CreateSpaceRequest struct {
func (h *SkillSearchHandler) CreateSpace(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req CreateSpaceRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -412,11 +412,11 @@ func (h *SkillSearchHandler) CreateSpace(c *gin.Context) {
RerankID: req.RerankID,
})
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// GetSpace handles the get skill space request
@@ -430,24 +430,24 @@ func (h *SkillSearchHandler) CreateSpace(c *gin.Context) {
func (h *SkillSearchHandler) GetSpace(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
spaceID := c.Param("space_id")
if spaceID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "space_id is required")
+ common.RespondError(c, common.CodeDataError, "space_id is required")
return
}
ctx := c.Request.Context()
result, code, err := h.spaceService.GetSpace(ctx, user.ID, spaceID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// UpdateSpaceRequest represents the request to update a skill space
@@ -473,19 +473,19 @@ type UpdateSpaceRequest struct {
func (h *SkillSearchHandler) UpdateSpace(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
spaceID := c.Param("space_id")
if spaceID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "space_id is required")
+ common.RespondError(c, common.CodeDataError, "space_id is required")
return
}
var req UpdateSpaceRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -498,11 +498,11 @@ func (h *SkillSearchHandler) UpdateSpace(c *gin.Context) {
TopK: req.TopK,
})
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// DeleteSpace handles the delete skill space request
@@ -518,19 +518,19 @@ func (h *SkillSearchHandler) UpdateSpace(c *gin.Context) {
func (h *SkillSearchHandler) DeleteSpace(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
spaceID := c.Param("space_id")
if spaceID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "space_id is required")
+ common.RespondError(c, common.CodeDataError, "space_id is required")
return
}
code, err := h.spaceService.DeleteSpace(c.Request.Context(), user.ID, spaceID, h.docEngine)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
@@ -555,22 +555,22 @@ func (h *SkillSearchHandler) DeleteSpace(c *gin.Context) {
func (h *SkillSearchHandler) GetSpaceByFolder(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
folderID := c.Query("folder_id")
if folderID == "" {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, "folder_id is required")
+ common.RespondError(c, common.CodeDataError, "folder_id is required")
return
}
ctx := c.Request.Context()
result, code, err := h.spaceService.GetSpaceByFolderID(ctx, user.ID, folderID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
diff --git a/internal/handler/stats.go b/internal/handler/stats.go
index 2d95705838..ff62ce19c0 100644
--- a/internal/handler/stats.go
+++ b/internal/handler/stats.go
@@ -41,7 +41,7 @@ func NewStatsHandler(statsService *service.StatsService) *StatsHandler {
func (h *StatsHandler) GetChatStats(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -66,9 +66,9 @@ func (h *StatsHandler) GetChatStats(c *gin.Context) {
if errors.Is(err, service.ErrTenantNotFound) {
code = common.CodeDataError
}
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, stats, "success")
+ common.RespondSuccess(c, stats, "success")
}
diff --git a/internal/handler/stub.go b/internal/handler/stub.go
index b17bddb377..d92c91073a 100644
--- a/internal/handler/stub.go
+++ b/internal/handler/stub.go
@@ -65,7 +65,7 @@ func issueUserAccessToken(user *entity.User, secretKey string) (string, error) {
// edition. The route stays registered so clients see "not implemented" rather
// than "not found".
func eeNotImplemented(c *gin.Context, feature string) {
- common.ErrorWithCode(c, common.CodeNotImplemented, feature+" not implemented")
+ common.RespondError(c, common.CodeNotImplemented, feature+" not implemented")
}
func (h *SystemHandler) GetEnableAdmin(c *gin.Context) { eeNotImplemented(c, "EnableAdmin") }
@@ -90,11 +90,11 @@ func (h *UserHandler) GetMeta(c *gin.Context) { eeNotImplemented(c, "GetMeta") }
func (h *UserHandler) GetLoginChannelsDeprecated(c *gin.Context) {
channels, code, err := h.userService.GetLoginChannels()
if err != nil {
- common.ResponseWithCodeData(c, code, []interface{}{}, "Load channels failure, error: "+err.Error())
+ common.RespondError(c, code, "Load channels failure, error: "+err.Error())
return
}
- common.SuccessWithData(c, channels, "success")
+ common.RespondSuccessList(c, channels, "success")
}
func (h *ProviderHandler) CreateModelGroup(c *gin.Context) { eeNotImplemented(c, "CreateModelGroup") }
func (h *ProviderHandler) DeleteModelGroup(c *gin.Context) { eeNotImplemented(c, "DeleteModelGroup") }
diff --git a/internal/handler/system.go b/internal/handler/system.go
index aec69a33c9..3bdc2d3bc8 100644
--- a/internal/handler/system.go
+++ b/internal/handler/system.go
@@ -77,18 +77,18 @@ func (h *SystemHandler) Healthz(c *gin.Context) {
func (h *SystemHandler) GetConfig(c *gin.Context) {
config, err := h.systemService.GetConfig()
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Failed to get system configuration")
+ common.Respond(c, http.StatusInternalServerError, 500, nil, "Failed to get system configuration")
return
}
- common.SuccessWithData(c, config, "success")
+ common.RespondSuccess(c, config, "success")
}
// GetStatus get RAGFlow status
func (h *SystemHandler) GetStatus(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -99,7 +99,7 @@ func (h *SystemHandler) GetStatus(c *gin.Context) {
return
}
- common.SuccessWithData(c, status, "success")
+ common.RespondSuccess(c, status, "success")
}
// GetVersion get RAGFlow version
@@ -114,11 +114,11 @@ func (h *SystemHandler) GetStatus(c *gin.Context) {
func (h *SystemHandler) GetVersion(c *gin.Context) {
version, err := h.systemService.GetVersion()
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Failed to get version")
+ common.Respond(c, http.StatusInternalServerError, 500, nil, "Failed to get version")
return
}
- common.SuccessWithData(c, version.Version, "success")
+ common.RespondSuccess(c, gin.H{"version": version.Version}, "success")
}
// GetLogLevel returns the current log level. The response uses the
@@ -128,7 +128,7 @@ func (h *SystemHandler) GetVersion(c *gin.Context) {
// table carried (e.g. "peewee", "pdfminer") were inert for the Go
// side and are no longer returned.
func (h *SystemHandler) GetLogLevel(c *gin.Context) {
- common.SuccessWithData(c, gin.H{"level": common.GetLogLevel()}, "success")
+ common.RespondSuccess(c, gin.H{"level": common.GetLogLevel()}, "success")
}
// SetLogLevelRequest set log level request. PkgName is accepted for
@@ -152,12 +152,12 @@ type SetLogLevelRequest struct {
func (h *SystemHandler) SetLogLevel(c *gin.Context) {
var req SetLogLevelRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ErrorWithCode(c, common.CodeDataError, "pkg_name and level are required")
+ common.RespondError(c, common.CodeDataError, "pkg_name and level are required")
return
}
if err := common.SetLogLevel(req.Level); err != nil {
- common.ErrorWithCode(c, common.CodeDataError, "Invalid log level: "+req.Level)
+ common.RespondError(c, common.CodeDataError, "Invalid log level: "+req.Level)
return
}
@@ -165,31 +165,31 @@ func (h *SystemHandler) SetLogLevel(c *gin.Context) {
config.SetLogLevel(req.Level)
}
- common.SuccessWithData(c, gin.H{"level": req.Level}, "SUCCESS")
+ common.RespondSuccess(c, gin.H{"level": req.Level}, "SUCCESS")
}
// ListEnvironments handle list environments
func (h *SystemHandler) ListEnvironments(c *gin.Context) {
environments, err := h.systemService.ListEnvironments()
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, environments, "SUCCESS")
+ common.RespondSuccessList(c, environments, "SUCCESS")
}
// Language returns the backend runtime language so the front end can
// choose the appropriate code path (Go vs Python).
func (h *SystemHandler) Language(c *gin.Context) {
- common.SuccessWithData(c, map[string]string{"language": "go"}, "success")
+ common.RespondSuccess(c, map[string]string{"language": "go"}, "success")
}
func (h *SystemHandler) GetHardwareInfo(c *gin.Context) {
hardwareInfo, err := utility.GetHardwareInfo()
if err != nil {
- common.ErrorWithCode(c, common.CodeServerError, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
return
}
- common.SuccessWithData(c, hardwareInfo, "SUCCESS")
+ common.RespondSuccess(c, hardwareInfo, "SUCCESS")
}
diff --git a/internal/handler/system_test.go b/internal/handler/system_test.go
new file mode 100644
index 0000000000..0ac2ffb88b
--- /dev/null
+++ b/internal/handler/system_test.go
@@ -0,0 +1,31 @@
+package handler
+
+import (
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+
+ "ragflow/internal/common"
+ "ragflow/internal/service"
+)
+
+func TestSystemHandlerGetVersion(t *testing.T) {
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ NewSystemHandler(service.NewSystemService()).GetVersion(c)
+ var body struct {
+ Code int `json:"code"`
+ Data struct {
+ Version string `json:"version"`
+ } `json:"data"`
+ }
+ if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
+ t.Fatal(err)
+ }
+ if w.Code != http.StatusOK || body.Code != 0 || body.Data.Version != common.GetRAGFlowVersion() {
+ t.Fatalf("unexpected version response: HTTP %d, %s", w.Code, w.Body.String())
+ }
+}
diff --git a/internal/handler/tenant.go b/internal/handler/tenant.go
index 0d37c4080e..e8d49ae91c 100644
--- a/internal/handler/tenant.go
+++ b/internal/handler/tenant.go
@@ -73,14 +73,14 @@ type SetModelRequest struct {
func (h *TenantHandler) setDefaultModels(c *gin.Context, wrapModels bool) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
// Parse request body (same as Python get_request_json())
var req SetModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "Invalid request body: "+err.Error())
return
}
@@ -95,16 +95,16 @@ func (h *TenantHandler) setDefaultModels(c *gin.Context, wrapModels bool) {
},
})
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
if wrapModels {
- common.SuccessWithData(c, map[string]interface{}{"models": []service.ModelItem{}}, "success")
+ common.RespondSuccess(c, map[string]interface{}{"models": []service.ModelItem{}}, "success")
return
}
- common.SuccessNoData(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
// GetDefaultModels returns the user's model selections for the current tenant. The
@@ -115,14 +115,14 @@ func (h *TenantHandler) setDefaultModels(c *gin.Context, wrapModels bool) {
func (h *TenantHandler) GetDefaultModels(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
defaultModels, err := h.userTenantService.ListDefaultModels(ctx, user.ID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, false, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
@@ -133,7 +133,7 @@ func (h *TenantHandler) GetDefaultModels(c *gin.Context) {
if defaultModels == nil {
defaultModels = []service.ModelItem{}
}
- common.SuccessWithData(c, map[string]interface{}{"models": defaultModels}, "success")
+ common.RespondSuccess(c, map[string]interface{}{"models": defaultModels}, "success")
}
// TenantInfo get tenant information
@@ -146,23 +146,23 @@ func (h *TenantHandler) GetDefaultModels(c *gin.Context) {
func (h *TenantHandler) TenantInfo(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
tenantInfo, err := h.userTenantService.GetCurrentTenantInfo(ctx, user.ID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, false, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
if tenantInfo == nil {
- common.ResponseWithCodeData(c, common.CodeDataError, false, "Tenant not found!")
+ common.RespondError(c, common.CodeDataError, "Tenant not found!")
return
}
- common.SuccessWithData(c, tenantInfo, "success")
+ common.RespondSuccess(c, tenantInfo, "success")
}
// TenantList get tenant list for current user
@@ -175,18 +175,18 @@ func (h *TenantHandler) TenantInfo(c *gin.Context) {
func (h *TenantHandler) TenantList(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
tenantList, err := h.tenantService.GetTenantList(ctx, user.ID)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeExceptionError, false, err.Error())
+ common.RespondError(c, common.CodeExceptionError, err.Error())
return
}
- common.SuccessWithData(c, tenantList, "success")
+ common.RespondSuccessList(c, tenantList, "success")
}
// CreateMetadataStore handles the create metadata store request
@@ -201,7 +201,7 @@ func (h *TenantHandler) TenantList(c *gin.Context) {
func (h *TenantHandler) CreateMetadataStore(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -210,11 +210,11 @@ func (h *TenantHandler) CreateMetadataStore(c *gin.Context) {
ctx := c.Request.Context()
code, err := h.tenantService.CreateMetadataStore(ctx, tenantID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessNoData(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
// DeleteMetadataStore handles the delete metadata store request
@@ -229,7 +229,7 @@ func (h *TenantHandler) CreateMetadataStore(c *gin.Context) {
func (h *TenantHandler) DeleteMetadataStore(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
@@ -239,11 +239,11 @@ func (h *TenantHandler) DeleteMetadataStore(c *gin.Context) {
ctx := c.Request.Context()
code, err := h.tenantService.DeleteMetadataStore(ctx, tenantID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessNoData(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
// CreateChunkTableRequest represents the request for creating a chunk table
@@ -265,13 +265,13 @@ type CreateChunkTableRequest struct {
func (h *TenantHandler) CreateChunkStore(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
var req CreateChunkTableRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -288,11 +288,11 @@ func (h *TenantHandler) CreateChunkStore(c *gin.Context) {
}
result, code, err := h.tenantService.CreateChunkStore(ctx, serviceReq)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, result, "success")
+ common.RespondSuccess(c, result, "success")
}
// DeleteChunkTableRequest represents the request for deleting a chunk table
@@ -313,14 +313,14 @@ type DeleteChunkTableRequest struct {
func (h *TenantHandler) DeleteChunkStore(c *gin.Context) {
_, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
ctx := c.Request.Context()
var req DeleteChunkTableRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
+ common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -332,11 +332,11 @@ func (h *TenantHandler) DeleteChunkStore(c *gin.Context) {
code, err := h.tenantService.DeleteChunkStore(ctx, req.KBID)
if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessNoData(c, "success")
+ common.RespondSuccess(c, nil, "success")
}
// ListTenantMembers lists all non-owner members of a tenant.
@@ -347,27 +347,27 @@ func (h *TenantHandler) DeleteChunkStore(c *gin.Context) {
func (h *TenantHandler) ListTenantMembers(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
tenantID := c.Param("tenant_id")
if tenantID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
return
}
if !matchesActiveTenant(c, tenantID) {
- common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")
+ common.RespondError(c, common.CodeForbidden, "Tenant does not match the active token context")
return
}
ctx := c.Request.Context()
members, code, err := h.tenantService.ListMembers(ctx, user.ID, tenantID)
if err != nil {
- common.ResponseWithCodeData(c, code, nil, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, members, "success")
+ common.RespondSuccessList(c, members, "success")
}
// tenantSMTPConfig returns the SMTP settings together with a flag telling
@@ -521,7 +521,7 @@ func (h *TenantHandler) AddTenantMember(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -530,13 +530,13 @@ func (h *TenantHandler) AddTenantMember(c *gin.Context) {
tenantID := c.Param("tenant_id")
if tenantID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("tenant_id is required")
return
}
if !matchesActiveTenant(c, tenantID) {
- common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")
+ common.RespondError(c, common.CodeForbidden, "Tenant does not match the active token context")
operationLog.Code = int(common.CodeForbidden)
operationLog.Error = errors.New("tenant does not match the active token context")
return
@@ -544,7 +544,7 @@ func (h *TenantHandler) AddTenantMember(c *gin.Context) {
var req service.AddMemberRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "invalid request body: "+err.Error())
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "invalid request body: "+err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("invalid request body: " + err.Error())
return
@@ -553,7 +553,7 @@ func (h *TenantHandler) AddTenantMember(c *gin.Context) {
ctx := c.Request.Context()
resp, code, err := h.tenantService.AddMember(ctx, user.ID, tenantID, &req)
if err != nil {
- common.ResponseWithCodeData(c, code, nil, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
@@ -576,7 +576,7 @@ func (h *TenantHandler) AddTenantMember(c *gin.Context) {
}
}
- common.SuccessWithData(c, resp, "success")
+ common.RespondSuccess(c, resp, "success")
}
// RemoveTenantMember removes a user from the tenant.
@@ -600,7 +600,7 @@ func (h *TenantHandler) RemoveTenantMember(c *gin.Context) {
}()
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -609,7 +609,7 @@ func (h *TenantHandler) RemoveTenantMember(c *gin.Context) {
tenantID := c.Param("tenant_id")
if tenantID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("tenant_id is required")
return
@@ -618,13 +618,13 @@ func (h *TenantHandler) RemoveTenantMember(c *gin.Context) {
UserID string `json:"user_id"`
}
if err := c.ShouldBindJSON(&body); err != nil || body.UserID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "user_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "user_id is required")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = errors.New("user_id is required")
return
}
if body.UserID != user.ID && !matchesActiveTenant(c, tenantID) {
- common.ErrorWithCode(c, common.CodeForbidden, "Tenant does not match the active token context")
+ common.RespondError(c, common.CodeForbidden, "Tenant does not match the active token context")
operationLog.Code = int(common.CodeForbidden)
operationLog.Error = errors.New("tenant does not match the active token context")
return
@@ -633,12 +633,12 @@ func (h *TenantHandler) RemoveTenantMember(c *gin.Context) {
ctx := c.Request.Context()
code, err := h.tenantService.RemoveMember(ctx, user.ID, tenantID, body.UserID)
if err != nil {
- common.ResponseWithCodeData(c, code, nil, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// AcceptTenantInvite accepts a pending invitation, transitioning membership status to joined.
@@ -663,7 +663,7 @@ func (h *TenantHandler) AcceptTenantInvite(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -672,7 +672,7 @@ func (h *TenantHandler) AcceptTenantInvite(c *gin.Context) {
tenantID := c.Param("tenant_id")
if tenantID == "" {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
+ common.Respond(c, http.StatusBadRequest, common.CodeBadRequest, nil, "tenant_id is required")
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = errors.New("tenant_id is required")
return
@@ -680,12 +680,12 @@ func (h *TenantHandler) AcceptTenantInvite(c *gin.Context) {
ctx := c.Request.Context()
code, err := h.tenantService.AcceptInvite(ctx, user.ID, tenantID)
if err != nil {
- common.ResponseWithCodeData(c, code, nil, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
func matchesActiveTenant(c *gin.Context, tenantID string) bool {
diff --git a/internal/handler/user.go b/internal/handler/user.go
index 54e878364e..59cdd8ca4d 100644
--- a/internal/handler/user.go
+++ b/internal/handler/user.go
@@ -93,31 +93,27 @@ func (h *UserHandler) Register(c *gin.Context) {
var req service.RegisterRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, false, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
user, code, err := h.userService.Register(ctx, &req)
if err != nil {
- var data interface{} = false
- if code == common.CodeExceptionError {
- data = nil
- }
- common.ResponseWithCodeData(c, code, data, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
operationLog.UserID = user.ID
secretKey, err := server.GetSecretKey(ctx, kvrocks.Get())
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, false, err.Error())
+ common.RespondError(c, common.CodeServerError, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
}
authToken, err := issueUserAccessToken(user, secretKey)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, false, "Failed to generate auth token")
+ common.RespondError(c, common.CodeServerError, "Failed to generate auth token")
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
@@ -131,7 +127,7 @@ func (h *UserHandler) Register(c *gin.Context) {
c.Header("Access-Control-Expose-Headers", "Authorization")
profile := h.userService.GetUserProfile(ctx, user)
- common.SuccessWithData(c, profile, fmt.Sprintf("%s, welcome aboard!", req.Nickname))
+ common.RespondSuccess(c, profile, fmt.Sprintf("%s, welcome aboard!", req.Nickname))
}
// Login user login
@@ -158,7 +154,7 @@ func (h *UserHandler) Login(c *gin.Context) {
var req service.LoginRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, false, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
@@ -168,7 +164,7 @@ func (h *UserHandler) Login(c *gin.Context) {
user, code, err := h.userService.Login(ctx, &req)
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
@@ -179,14 +175,14 @@ func (h *UserHandler) Login(c *gin.Context) {
secretKey, err := server.GetSecretKey(ctx, kvrocks.Get())
if err != nil {
errMessage := fmt.Errorf("failed to get secret key: %s", err.Error())
- common.ResponseWithCodeData(c, common.CodeServerError, false, errMessage.Error())
+ common.RespondError(c, common.CodeServerError, errMessage.Error())
operationLog.Code = int(common.CodeServerError)
operationLog.Error = errMessage
return
}
authToken, err := issueUserAccessToken(user, secretKey)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, false, "Failed to generate auth token")
+ common.RespondError(c, common.CodeServerError, "Failed to generate auth token")
operationLog.Code = int(common.CodeServerError)
operationLog.Error = err
return
@@ -202,7 +198,7 @@ func (h *UserHandler) Login(c *gin.Context) {
c.Header("Access-Control-Expose-Headers", "Authorization")
profile := h.userService.GetUserProfile(ctx, user)
- common.SuccessWithData(c, profile, "Welcome back!")
+ common.RespondSuccess(c, profile, "Welcome back!")
}
// LoginByEmail user login by email
@@ -229,7 +225,7 @@ func (h *UserHandler) LoginByEmail(c *gin.Context) {
var req service.EmailLoginRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, false, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
operationLog.Code = int(common.CodeBadRequest)
operationLog.Error = err
return
@@ -239,7 +235,7 @@ func (h *UserHandler) LoginByEmail(c *gin.Context) {
if !local.IsAdminAvailable() {
adminStatus := local.GetAdminStatus()
- common.ResponseWithCodeData(c, common.CodeAuthenticationError, "No", adminStatus.Reason)
+ common.RespondError(c, common.CodeAuthenticationError, adminStatus.Reason)
operationLog.Code = int(common.CodeAuthenticationError)
operationLog.Error = errors.New(adminStatus.Reason)
return
@@ -247,7 +243,7 @@ func (h *UserHandler) LoginByEmail(c *gin.Context) {
user, code, err := h.userService.LoginByEmail(ctx, &req)
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
@@ -255,7 +251,7 @@ func (h *UserHandler) LoginByEmail(c *gin.Context) {
operationLog.UserID = user.ID
if user.IsSuperuser != nil && *user.IsSuperuser {
- common.ResponseWithCodeData(c, common.CodeForbidden, false, "super admin should not login to this page.")
+ common.RespondError(c, common.CodeForbidden, "super admin should not login to this page.")
operationLog.Code = int(common.CodeForbidden)
operationLog.Error = fmt.Errorf("super admin should not login to this page")
return
@@ -264,14 +260,14 @@ func (h *UserHandler) LoginByEmail(c *gin.Context) {
secretKey, err := server.GetSecretKey(ctx, kvrocks.Get())
if err != nil {
errorMessage := fmt.Errorf("failed to get secret key: %s", err.Error())
- common.ResponseWithCodeData(c, common.CodeServerError, false, errorMessage.Error())
+ common.RespondError(c, common.CodeServerError, errorMessage.Error())
operationLog.Code = int(common.CodeServerError)
operationLog.Error = errorMessage
return
}
authToken, err := issueUserAccessToken(user, secretKey)
if err != nil {
- common.ResponseWithCodeData(c, common.CodeServerError, false, "Failed to generate auth token")
+ common.RespondError(c, common.CodeServerError, "Failed to generate auth token")
operationLog.Code = int(common.CodeServerError)
operationLog.Error = err
return
@@ -284,7 +280,7 @@ func (h *UserHandler) LoginByEmail(c *gin.Context) {
c.Header("Access-Control-Expose-Headers", "Authorization")
profile := h.userService.GetUserProfile(ctx, user)
- common.SuccessWithData(c, profile, "Welcome back!")
+ common.RespondSuccess(c, profile, "Welcome back!")
}
// GetUserByID get user by ID
@@ -300,11 +296,11 @@ func (h *UserHandler) GetUserByID(c *gin.Context) {
user, code, err := h.userService.GetUserByID(ctx, id)
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, user, "success")
+ common.RespondSuccess(c, user, "success")
}
// Logout user logout
@@ -342,7 +338,7 @@ func (h *UserHandler) Logout(c *gin.Context) {
// Same as [email protected]
token := c.GetHeader("Authorization")
if token == "" {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, common.CodeUnauthorized, nil, "missing authorization header")
+ common.Respond(c, http.StatusUnauthorized, common.CodeUnauthorized, nil, "missing authorization header")
c.Abort()
operationLog.Code = int(common.CodeUnauthorized)
operationLog.Error = fmt.Errorf("missing authorization header")
@@ -352,7 +348,7 @@ func (h *UserHandler) Logout(c *gin.Context) {
// Get user by access token
identity, code, err := h.userService.ResolveAccessToken(ctx, token)
if err != nil {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, code, nil, "Invalid access token")
+ common.Respond(c, http.StatusUnauthorized, code, nil, "Invalid access token")
c.Abort()
operationLog.Code = int(code)
operationLog.Error = err
@@ -364,13 +360,13 @@ func (h *UserHandler) Logout(c *gin.Context) {
// Logout user
code, err = h.userService.Logout(ctx, user)
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// Info get user profile information
@@ -384,14 +380,14 @@ func (h *UserHandler) Info(c *gin.Context) {
ctx := c.Request.Context()
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
// Get user profile
profile := h.userService.GetUserProfile(ctx, user)
- common.SuccessWithData(c, profile, "success")
+ common.RespondSuccess(c, profile, "success")
}
// Setting update user settings
@@ -406,29 +402,25 @@ func (h *UserHandler) Setting(c *gin.Context) {
ctx := c.Request.Context()
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
// Parse request
var req service.UpdateSettingsRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, false, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
// Update user settings
code, err := h.userService.UpdateUserSettings(ctx, user, &req)
if err != nil {
- if code == common.CodeExceptionError {
- common.ResponseWithCodeData(c, common.CodeExceptionError, false, err.Error())
- return
- }
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
// ChangePassword change user password
@@ -443,25 +435,25 @@ func (h *UserHandler) ChangePassword(c *gin.Context) {
ctx := c.Request.Context()
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
return
}
// Parse request
var req service.ChangePasswordRequest
if err := c.ShouldBindJSON(&req); err != nil {
- common.ResponseWithCodeData(c, common.CodeBadRequest, false, err.Error())
+ common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
// Change password
code, err := h.userService.ChangePassword(ctx, user, &req)
if err != nil {
- common.ResponseWithCodeData(c, code, false, err.Error())
+ common.RespondError(c, code, err.Error())
return
}
- common.SuccessWithData(c, true, "password changed successfully")
+ common.RespondSuccess(c, nil, "password changed successfully")
}
// SetTenantInfo update tenant information
@@ -489,7 +481,7 @@ func (h *UserHandler) SetTenantInfo(c *gin.Context) {
user, errorCode, errorMessage := GetUser(c)
if errorCode != common.CodeSuccess {
- common.ErrorWithCode(c, errorCode, errorMessage)
+ common.RespondError(c, errorCode, errorMessage)
operationLog.Code = int(errorCode)
operationLog.Error = errors.New(errorMessage)
return
@@ -501,7 +493,7 @@ func (h *UserHandler) SetTenantInfo(c *gin.Context) {
var payload map[string]interface{}
if err := c.ShouldBindBodyWith(&payload, binding.JSON); err != nil {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, missingArgumentMessage)
+ common.RespondError(c, common.CodeArgumentError, missingArgumentMessage)
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = err
return
@@ -514,7 +506,7 @@ func (h *UserHandler) SetTenantInfo(c *gin.Context) {
}
}
if len(missing) > 0 {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, fmt.Sprintf("required argument are missing: %s; ", joinStrings(missing)))
+ common.RespondError(c, common.CodeArgumentError, fmt.Sprintf("required argument are missing: %s; ", joinStrings(missing)))
operationLog.Code = int(common.CodeArgumentError)
operationLog.Error = errors.New(fmt.Sprintf("required argument are missing: %s; ", joinStrings(missing)))
return
@@ -545,13 +537,13 @@ func (h *UserHandler) SetTenantInfo(c *gin.Context) {
code, err := h.userTenantService.SetModelSettings(ctx, user.ID, &req)
if err != nil {
- common.ResponseWithCodeData(c, code, nil, err.Error())
+ common.RespondError(c, code, err.Error())
operationLog.Code = int(code)
operationLog.Error = err
return
}
- common.SuccessWithData(c, true, "success")
+ common.RespondSuccess(c, nil, "success")
}
func joinStrings(values []string) string {
diff --git a/internal/router/request_body_limit.go b/internal/router/request_body_limit.go
index c9b41452be..244221d21e 100644
--- a/internal/router/request_body_limit.go
+++ b/internal/router/request_body_limit.go
@@ -32,7 +32,7 @@ func requestBodyLimitMiddleware() gin.HandlerFunc {
}
if c.Request.ContentLength > limit {
- common.ResponseWithHttpCodeData(c, http.StatusRequestEntityTooLarge, common.CodeBadRequest, nil, "request body too large")
+ common.Respond(c, http.StatusRequestEntityTooLarge, common.CodeBadRequest, nil, "request body too large")
c.Abort()
return
}
diff --git a/internal/service/chat_session.go b/internal/service/chat_session.go
index 3285e5f195..bcbdd126c2 100644
--- a/internal/service/chat_session.go
+++ b/internal/service/chat_session.go
@@ -355,7 +355,7 @@ func (s *ChatSessionService) DeleteSessions(ctx context.Context, userID, chatID
return nil, "", common.CodeDataError, errors.New(strings.Join(allErrors, "; "))
}
- return true, "success", common.CodeSuccess, nil
+ return nil, "success", common.CodeSuccess, nil
}
func stringSliceFromValue(value interface{}) ([]string, bool) {
diff --git a/internal/service/chat_session_contract_test.go b/internal/service/chat_session_contract_test.go
index 3a24956885..054d663a9f 100644
--- a/internal/service/chat_session_contract_test.go
+++ b/internal/service/chat_session_contract_test.go
@@ -187,7 +187,7 @@ func TestDeleteSessions_SuccessByIDs(t *testing.T) {
if message != "success" {
t.Fatalf("message=%q", message)
}
- if result != true {
+ if result != nil {
t.Fatalf("result=%v", result)
}
if len(store.sessions) != 1 {
diff --git a/internal/service/openai_chat.go b/internal/service/openai_chat.go
index 50f203d0b6..32d044f991 100644
--- a/internal/service/openai_chat.go
+++ b/internal/service/openai_chat.go
@@ -241,7 +241,7 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, permissionErr := permissionresponse.NormalizeHidden(err)
- common.ResponseWithCodeData(c, code, nil, permissionErr.Error())
+ common.RespondError(c, code, permissionErr.Error())
return
}
s.writeDataError(c, err.Error())
@@ -250,7 +250,7 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
dialog := dialogResp.Chat
if err := validateChatDatasetAccess(ctx, userID, dialog.KBIDs); err != nil {
code, permissionErr := permissionresponse.NormalizeHidden(err)
- common.ResponseWithCodeData(c, code, nil, permissionErr.Error())
+ common.RespondError(c, code, permissionErr.Error())
return
}
resolvedModel := req.Model
@@ -920,12 +920,12 @@ func streamChatCompletionSSE(
// writeArgError writes a 101 JSON error envelope (malformed request).
func (s *OpenAIChatService) writeArgError(c *gin.Context, msg string) {
- common.ResponseWithCodeData(c, common.CodeArgumentError, nil, msg)
+ common.RespondError(c, common.CodeArgumentError, msg)
}
// writeDataError writes a 102 JSON error envelope (service failure).
func (s *OpenAIChatService) writeDataError(c *gin.Context, msg string) {
- common.ResponseWithCodeData(c, common.CodeDataError, nil, msg)
+ common.RespondError(c, common.CodeDataError, msg)
}
func getCreatedOrDefault(created *int64) int64 {
diff --git a/test/api/agent_api_test.go b/test/api/agent_api_test.go
index 4bef4a6c7e..9cb72bf886 100644
--- a/test/api/agent_api_test.go
+++ b/test/api/agent_api_test.go
@@ -186,18 +186,18 @@ func TestRESTAgentSessions(t *testing.T) {
}
restCode(t, restCall(t, TestConfig, http.MethodGet, "/agents/"+otherID+"/sessions/"+sessionID, nil, nil), http.StatusOK, 404)
wrongDelete := restOK(t, restCall(t, TestConfig, http.MethodDelete, "/agents/"+otherID+"/sessions/"+sessionID, nil, nil))
- if wrongDelete["data"] != false {
- t.Fatalf("cross-agent session delete must be a no-op: %v", wrongDelete)
+ if data, exists := wrongDelete["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
restOK(t, restCall(t, TestConfig, http.MethodGet, path+"/"+sessionID, nil, nil))
deleted := restOK(t, restCall(t, TestConfig, http.MethodDelete, path+"/"+sessionID, nil, nil))
- if deleted["data"] != true {
- t.Fatalf("session deletion returned %v", deleted)
+ if data, exists := deleted["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
restCode(t, restCall(t, TestConfig, http.MethodGet, path+"/"+sessionID, nil, nil), http.StatusOK, 404)
repeated := restOK(t, restCall(t, TestConfig, http.MethodDelete, path+"/"+sessionID, nil, nil))
- if repeated["data"] != false {
- t.Fatalf("repeated deletion must be a no-op: %v", repeated)
+ if data, exists := repeated["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
restOK(t, restCall(t, TestConfig, http.MethodGet, path+"/"+secondID, nil, nil))
for _, tc := range []struct {
diff --git a/test/api/chunk_api_test.go b/test/api/chunk_api_test.go
index 93bc6fec6b..9f02093b3a 100644
--- a/test/api/chunk_api_test.go
+++ b/test/api/chunk_api_test.go
@@ -541,20 +541,20 @@ func TestChunkLifecycle(t *testing.T) {
deleted := callChunkAPI(t, TestConfig, http.MethodDelete, path,
map[string]interface{}{"chunk_ids": []string{ids[0], ids[1], ids[0]}}, nil, http.StatusOK)
requireChunkCode(t, deleted, 0)
- if deleted["data"] != float64(2) {
+ if chunkData(t, deleted)["deleted_count"] != float64(2) {
t.Fatalf("deleted count = %v, want 2 unique chunks", deleted["data"])
}
assertChunkIDs(t, listChunkIDs(t, path, nil, 1), ids[2:])
deleted = callChunkAPI(t, TestConfig, http.MethodDelete, path,
map[string]interface{}{"chunk_ids": ids[:2]}, nil, http.StatusOK)
requireChunkCode(t, deleted, 0)
- if deleted["data"] != float64(0) {
+ if chunkData(t, deleted)["deleted_count"] != float64(0) {
t.Fatalf("repeated deletion count = %v, want 0", deleted["data"])
}
deleted = callChunkAPI(t, TestConfig, http.MethodDelete, path,
map[string]interface{}{"delete_all": true}, nil, http.StatusOK)
requireChunkCode(t, deleted, 0)
- if deleted["data"] != float64(1) {
+ if chunkData(t, deleted)["deleted_count"] != float64(1) {
t.Fatalf("delete_all count = %v, want 1", deleted["data"])
}
assertChunkIDs(t, listChunkIDs(t, path, nil, 0), nil)
@@ -654,7 +654,7 @@ func TestChunkReadUpdateAndDeleteStayWithinDocument(t *testing.T) {
deleted := callChunkAPI(t, TestConfig, http.MethodDelete, otherPath,
map[string]interface{}{"chunk_ids": []string{id}}, nil, http.StatusOK)
requireChunkCode(t, deleted, 0)
- if deleted["data"] != float64(0) {
+ if chunkData(t, deleted)["deleted_count"] != float64(0) {
t.Fatalf("deleted another document's chunk: %v", deleted)
}
get := callChunkAPI(t, TestConfig, http.MethodGet, path+"/"+id, nil, nil, http.StatusOK)
diff --git a/test/api/document_api_test.go b/test/api/document_api_test.go
index 6f9bf72284..4781639b09 100644
--- a/test/api/document_api_test.go
+++ b/test/api/document_api_test.go
@@ -172,15 +172,16 @@ func TestRESTDocumentUploadValidation(t *testing.T) {
// Mixed uploads explicitly report the rejected file while retaining the valid file.
partial := multipartRESTDocuments(t, TestConfig, id, []documentUpload{{Name: "valid.txt", Content: []byte("valid content")}, {Name: "invalid.exe"}})
restCode(t, partial, 200, 500)
- accepted := array(t, partial.JSON["data"])
- if len(accepted) != 1 || object(t, accepted[0])["name"] != "valid.txt" || !strings.Contains(fmt.Sprint(partial.JSON["message"]), "invalid.exe") {
+ if data, exists := partial.JSON["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
+ }
+ if !strings.Contains(fmt.Sprint(partial.JSON["message"]), "invalid.exe") {
t.Fatalf("partial upload=%v", partial.JSON)
}
data, docs := listRESTDocuments(t, id, nil)
- if data["total"] != float64(1) {
+ if data["total"] != float64(1) || len(docs) != 1 || docs[0]["name"] != "valid.txt" {
t.Fatalf("partial upload total=%v", data)
}
- requireRESTDocumentIDs(t, docs, []string{object(t, accepted[0])["id"].(string)})
}
func TestRESTDocumentListingFiltersPaginationAndReads(t *testing.T) {
diff --git a/test/api/files_api_test.go b/test/api/files_api_test.go
index 144932e4e4..8853029b8b 100644
--- a/test/api/files_api_test.go
+++ b/test/api/files_api_test.go
@@ -100,8 +100,8 @@ func TestFilesFolderCreateFallbackAndRenameDuplicate(t *testing.T) {
"src_file_ids": []string{secondID},
"new_name": strings.ToUpper(stringField(t, second, "name")),
}, nil)
- if restOK(t, caseOnly)["data"] != true {
- t.Fatalf("case-only rename data = %v, want true", caseOnly.JSON["data"])
+ if data, exists := restOK(t, caseOnly)["data"]; exists {
+ t.Fatalf("case-only rename data must be omitted, got %v", data)
}
}
@@ -206,8 +206,8 @@ func TestFilesLinkToDatasetsContract(t *testing.T) {
"file_ids": []string{fileID},
"kb_ids": []string{},
}, nil)
- if restOK(t, r)["data"] != true {
- t.Fatalf("link data = %v, want true", r.JSON["data"])
+ if data, exists := restOK(t, r)["data"]; exists {
+ t.Fatalf("link data must be omitted, got %v", data)
}
})
}
diff --git a/test/api/retrieval_api_test.go b/test/api/retrieval_api_test.go
index 9dc9798827..021bfad43b 100644
--- a/test/api/retrieval_api_test.go
+++ b/test/api/retrieval_api_test.go
@@ -354,16 +354,16 @@ func TestRESTRetrievalChunkDeletionConsistency(t *testing.T) {
// Establish all target chunks are searchable before either deletion, so an empty index cannot pass.
waitRESTRetrievalIDs(t, f.request(), f.chunkIDs)
path := "/datasets/" + f.datasetID + "/documents/" + f.documentIDs[0] + "/chunks"
- deleted := restOK(t, restCall(t, TestConfig, http.MethodDelete, path, apiObject{"chunk_ids": f.chunkIDs[:1]}, nil))["data"]
+ deleted := object(t, restOK(t, restCall(t, TestConfig, http.MethodDelete, path, apiObject{"chunk_ids": f.chunkIDs[:1]}, nil))["data"])["deleted_count"]
if deleted != float64(1) {
t.Fatalf("deleted count=%v want 1", deleted)
}
waitRESTRetrievalIDs(t, f.request(), f.chunkIDs[1:])
- if count := restOK(t, restCall(t, TestConfig, http.MethodDelete, path, apiObject{"chunk_ids": f.chunkIDs[1:2]}, nil))["data"]; count != float64(1) {
+ if count := object(t, restOK(t, restCall(t, TestConfig, http.MethodDelete, path, apiObject{"chunk_ids": f.chunkIDs[1:2]}, nil))["data"])["deleted_count"]; count != float64(1) {
t.Fatalf("deleted count=%v want 1", count)
}
path = "/datasets/" + f.datasetID + "/documents/" + f.documentIDs[1] + "/chunks"
- deleted = restOK(t, restCall(t, TestConfig, http.MethodDelete, path, apiObject{"chunk_ids": f.chunkIDs[2:]}, nil))["data"]
+ deleted = object(t, restOK(t, restCall(t, TestConfig, http.MethodDelete, path, apiObject{"chunk_ids": f.chunkIDs[2:]}, nil))["data"])["deleted_count"]
if deleted != float64(2) {
t.Fatalf("batch deleted count=%v want 2", deleted)
}
diff --git a/test/api/router_contracts_api_test.go b/test/api/router_contracts_api_test.go
index f8eeea80e4..9317dad099 100644
--- a/test/api/router_contracts_api_test.go
+++ b/test/api/router_contracts_api_test.go
@@ -22,9 +22,8 @@ func requireRouteNotFound(t *testing.T, r restResult, path string) {
if r.JSON["message"] != want {
t.Fatalf("expected message %q, got %v, payload: %v", want, r.JSON["message"], r.JSON)
}
- data, ok := r.JSON["data"]
- if !ok || data != nil {
- t.Fatalf("expected data null, got %v, payload: %v", r.JSON["data"], r.JSON)
+ if data, exists := r.JSON["data"]; exists {
+ t.Fatalf("data must be omitted, got %v, payload: %v", data, r.JSON)
}
}
diff --git a/test/api/search_api_test.go b/test/api/search_api_test.go
index 61c21166ae..b0d312c521 100644
--- a/test/api/search_api_test.go
+++ b/test/api/search_api_test.go
@@ -160,8 +160,8 @@ func TestRESTSearchLifecycle(t *testing.T) {
}
deleted := restOK(t, restCall(t, TestConfig, http.MethodDelete, "/searches/"+id, nil, nil))
- if deleted["data"] != true {
- t.Fatalf("delete returned %v, want true", deleted["data"])
+ if data, exists := deleted["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
restCode(t, restCall(t, TestConfig, http.MethodGet, "/searches/"+id, nil, nil), http.StatusOK, 404)
// Deletion is a hard delete, so a repeat must be invisible rather than a no-op success.
diff --git a/test/api/session_api_test.go b/test/api/session_api_test.go
index 7139492760..d2e6618a2c 100644
--- a/test/api/session_api_test.go
+++ b/test/api/session_api_test.go
@@ -62,9 +62,9 @@ func TestRESTSessionLifecyclePersistsAndDeletes(t *testing.T) {
t.Fatalf("updated name was not persisted: %v", persisted)
}
- deleted := restOK(t, restCall(t, TestConfig, http.MethodDelete, "/chats/"+chatID+"/sessions", apiObject{"ids": []string{sessionID}}, nil))["data"]
- if deleted != true {
- t.Fatalf("delete result=%v", deleted)
+ deleted := restOK(t, restCall(t, TestConfig, http.MethodDelete, "/chats/"+chatID+"/sessions", apiObject{"ids": []string{sessionID}}, nil))
+ if data, exists := deleted["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
remaining := restOK(t, restCall(t, TestConfig, http.MethodGet, "/chats/"+chatID+"/sessions", nil, apiObject{"page_size": 20}))
if slicesContainsID(t, array(t, remaining["data"]), sessionID) {
diff --git a/test/api/system_api_test.go b/test/api/system_api_test.go
index 9516cffbc9..f6ea1dc364 100644
--- a/test/api/system_api_test.go
+++ b/test/api/system_api_test.go
@@ -22,8 +22,8 @@ func TestRESTSystemPublicContracts(t *testing.T) {
t.Fatalf("ping status/body=%d/%q", ping.Status, ping.Body)
}
version := restOK(t, restCall(t, &config, http.MethodGet, "/system/version", nil, nil))
- if value, ok := version["data"].(string); !ok || value == "" {
- t.Fatalf("version must be a nonempty string: %v", version)
+ if value, ok := object(t, version["data"])["version"].(string); !ok || value == "" {
+ t.Fatalf("data.version must be a nonempty string: %v", version)
}
systemConfig := restOK(t, restCall(t, &config, http.MethodGet, "/system/config", nil, nil))
configData := object(t, systemConfig["data"])
@@ -108,8 +108,8 @@ func TestRESTSystemTokenLifecycleAndRedaction(t *testing.T) {
}
}
repeated := restOK(t, restCall(t, TestConfig, http.MethodDelete, "/system/tokens/"+token, nil, nil))
- if repeated["data"] != true {
- t.Fatalf("repeated delete should be idempotent: %v", repeated)
+ if data, exists := repeated["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
}
diff --git a/test/api/task_routes_api_test.go b/test/api/task_routes_api_test.go
index 38d7e78545..1bbb6a09d8 100644
--- a/test/api/task_routes_api_test.go
+++ b/test/api/task_routes_api_test.go
@@ -21,12 +21,12 @@ func TestRESTTaskCancellationRequiresAuthentication(t *testing.T) {
func TestRESTTaskCancellationMissingAndRepeatedAreIdempotent(t *testing.T) {
taskID := uniqueName("missing_task")
first := restOK(t, restCall(t, TestConfig, http.MethodPost, "/tasks/"+taskID+"/cancel", nil, nil))
- if first["data"] != true {
- t.Fatalf("missing-task cancellation should acknowledge the request: %v", first)
+ if data, exists := first["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
second := restOK(t, restCall(t, TestConfig, http.MethodPost, "/tasks/"+taskID+"/cancel", nil, nil))
- if second["data"] != true {
- t.Fatalf("repeated cancellation changed acknowledgement: %v", second)
+ if data, exists := second["data"]; exists {
+ t.Fatalf("data must be omitted, got %v", data)
}
}
diff --git a/test/testcases/test_sdk_api/test_chat_assistant_management/test_delete_chat_assistants.py b/test/testcases/test_sdk_api/test_chat_assistant_management/test_delete_chat_assistants.py
index 52696fd952..e5b1250060 100644
--- a/test/testcases/test_sdk_api/test_chat_assistant_management/test_delete_chat_assistants.py
+++ b/test/testcases/test_sdk_api/test_chat_assistant_management/test_delete_chat_assistants.py
@@ -88,7 +88,7 @@ class TestChatAssistantsDelete:
chat = chat_factory()
response = client.delete(f"/chats/{chat.id}", None).json()
assert response["code"] == 0, response
- assert response["data"] is True
+ assert "data" not in response, response
assert client.list_chats(id=chat.id) == []
@pytest.mark.p2
diff --git a/web/src/hooks/use-agent-request.ts b/web/src/hooks/use-agent-request.ts
index b1d112d35f..78fd16a0cb 100644
--- a/web/src/hooks/use-agent-request.ts
+++ b/web/src/hooks/use-agent-request.ts
@@ -355,7 +355,7 @@ export const useDeleteAgent = () => {
});
markListItemsDeleted(ListDeletionKey.AgentList);
}
- return data?.data ?? false;
+ return data?.code;
},
});
@@ -1191,7 +1191,7 @@ export const useCancelDataflow = () => {
if (ret?.data?.code === 0) {
message.success('success');
} else {
- message.error(ret?.data?.data);
+ message.error(ret?.data?.message);
}
return ret?.data?.code;
},
diff --git a/web/src/hooks/use-compilation-template-group-request.ts b/web/src/hooks/use-compilation-template-group-request.ts
index 3ed43051fd..5984513f94 100644
--- a/web/src/hooks/use-compilation-template-group-request.ts
+++ b/web/src/hooks/use-compilation-template-group-request.ts
@@ -190,7 +190,7 @@ export const useDeleteCompilationTemplateGroup = () => {
});
markListItemsDeleted(ListDeletionKey.AgentList);
}
- return data?.data ?? true;
+ return data?.code;
},
});
diff --git a/web/src/hooks/use-mcp-request.ts b/web/src/hooks/use-mcp-request.ts
index c6d3972980..1d33381edb 100644
--- a/web/src/hooks/use-mcp-request.ts
+++ b/web/src/hooks/use-mcp-request.ts
@@ -168,7 +168,7 @@ export const useDeleteMcpServer = () => {
ids.map((id) => mcpServerService.delete({ mcp_id: id })),
);
const failed = results.find(({ data = {} }) => data.code !== 0);
- const data = failed?.data ?? { code: 0, data: true };
+ const data = failed?.data ?? { code: 0 };
if (!failed) {
message.success(i18n.t(`message.deleted`));
diff --git a/web/src/hooks/use-user-setting-request.tsx b/web/src/hooks/use-user-setting-request.tsx
index 1337ee4cda..80e52ea9a4 100644
--- a/web/src/hooks/use-user-setting-request.tsx
+++ b/web/src/hooks/use-user-setting-request.tsx
@@ -215,7 +215,7 @@ export const useFetchSystemVersion = () => {
setLoading(true);
const { data } = await userService.getSystemVersion();
if (data.code === 0) {
- setVersion(data.data);
+ setVersion(data.data.version);
setLoading(false);
}
} catch (error) {
@@ -281,7 +281,7 @@ export const useRemoveSystemToken = () => {
queryKey: [UserSettingApiAction.FetchSystemTokenList],
});
}
- return data?.data ?? [];
+ return data?.code;
},
});
@@ -387,7 +387,7 @@ export const useDeleteTenantUser = () => {
queryKey: [UserSettingApiAction.ListTenant],
});
}
- return data?.data ?? [];
+ return data?.code;
},
});
@@ -434,7 +434,7 @@ export const useAgreeTenant = () => {
queryKey: [UserSettingApiAction.ListTenant],
});
}
- return data?.data ?? [];
+ return data?.code;
},
});
@@ -472,11 +472,7 @@ export const useDeleteLangfuseConfig = () => {
mutationFn: async () => {
const { data } = await userService.deleteLangfuseConfig();
if (data.code === 0) {
- if (data.data) {
- message.success(t('message.deleted'));
- } else {
- message.warning(t('message.noLangfuseConfigToDelete'));
- }
+ message.success(t('message.deleted'));
}
return data?.code;
},
diff --git a/web/src/hooks/use-user-setting-response.test.tsx b/web/src/hooks/use-user-setting-response.test.tsx
new file mode 100644
index 0000000000..922f1a1a96
--- /dev/null
+++ b/web/src/hooks/use-user-setting-response.test.tsx
@@ -0,0 +1,136 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook } from '@testing-library/react';
+import {
+ useAgreeTenant,
+ useDeleteLangfuseConfig,
+ useDeleteTenantUser,
+ useFetchSystemVersion,
+ useRemoveSystemToken,
+} from './use-user-setting-request';
+
+const mockGetSystemVersion = jest.fn();
+const mockDeleteLangfuseConfig = jest.fn();
+const mockRemoveToken = jest.fn();
+const mockDeleteTenantUser = jest.fn();
+const mockAgreeTenant = jest.fn();
+const mockSuccess = jest.fn();
+const mockWarning = jest.fn();
+
+jest.mock('@/services/user-service', () => ({
+ __esModule: true,
+ default: {
+ getSystemVersion: () => mockGetSystemVersion(),
+ deleteLangfuseConfig: () => mockDeleteLangfuseConfig(),
+ removeToken: (...args: unknown[]) => mockRemoveToken(...args),
+ getTenantInfo: async () => ({
+ data: { code: 0, data: { tenant_id: 'tenant-1' } },
+ }),
+ },
+ deleteTenantUser: (...args: unknown[]) => mockDeleteTenantUser(...args),
+ agreeTenant: (...args: unknown[]) => mockAgreeTenant(...args),
+}));
+jest.mock('@/services/knowledge-service', () => ({
+ __esModule: true,
+ default: {},
+}));
+jest.mock('./use-llm-request', () => ({
+ useFetchDefaultModelDictionary: jest.fn(),
+}));
+jest.mock('@/locales/config', () => ({
+ DEFAULT_LANGUAGE_CODE: 'en',
+ supportedLanguages: [],
+}));
+jest.mock('react-i18next', () => ({
+ useTranslation: () => ({ t: (key: string) => key }),
+}));
+jest.mock('@/components/ui/message', () => ({
+ __esModule: true,
+ default: {
+ success: (value: string) => mockSuccess(value),
+ warning: (value: string) => mockWarning(value),
+ },
+}));
+
+function createWrapper() {
+ const queryClient = new QueryClient({
+ defaultOptions: { mutations: { retry: false } },
+ });
+ return function Wrapper({ children }: { children?: any }) {
+ return (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+ );
+ };
+}
+
+beforeEach(() => jest.clearAllMocks());
+
+it('reads the system version from data.version', async () => {
+ mockGetSystemVersion.mockResolvedValue({
+ data: { code: 0, message: 'success', data: { version: 'v1.2.3' } },
+ });
+ const { result } = renderHook(() => useFetchSystemVersion());
+
+ await act(async () => {
+ await result.current.fetchSystemVersion();
+ });
+
+ expect(result.current.version).toBe('v1.2.3');
+ expect(result.current.loading).toBe(false);
+});
+
+it.each(['success', 'Have not record any Langfuse keys.'])(
+ 'handles Langfuse deletion without data: %s',
+ async (message) => {
+ mockDeleteLangfuseConfig.mockResolvedValue({
+ data: { code: 0, message },
+ });
+ const { result } = renderHook(() => useDeleteLangfuseConfig(), {
+ wrapper: createWrapper(),
+ });
+
+ await act(async () => {
+ expect(await result.current.deleteLangfuseConfig()).toBe(0);
+ });
+
+ expect(mockSuccess).toHaveBeenCalledWith('message.deleted');
+ expect(mockWarning).not.toHaveBeenCalled();
+ },
+);
+
+it.each([0, 102])(
+ 'uses code %s for acknowledgments without data',
+ async (code) => {
+ const response = {
+ data: { code, message: code === 0 ? 'success' : 'failed' },
+ };
+ mockRemoveToken.mockResolvedValue(response);
+ mockDeleteTenantUser.mockResolvedValue(response);
+ mockAgreeTenant.mockResolvedValue(response);
+ const { result } = renderHook(
+ () => ({
+ tokens: useRemoveSystemToken(),
+ members: useDeleteTenantUser(),
+ invites: useAgreeTenant(),
+ }),
+ { wrapper: createWrapper() },
+ );
+
+ await act(async () => {
+ expect(await result.current.tokens.removeToken('token-1')).toBe(code);
+ expect(
+ await result.current.members.deleteTenantUser({
+ userId: 'user-1',
+ tenantId: 'tenant-1',
+ }),
+ ).toBe(code);
+ expect(await result.current.invites.agreeTenant('tenant-1')).toBe(code);
+ });
+
+ expect(mockRemoveToken).toHaveBeenCalledWith({}, 'token-1');
+ expect(mockDeleteTenantUser).toHaveBeenCalledWith({
+ tenantId: 'tenant-1',
+ userId: 'user-1',
+ });
+ expect(mockAgreeTenant).toHaveBeenCalledWith('tenant-1');
+ },
+);
diff --git a/web/src/interfaces/database/base.ts b/web/src/interfaces/database/base.ts
index da02afc291..85a3090186 100644
--- a/web/src/interfaces/database/base.ts
+++ b/web/src/interfaces/database/base.ts
@@ -1,6 +1,6 @@
export interface ResponseType<T = any> {
code: number;
- data: T;
+ data?: T;
message: string;
status: number;
}
diff --git a/web/src/pages/dataset/dataset/use-upload-document.ts b/web/src/pages/dataset/dataset/use-upload-document.ts
index 1f47c0c985..78f7e7f72d 100644
--- a/web/src/pages/dataset/dataset/use-upload-document.ts
+++ b/web/src/pages/dataset/dataset/use-upload-document.ts
@@ -64,7 +64,7 @@ export const useHandleUploadDocument = (pipelineId?: string) => {
if (
(isSuccess || isPartialSuccess) &&
parseOnCreation &&
- ret.data?.length > 0
+ (ret.data?.length ?? 0) > 0
) {
const runnableDocuments = (ret.data as IDocumentInfo[]).filter(
(doc) => findDocumentParseGaps([doc]).length === 0,
diff --git a/web/src/pages/memories/interface.ts b/web/src/pages/memories/interface.ts
index 33e8bcd292..35ab17f7f2 100644
--- a/web/src/pages/memories/interface.ts
+++ b/web/src/pages/memories/interface.ts
@@ -63,7 +63,6 @@ export interface DeleteMemoryProps {
export interface DeleteMemoryResponse {
code: number;
- data: boolean;
message: string;
}
diff --git a/web/src/pages/next-searches/hooks.ts b/web/src/pages/next-searches/hooks.ts
index fd2a6edcdb..e6b6bfaafe 100644
--- a/web/src/pages/next-searches/hooks.ts
+++ b/web/src/pages/next-searches/hooks.ts
@@ -170,7 +170,6 @@ interface DeleteSearchProps {
interface DeleteSearchResponse {
code: number;
- data: boolean;
message: string;
}
diff --git a/web/src/pages/user-setting/mcp/use-export-mcp.ts b/web/src/pages/user-setting/mcp/use-export-mcp.ts
index dc9aa35518..5adafd5e46 100644
--- a/web/src/pages/user-setting/mcp/use-export-mcp.ts
+++ b/web/src/pages/user-setting/mcp/use-export-mcp.ts
@@ -31,7 +31,7 @@ export function useExportMcp(mcp?: IMcpServer) {
return;
}
const data = await exportMcpServer(ids);
- if (data.code === 0) {
+ if (data.code === 0 && data.data) {
downloadJsonFile(data.data, `${mcp?.name || 'mcp'}.json`);
}
},
diff --git a/web/src/services/admin-service.ts b/web/src/services/admin-service.ts
index 3f12cc6ab9..7cc5529039 100644
--- a/web/src/services/admin-service.ts
+++ b/web/src/services/admin-service.ts
@@ -171,12 +171,12 @@ type ResponseData<D = NonNullable<unknown>> = {
export const login = (params: { email: string; password: string }) =>
request.post<ResponseData<AdminService.LoginData>>(adminLogin, params);
-export const logout = () => request.post<ResponseData<boolean>>(adminLogout);
+export const logout = () => request.post<ResponseData<void>>(adminLogout);
export const listUsers = () =>
request.get<ResponseData<AdminService.ListUsersItem[]>>(adminListUsers, {});
export const createUser = (email: string, password: string) =>
- request.post<ResponseData<boolean>>(adminCreateUser, {
+ request.post<ResponseData<Record<string, unknown>>>(adminCreateUser, {
username: email,
password,
});