yunzer_go/server/controllers/knowledge.go

package controllers

import (
	"encoding/json"
	"server/models"
	"strconv"

	beego "github.com/beego/beego/v2/server/web"
)

// KnowledgeController 知识库控制器
type KnowledgeController struct {
	beego.Controller
}

// List 获取知识列表
// @router /api/knowledge/list [get]
func (c *KnowledgeController) List() {
	// 获取查询参数
	page, _ := c.GetInt("page", 1)
	pageSize, _ := c.GetInt("pageSize", 10)
	status, _ := c.GetInt8("status", -1) // -1表示查询所有
	categoryId, _ := c.GetInt("categoryId", 0)
	keyword := c.GetString("keyword", "")

	knowledges, total, err := models.GetAllKnowledge(page, pageSize, status, categoryId, keyword)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取知识列表失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "success",
		"data": map[string]interface{}{
			"list":     knowledges,
			"total":    total,
			"page":     page,
			"pageSize": pageSize,
		},
	}
	c.ServeJSON()
}

// Detail 获取知识详情
// @router /api/knowledge/detail [get]
func (c *KnowledgeController) Detail() {
	id, _ := strconv.Atoi(c.GetString("id"))
	if id == 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "知识ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	knowledge, err := models.GetKnowledgeById(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取知识详情失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "success",
		"data":    knowledge,
	}
	c.ServeJSON()
}

// Create 创建知识
// @router /api/knowledge/create [post]
func (c *KnowledgeController) Create() {
	// 解析请求体
	var knowledge models.Knowledge
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &knowledge)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 验证必填字段
	if knowledge.Title == "" {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "标题不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	id, err := models.AddKnowledge(&knowledge)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "创建知识失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "创建成功",
		"data":    map[string]interface{}{"id": id},
	}
	c.ServeJSON()
}

// Update 更新知识
// @router /api/knowledge/update [post]
func (c *KnowledgeController) Update() {
	// 解析请求体
	var knowledge models.Knowledge
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &knowledge)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 验证必填字段
	if knowledge.Id == 0 {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "知识ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	err = models.UpdateKnowledge(knowledge.Id, &knowledge)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "更新知识失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "更新成功",
		"data":    nil,
	}
	c.ServeJSON()
}

// Delete 软删除知识
// @router /api/knowledge/delete [post]
func (c *KnowledgeController) Delete() {
	var request map[string]interface{}
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &request)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	id, ok := request["id"].(float64)
	if !ok {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "知识ID不能为空",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 从请求头或 session 中获取当前用户信息
	deleteBy := c.GetString("username")
	if deleteBy == "" {
		deleteBy = c.GetString("user")
	}
	if deleteBy == "" {
		deleteBy = "system" // 默认值
	}

	err = models.DeleteKnowledge(int(id), deleteBy)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "删除知识失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "删除成功",
		"data":    nil,
	}
	c.ServeJSON()
}

// GetCategories 获取分类列表
// @router /api/knowledge/categories [get]
func (c *KnowledgeController) GetCategories() {
	categories, err := models.GetAllCategories()
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取分类列表失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 手动转换数据格式，确保字段名正确
	var result []map[string]interface{}
	for _, cat := range categories {
		result = append(result, map[string]interface{}{
			"categoryId":   cat.CategoryId,
			"categoryName": cat.CategoryName,
			"categoryDesc": cat.CategoryDesc,
			"parentId":     cat.ParentId,
			"sortOrder":    cat.SortOrder,
			"createTime":   cat.CreateTime,
			"updateTime":   cat.UpdateTime,
		})
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "success",
		"data":    result,
	}
	c.ServeJSON()
}

// GetTags 获取标签列表
// @router /api/knowledge/tags [get]
func (c *KnowledgeController) GetTags() {
	tags, err := models.GetAllTags()
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "获取标签列表失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 手动转换数据格式，确保字段名正确
	var result []map[string]interface{}
	for _, tag := range tags {
		result = append(result, map[string]interface{}{
			"tagId":      tag.TagId,
			"tagName":    tag.TagName,
			"tagColor":   tag.TagColor,
			"usageCount": tag.UsageCount,
			"createTime": tag.CreateTime,
			"updateTime": tag.UpdateTime,
		})
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "success",
		"data":    result,
	}
	c.ServeJSON()
}

// AddCategory 添加分类
// @router /api/knowledge/category/add [post]
func (c *KnowledgeController) AddCategory() {
	var category models.KnowledgeCategory
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &category)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	id, err := models.AddCategory(&category)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "添加分类失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "添加成功",
		"data":    map[string]interface{}{"categoryId": id},
	}
	c.ServeJSON()
}

// AddTag 添加标签
// @router /api/knowledge/tag/add [post]
func (c *KnowledgeController) AddTag() {
	var tag models.KnowledgeTag
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &tag)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "请求参数格式错误",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	id, err := models.AddTag(&tag)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"code":    1,
			"message": "添加标签失败: " + err.Error(),
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	c.Data["json"] = map[string]interface{}{
		"code":    0,
		"message": "添加成功",
		"data":    map[string]interface{}{"tagId": id},
	}
	c.ServeJSON()
}