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)
	share, _ := c.GetInt8("share", -1) // Default -1 to query all
	keyword := c.GetString("keyword", "")

	// 获取租户ID（如果是员工登录，从JWT token中获取）
	tenantId := 0
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			tenantId = tenantIdVal
		}
	}

	// Use share in the query
	knowledges, total, err := models.GetAllKnowledge(page, pageSize, status, categoryId, share, keyword, tenantId)
	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()
}

// GetCount 获取知识库数量及增长率
// @router /api/knowledge/count [get]
func (c *KnowledgeController) GetCount() {
	// 获取租户ID（如果是员工登录，从JWT token中获取）
	tenantId := 0
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			tenantId = tenantIdVal
		}
	}

	totalCount, currentMonthCount, lastMonthCount, growthRate, err := models.GetKnowledgeCountWithGrowth(tenantId)
	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{}{
			"count":             totalCount,
			"currentMonthCount": currentMonthCount,
			"lastMonthCount":    lastMonthCount,
			"growthRate":        growthRate,
		},
	}
	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
	}

	// 获取租户ID（如果是员工登录，从JWT token中获取）
	tenantId := 0
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			tenantId = tenantIdVal
		}
	}

	knowledge, err := models.GetKnowledgeById(id, tenantId)
	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
	}

	// Add share parsing (default 0 for personal)
	share, _ := c.GetInt8("share", 0)
	knowledge.Share = share

	// 获取租户ID（如果是员工登录，从JWT token中获取并设置）
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			knowledge.TenantId = tenantIdVal
		}
	}

	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
	}

	// 获取租户ID（如果是员工登录，从JWT token中获取）
	tenantId := 0
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			tenantId = tenantIdVal
		}
	}

	err = models.UpdateKnowledge(knowledge.Id, &knowledge, tenantId)
	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" // 默认值
	}

	// 获取租户ID（如果是员工登录，从JWT token中获取）
	tenantId := 0
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			tenantId = tenantIdVal
		}
	}

	err = models.DeleteKnowledge(int(id), deleteBy, tenantId)
	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() {
	// 获取租户ID（如果是员工登录，从JWT token中获取）
	tenantId := 0
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			tenantId = tenantIdVal
		}
	}

	categories, err := models.GetAllCategories(tenantId)
	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() {
	// 获取租户ID（如果是员工登录，从JWT token中获取）
	tenantId := 0
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			tenantId = tenantIdVal
		}
	}

	tags, err := models.GetAllTags(tenantId)
	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,
			"tagBackground": tag.TagBackground,
			"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（如果是员工登录，从JWT token中获取并设置）
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			category.TenantId = tenantIdVal
		}
	}

	// 不处理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":    nil,
	}
	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（如果是员工登录，从JWT token中获取并设置）
	if tenantIdVal, ok := c.Ctx.Input.GetData("tenantId").(int); ok && tenantIdVal > 0 {
		// 检查是否是员工登录（type === "employee"）
		if userType, ok := c.Ctx.Input.GetData("userType").(string); ok && userType == "employee" {
			tag.TenantId = tenantIdVal
		}
	}

	// 判断是添加还是更新
	if tag.TagId > 0 {
		// 更新操作
		err = models.UpdateTag(&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": tag.TagId},
		}
		c.ServeJSON()
		return
	}

	// 添加操作：确保 TagId 为 0，让数据库自动生成
	tag.TagId = 0
	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()
}