videoplayer/handler/dbm.go

package handler

import (
	"github.com/gin-gonic/gin"
	"log"
	"net/http"
	"videoplayer/proto"
	"videoplayer/service"
)

func SetDBManageGroup(router *gin.Engine) {
	dbm := router.Group("/dbm")

	dbm.POST("/run_sql", RunSQLHandler)                          // 运行SQL语句
	dbm.POST("/create_db_manage", CreateDBManageHandler)         // 创建数据库管理
	dbm.POST("/get_db_manage", GetDBManageHandler)               // 获取数据库管理信息
	dbm.POST("/get_sql_history", GetSQLRunHistoryHandler)        // 获取SQL运行历史
	dbm.POST("/update_db_manage", UpdateDBManageHandler)         // 更新数据库管理信息
	dbm.POST("/del_db_manage", DeleteDBManageHandler)            // 删除数据库管理信息
	dbm.POST("/del_dbm_sql_history", DeleteSQLRunHistoryHandler) // 删除SQL运行历史
	dbm.POST("/get_db_table_desc", GetDBTableDescHandler)        // 获取数据库表描述
}

func DeleteSQLRunHistoryHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.DeleteDBManageSQLHistoryReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		err2 := service.DeleteSQLRunHistory(&req, userID)
		if err2 != nil {
			resp.Code = proto.DBMRunSQLHistoryDeleteFailed
			resp.Message = "删除SQL运行历史失败: " + err2.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "删除SQL运行历史成功"
		}
	}
	c.JSON(http.StatusOK, resp)

}

func DeleteDBManageHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.DeleteDBManageReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		err2 := service.DeleteDBManage(&req, userID)
		if err2 != nil {
			resp.Code = proto.DBMDeleteFailed
			resp.Message = "删除数据库管理失败: " + err2.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "删除数据库管理成功"
		}
	}
	c.JSON(http.StatusOK, resp)
}

func UpdateDBManageHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.UpdateDBManageReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		dbManage, err2 := service.UpdateDBManage(&req, userID)
		if err2 != nil {
			resp.Code = proto.DBMUpdateFailed
			resp.Message = "更新数据库管理失败: " + err2.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "更新数据库管理成功"
			resp.Data = dbManage
		}
	}
	c.JSON(http.StatusOK, resp)
}

func GetSQLRunHistoryHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.GetSQLRunHistoryReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		history, err2 := service.GetSQLRunHistory(&req, userID)
		if err2 != nil {
			resp.Code = proto.DBMGetFailed
			resp.Message = "获取SQL运行历史失败: " + err2.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "获取SQL运行历史成功"
			resp.Data = history
		}
	}
	c.JSON(http.StatusOK, resp)
}

func GetDBManageHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))

	var req proto.GetDBManageReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		dbManage, err2 := service.GetDBManageList(&req, userID)
		if err2 != nil {
			resp.Code = proto.DBMGetFailed
			resp.Message = "获取数据库管理信息失败: " + err2.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "获取数据库管理信息成功"
			resp.Data = dbManage
		}
	}
	c.JSON(http.StatusOK, resp)
}

func CreateDBManageHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))

	var req proto.CreateDBManageReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		dbManage, err2 := service.CreateDBManage(&req, userID)
		if err2 != nil {
			resp.Code = proto.DBMCreateFailed
			resp.Message = "创建数据库管理失败: " + err.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "创建数据库管理成功"
			resp.Data = dbManage
		}
	}
	c.JSON(http.StatusOK, resp)
}

func RunSQLHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := uint(id.(float64))
	// 处理运行SQL请求
	var req proto.RunSQLRequest
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		req.UserID = userID
		res, err2 := service.RunSQL(&req)
		if err2 != nil {
			resp.Code = proto.DBMRunSQLFailed
			resp.Message = "运行SQL失败: " + err2.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "运行SQL成功"
			resp.Data = res
		}
	}
	log.Println("run sql resp, sql is:", req.SQL)
	c.JSON(http.StatusOK, resp)
	return
}

func GetDBTableDescHandler(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))

	var req proto.GetDBTableDescReq
	var resp proto.GeneralResp
	if err := c.ShouldBind(&req); err != nil {
		resp.Code = proto.ParameterError
		resp.Message = "请求参数解析错误"
	} else {
		tableDesc, err2 := service.GetDBTableDesc(&req, userID)
		if err2 != nil {
			resp.Code = proto.DBMGetTableDescFailed
			resp.Message = "获取数据库表描述失败: " + err2.Error()
		} else {
			resp.Code = proto.SuccessCode
			resp.Message = "获取数据库表描述成功"
			resp.Data = tableDesc
		}
	}
	c.JSON(http.StatusOK, resp)
}