262 lines
7.1 KiB
Go
262 lines
7.1 KiB
Go
package handler
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"kefu-sys/server/internal/middleware"
|
|
"kefu-sys/server/internal/model"
|
|
)
|
|
|
|
type KnowledgeHandler struct{}
|
|
|
|
func NewKnowledgeHandler() *KnowledgeHandler { return &KnowledgeHandler{} }
|
|
|
|
func requireKnowledgeManager(c *gin.Context) bool {
|
|
if middleware.HasAnyRole(c, "admin", "supervisor") {
|
|
return true
|
|
}
|
|
c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "仅主管或管理员可管理知识库"})
|
|
return false
|
|
}
|
|
|
|
func hasKnowledgeCapacity(tenantID uint) (bool, error) {
|
|
var tenant model.Tenant
|
|
if err := model.DB.First(&tenant, tenantID).Error; err != nil {
|
|
return false, err
|
|
}
|
|
if tenant.PlanID == nil {
|
|
return true, nil
|
|
}
|
|
var plan model.Plan
|
|
if err := model.DB.First(&plan, *tenant.PlanID).Error; err != nil {
|
|
return false, err
|
|
}
|
|
if plan.KBLimit == 0 {
|
|
return true, nil
|
|
}
|
|
var count int64
|
|
if err := model.DB.Model(&model.KnowledgeEntry{}).Where("tenant_id = ?", tenantID).Count(&count).Error; err != nil {
|
|
return false, err
|
|
}
|
|
return count < int64(plan.KBLimit), nil
|
|
}
|
|
|
|
type CategoryListItem struct {
|
|
model.Category
|
|
EntryCount int64 `json:"entry_count"`
|
|
}
|
|
|
|
func (h *KnowledgeHandler) ListCategories(c *gin.Context) {
|
|
tenantID := middleware.GetTenantID(c)
|
|
|
|
var categories []model.Category
|
|
model.DB.Where("tenant_id = ?", tenantID).Order("id asc").Find(&categories)
|
|
|
|
type countRow struct {
|
|
CategoryID uint
|
|
Cnt int64
|
|
}
|
|
var rows []countRow
|
|
model.DB.Model(&model.KnowledgeEntry{}).
|
|
Select("category_id, COUNT(*) as cnt").
|
|
Where("tenant_id = ?", tenantID).
|
|
Group("category_id").
|
|
Scan(&rows)
|
|
countMap := map[uint]int64{}
|
|
var total int64
|
|
for _, r := range rows {
|
|
countMap[r.CategoryID] = r.Cnt
|
|
total += r.Cnt
|
|
}
|
|
|
|
items := make([]CategoryListItem, 0, len(categories))
|
|
for _, cat := range categories {
|
|
items = append(items, CategoryListItem{Category: cat, EntryCount: countMap[cat.ID]})
|
|
}
|
|
// total 放在额外字段便于侧栏「全部知识库」
|
|
middleware.JSON(c, gin.H{"list": items, "total_entries": total})
|
|
}
|
|
|
|
func (h *KnowledgeHandler) CreateCategory(c *gin.Context) {
|
|
if !requireKnowledgeManager(c) {
|
|
return
|
|
}
|
|
var category model.Category
|
|
if err := c.ShouldBindJSON(&category); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
|
|
return
|
|
}
|
|
category.TenantID = middleware.GetTenantID(c)
|
|
|
|
if err := model.DB.Create(&category).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "创建失败"})
|
|
return
|
|
}
|
|
|
|
middleware.JSON(c, category)
|
|
}
|
|
|
|
type EntryListItem struct {
|
|
model.KnowledgeEntry
|
|
CategoryName string `json:"category_name"`
|
|
}
|
|
|
|
func (h *KnowledgeHandler) ListEntries(c *gin.Context) {
|
|
tenantID := middleware.GetTenantID(c)
|
|
page, pageSize := middleware.GetPageParams(c)
|
|
categoryID := c.Query("category_id")
|
|
search := c.Query("search")
|
|
status := c.Query("status")
|
|
sortBy := c.Query("sort") // usage | updated(default)
|
|
|
|
var entries []model.KnowledgeEntry
|
|
var total int64
|
|
|
|
query := model.DB.Where("tenant_id = ?", tenantID)
|
|
if categoryID != "" {
|
|
query = query.Where("category_id = ?", categoryID)
|
|
}
|
|
if search != "" {
|
|
query = query.Where("title LIKE ? OR content LIKE ?", "%"+search+"%", "%"+search+"%")
|
|
}
|
|
if status != "" {
|
|
query = query.Where("status = ?", status)
|
|
}
|
|
|
|
query.Model(&model.KnowledgeEntry{}).Count(&total)
|
|
order := "updated_at desc"
|
|
if sortBy == "usage" {
|
|
order = "usage_count desc, updated_at desc"
|
|
} else if sortBy == "title" {
|
|
order = "title asc"
|
|
}
|
|
query.Order(order).Offset((page - 1) * pageSize).Limit(pageSize).Find(&entries)
|
|
|
|
catIDs := make([]uint, 0, len(entries))
|
|
for _, e := range entries {
|
|
catIDs = append(catIDs, e.CategoryID)
|
|
}
|
|
catMap := map[uint]string{}
|
|
if len(catIDs) > 0 {
|
|
seen := map[uint]struct{}{}
|
|
unique := make([]uint, 0)
|
|
for _, id := range catIDs {
|
|
if _, ok := seen[id]; ok {
|
|
continue
|
|
}
|
|
seen[id] = struct{}{}
|
|
unique = append(unique, id)
|
|
}
|
|
var cats []model.Category
|
|
model.DB.Where("id IN ?", unique).Find(&cats)
|
|
for _, cat := range cats {
|
|
catMap[cat.ID] = cat.Name
|
|
}
|
|
}
|
|
|
|
items := make([]EntryListItem, 0, len(entries))
|
|
for _, e := range entries {
|
|
items = append(items, EntryListItem{
|
|
KnowledgeEntry: e,
|
|
CategoryName: catMap[e.CategoryID],
|
|
})
|
|
}
|
|
|
|
middleware.JSONList(c, items, total, page, pageSize)
|
|
}
|
|
|
|
func (h *KnowledgeHandler) CreateEntry(c *gin.Context) {
|
|
if !requireKnowledgeManager(c) {
|
|
return
|
|
}
|
|
var entry model.KnowledgeEntry
|
|
if err := c.ShouldBindJSON(&entry); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
|
|
return
|
|
}
|
|
entry.TenantID = middleware.GetTenantID(c)
|
|
available, err := hasKnowledgeCapacity(entry.TenantID)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "校验知识库容量失败"})
|
|
return
|
|
}
|
|
if !available {
|
|
c.JSON(http.StatusConflict, gin.H{"code": 409, "message": "当前套餐知识库容量已达上限"})
|
|
return
|
|
}
|
|
var category model.Category
|
|
if err := model.DB.Where("id = ? AND tenant_id = ?", entry.CategoryID, entry.TenantID).First(&category).Error; err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "知识分类不存在"})
|
|
return
|
|
}
|
|
|
|
if err := model.DB.Create(&entry).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "创建失败"})
|
|
return
|
|
}
|
|
|
|
middleware.JSON(c, entry)
|
|
}
|
|
|
|
func (h *KnowledgeHandler) UpdateEntry(c *gin.Context) {
|
|
if !requireKnowledgeManager(c) {
|
|
return
|
|
}
|
|
tenantID := middleware.GetTenantID(c)
|
|
id := c.Param("id")
|
|
|
|
var entry model.KnowledgeEntry
|
|
if err := model.DB.Where("id = ? AND tenant_id = ?", id, tenantID).First(&entry).Error; err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "条目不存在"})
|
|
return
|
|
}
|
|
|
|
var updates map[string]interface{}
|
|
if err := c.ShouldBindJSON(&updates); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
|
|
return
|
|
}
|
|
|
|
allowed := map[string]bool{"category_id": true, "title": true, "content": true, "status": true}
|
|
for key := range updates {
|
|
if !allowed[key] {
|
|
delete(updates, key)
|
|
}
|
|
}
|
|
if categoryID, exists := updates["category_id"]; exists {
|
|
var category model.Category
|
|
if err := model.DB.Where("id = ? AND tenant_id = ?", categoryID, tenantID).First(&category).Error; err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "知识分类不存在"})
|
|
return
|
|
}
|
|
}
|
|
if len(updates) == 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "没有可更新字段"})
|
|
return
|
|
}
|
|
|
|
if err := model.DB.Model(&entry).Updates(updates).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "更新失败"})
|
|
return
|
|
}
|
|
model.DB.First(&entry, entry.ID)
|
|
middleware.JSON(c, entry)
|
|
}
|
|
|
|
func (h *KnowledgeHandler) DeleteEntry(c *gin.Context) {
|
|
if !requireKnowledgeManager(c) {
|
|
return
|
|
}
|
|
tenantID := middleware.GetTenantID(c)
|
|
id := c.Param("id")
|
|
|
|
result := model.DB.Where("id = ? AND tenant_id = ?", id, tenantID).Delete(&model.KnowledgeEntry{})
|
|
if result.RowsAffected == 0 {
|
|
c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "条目不存在"})
|
|
return
|
|
}
|
|
|
|
middleware.JSON(c, gin.H{"message": "已删除"})
|
|
}
|