silk/server-go/internal/handler/knowledge.go

package handler

import (
	"net/http"

	"silk-server-go/internal/middleware"
	"silk-server-go/internal/model"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

// RegisterKnowledgeRoutes 注册知识库路由
func RegisterKnowledgeRoutes(rg *gin.RouterGroup, db *gorm.DB) {
	read := middleware.RequirePermission(db, "knowledge:read")
	write := middleware.RequirePermission(db, "knowledge:write")

	rg.GET("/knowledge/diseases", read, listDiseases(db))
	rg.GET("/knowledge/diseases/:id", read, getDisease(db))
	rg.POST("/knowledge/diseases", write, createDisease(db))
	rg.PATCH("/knowledge/diseases/:id", write, updateDisease(db))
	rg.DELETE("/knowledge/diseases/:id", write, deleteDisease(db))

	rg.GET("/knowledge/articles", read, listArticles(db))
	rg.GET("/knowledge/articles/:id", read, getArticle(db))
	rg.POST("/knowledge/articles", write, createArticle(db))
	rg.PATCH("/knowledge/articles/:id", write, updateArticle(db))
	rg.DELETE("/knowledge/articles/:id", write, deleteArticle(db))
}

// listDiseases 蚕病百科列表（支持 category/keyword/enabled 过滤）
func listDiseases(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		q := db.Model(&model.Disease{})
		if cat := c.Query("category"); cat != "" {
			q = q.Where("category = ?", cat)
		}
		if kw := c.Query("keyword"); kw != "" {
			q = q.Where("name ILIKE ?", "%"+kw+"%")
		}
		if enabled := c.Query("enabled"); enabled != "" {
			q = q.Where("enabled = ?", enabled == "true")
		}
		var list []model.Disease
		q.Order("sort_order ASC, name ASC").Find(&list)
		c.JSON(http.StatusOK, list)
	}
}

// getDisease 蚕病百科详情
func getDisease(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		var d model.Disease
		if db.Where("id = ?", c.Param("id")).First(&d).Error != nil {
			c.JSON(http.StatusNotFound, gin.H{"error": "disease not found"})
			return
		}
		c.JSON(http.StatusOK, d)
	}
}

// createDisease 新建病种
func createDisease(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		var d model.Disease
		if err := c.ShouldBindJSON(&d); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		d.ID = ""
		if d.Name == "" {
			c.JSON(http.StatusBadRequest, gin.H{"error": "病种名称不能为空"})
			return
		}
		if err := db.Create(&d).Error; err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "创建失败"})
			return
		}
		c.JSON(http.StatusCreated, d)
	}
}

// updateDisease 更新病种
func updateDisease(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		id := c.Param("id")
		var d model.Disease
		if db.Where("id = ?", id).First(&d).Error != nil {
			c.JSON(http.StatusNotFound, gin.H{"error": "disease not found"})
			return
		}
		updates, err := bindUpdates(c)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		if len(updates) > 0 {
			db.Model(&model.Disease{}).Where("id = ?", id).Updates(updates)
		}
		db.Where("id = ?", id).First(&d)
		c.JSON(http.StatusOK, d)
	}
}

// deleteDisease 删除病种
func deleteDisease(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		id := c.Param("id")
		var d model.Disease
		if db.Where("id = ?", id).First(&d).Error != nil {
			c.JSON(http.StatusNotFound, gin.H{"error": "disease not found"})
			return
		}
		db.Where("id = ?", id).Delete(&model.Disease{})
		c.JSON(http.StatusOK, gin.H{"id": id})
	}
}

// listArticles 知识文章列表（支持 kind/enabled 过滤）
func listArticles(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		q := db.Model(&model.KnowledgeArticle{})
		if kind := c.Query("kind"); kind != "" {
			q = q.Where("kind = ?", kind)
		}
		if enabled := c.Query("enabled"); enabled != "" {
			q = q.Where("enabled = ?", enabled == "true")
		}
		var list []model.KnowledgeArticle
		q.Order("sort_order ASC, created_at DESC").Find(&list)
		c.JSON(http.StatusOK, list)
	}
}

// getArticle 知识文章详情
func getArticle(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		var a model.KnowledgeArticle
		if db.Where("id = ?", c.Param("id")).First(&a).Error != nil {
			c.JSON(http.StatusNotFound, gin.H{"error": "article not found"})
			return
		}
		c.JSON(http.StatusOK, a)
	}
}

// createArticle 新建知识文章
func createArticle(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		var a model.KnowledgeArticle
		if err := c.ShouldBindJSON(&a); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		a.ID = ""
		if a.Kind == "" || a.Title == "" {
			c.JSON(http.StatusBadRequest, gin.H{"error": "文章类型和标题不能为空"})
			return
		}
		if err := db.Create(&a).Error; err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "创建失败"})
			return
		}
		c.JSON(http.StatusCreated, a)
	}
}

// updateArticle 更新知识文章
func updateArticle(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		id := c.Param("id")
		var a model.KnowledgeArticle
		if db.Where("id = ?", id).First(&a).Error != nil {
			c.JSON(http.StatusNotFound, gin.H{"error": "article not found"})
			return
		}
		updates, err := bindUpdates(c)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		if len(updates) > 0 {
			db.Model(&model.KnowledgeArticle{}).Where("id = ?", id).Updates(updates)
		}
		db.Where("id = ?", id).First(&a)
		c.JSON(http.StatusOK, a)
	}
}

// deleteArticle 删除知识文章
func deleteArticle(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		id := c.Param("id")
		var a model.KnowledgeArticle
		if db.Where("id = ?", id).First(&a).Error != nil {
			c.JSON(http.StatusNotFound, gin.H{"error": "article not found"})
			return
		}
		db.Where("id = ?", id).Delete(&model.KnowledgeArticle{})
		c.JSON(http.StatusOK, gin.H{"id": id})
	}
}