knowledge-graph-agent/backend/internal/handler/crud_handler.go

package handler

import (
	"net/http"

	"github.com/gin-gonic/gin"
	"knowledge-graph-backend/internal/model"
	"knowledge-graph-backend/internal/service"
)

// NodeCRUDHandler 节点的增删改处理器
type NodeCRUDHandler struct {
	service service.GraphService
}

// NewNodeCRUDHandler 创建节点CRUD处理器
func NewNodeCRUDHandler(svc service.GraphService) *NodeCRUDHandler {
	return &NodeCRUDHandler{
		service: svc,
	}
}

// EdgeCRUDHandler 边的增删改处理器
type EdgeCRUDHandler struct {
	service service.GraphService
}

// NewEdgeCRUDHandler 创建边CRUD处理器
func NewEdgeCRUDHandler(svc service.GraphService) *EdgeCRUDHandler {
	return &EdgeCRUDHandler{
		service: svc,
	}
}

// CreateNode 创建新节点
// @Summary 创建节点
// @Description 在知识图谱中创建一个新节点
// @Accept json
// @Produce json
// @Param request body model.CreateNodeRequest true "节点创建请求"
// @Success 200 {object} model.Node "创建成功"
// @Failure 400 {object} model.ErrorResponse "请求错误"
// @Failure 409 {object} model.ErrorResponse "节点已存在"
// @Failure 500 {object} model.ErrorResponse "内部错误"
// @Router /api/nodes [post]
func (h *NodeCRUDHandler) CreateNode(c *gin.Context) {
	var req model.CreateNodeRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.ErrorResponse{
			Error:   "invalid_request",
			Message: err.Error(),
		})
		return
	}

	node, err := h.service.CreateNode(req)
	if err != nil {
		c.JSON(http.StatusConflict, model.ErrorResponse{
			Error:   "create_failed",
			Message: err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, node)
}

// UpdateNode 更新节点
// @Summary 更新节点
// @Description 更新知识图谱中指定节点的信息
// @Accept json
// @Produce json
// @Param id path string true "节点ID"
// @Param request body model.UpdateNodeRequest true "节点更新请求"
// @Success 200 {object} model.Node "更新成功"
// @Failure 400 {object} model.ErrorResponse "请求错误"
// @Failure 404 {object} model.ErrorResponse "节点未找到"
// @Failure 500 {object} model.ErrorResponse "内部错误"
// @Router /api/nodes/{id} [put]
func (h *NodeCRUDHandler) UpdateNode(c *gin.Context) {
	id := c.Param("id")

	var req model.UpdateNodeRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.ErrorResponse{
			Error:   "invalid_request",
			Message: err.Error(),
		})
		return
	}

	node, err := h.service.UpdateNode(id, req)
	if err != nil {
		c.JSON(http.StatusNotFound, model.ErrorResponse{
			Error:   "update_failed",
			Message: err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, node)
}

// DeleteNode 删除节点
// @Summary 删除节点
// @Description 从知识图谱中删除指定节点及其相关的所有边
// @Produce json
// @Param id path string true "节点ID"
// @Success 200 {object} model.DeleteResponse "删除成功"
// @Failure 404 {object} model.ErrorResponse "节点未找到"
// @Failure 500 {object} model.ErrorResponse "内部错误"
// @Router /api/nodes/{id} [delete]
func (h *NodeCRUDHandler) DeleteNode(c *gin.Context) {
	id := c.Param("id")

	err := h.service.DeleteNode(id)
	if err != nil {
		c.JSON(http.StatusNotFound, model.ErrorResponse{
			Error:   "delete_failed",
			Message: err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, model.DeleteResponse{
		Success: true,
		Message: "节点已成功删除",
		ID:      id,
	})
}

// CreateEdge 创建新边
// @Summary 创建边
// @Description 在知识图谱中创建一个新边（关系）
// @Accept json
// @Produce json
// @Param request body model.CreateEdgeRequest true "边创建请求"
// @Success 200 {object} model.EdgeResponse "创建成功"
// @Failure 400 {object} model.ErrorResponse "请求错误"
// @Failure 404 {object} model.ErrorResponse "源节点或目标节点未找到"
// @Failure 409 {object} model.ErrorResponse "边已存在"
// @Failure 500 {object} model.ErrorResponse "内部错误"
// @Router /api/edges [post]
func (h *EdgeCRUDHandler) CreateEdge(c *gin.Context) {
	var req model.CreateEdgeRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.ErrorResponse{
			Error:   "invalid_request",
			Message: err.Error(),
		})
		return
	}

	edge, err := h.service.CreateEdge(req)
	if err != nil {
		c.JSON(http.StatusConflict, model.ErrorResponse{
			Error:   "create_failed",
			Message: err.Error(),
		})
		return
	}

	// 转换为响应格式
	response := model.EdgeResponse{
		ID:         edge.ID,
		Source:     edge.Source,
		Target:     edge.Target,
		Label:      edge.Label,
		Type:       edge.Type,
		Properties: edge.Properties,
	}

	c.JSON(http.StatusOK, response)
}

// DeleteEdge 删除边
// @Summary 删除边
// @Description 从知识图谱中删除指定的边
// @Produce json
// @Param id path string true "边ID"
// @Success 200 {object} model.DeleteResponse "删除成功"
// @Failure 404 {object} model.ErrorResponse "边未找到"
// @Failure 500 {object} model.ErrorResponse "内部错误"
// @Router /api/edges/{id} [delete]
func (h *EdgeCRUDHandler) DeleteEdge(c *gin.Context) {
	edgeID := c.Param("id")

	err := h.service.DeleteEdge(edgeID)
	if err != nil {
		c.JSON(http.StatusNotFound, model.ErrorResponse{
			Error:   "delete_failed",
			Message: err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, model.DeleteResponse{
		Success: true,
		Message: "边已成功删除",
		ID:      edgeID,
	})
}