TaskPool/internal/controllers/mise_controller.go

package controllers

import (
	"github.com/engigu/taskpool/internal/services"
	"github.com/engigu/taskpool/internal/utils"

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

type MiseController struct {
	service *services.MiseService
}

func NewMiseController(service *services.MiseService) *MiseController {
	return &MiseController{
		service: service,
	}
}

// List 获取语言列表
func (c *MiseController) List(ctx *gin.Context) {
	langs, err := c.service.List()
	if err != nil {
		utils.ServerError(ctx, "获取语言列表失败: "+err.Error())
		return
	}
	utils.Success(ctx, langs)
}

// Sync 同步本地环境到数据库
func (c *MiseController) Sync(ctx *gin.Context) {
	if err := c.service.Sync(); err != nil {
		utils.ServerError(ctx, "同步本地环境失败: "+err.Error())
		return
	}
	utils.Success(ctx, nil)
}

// Plugins 获取可用插件列表
func (c *MiseController) Plugins(ctx *gin.Context) {
	plugins, err := c.service.Plugins()
	if err != nil {
		utils.ServerError(ctx, "获取插件列表失败: "+err.Error())
		return
	}
	utils.Success(ctx, plugins)
}

// Versions 获取指定插件的可用版本列表
func (c *MiseController) Versions(ctx *gin.Context) {
	plugin := ctx.Query("plugin")
	if plugin == "" {
		utils.BadRequest(ctx, "参数 plugin 不能为空")
		return
	}
	versions, err := c.service.Versions(plugin)
	if err != nil {
		utils.ServerError(ctx, "获取版本列表失败: "+err.Error())
		return
	}
	utils.Success(ctx, versions)
}

// VerifyCommand 获取验证命令
func (c *MiseController) VerifyCommand(ctx *gin.Context) {
	plugin := ctx.Query("plugin")
	version := ctx.Query("version")
	if plugin == "" {
		utils.BadRequest(ctx, "参数 plugin 不能为空")
		return
	}
	cmd, err := c.service.GetVerifyCommand(plugin, version)
	if err != nil {
		utils.ServerError(ctx, "获取验证命令失败: "+err.Error())
		return
	}
	utils.Success(ctx, gin.H{"command": cmd})
}

// UseGlobal 设置全局默认版本
func (c *MiseController) UseGlobal(ctx *gin.Context) {
	var req struct {
		Plugin  string `json:"plugin"`
		Version string `json:"version"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}
	if req.Plugin == "" || req.Version == "" {
		utils.BadRequest(ctx, "参数 plugin 和 version 不能为空")
		return
	}
	if err := c.service.UseGlobal(req.Plugin, req.Version); err != nil {
		utils.ServerError(ctx, "设置全局版本失败: "+err.Error())
		return
	}
	utils.Success(ctx, nil)
}

// UnsetGlobal 取消全局默认版本
func (c *MiseController) UnsetGlobal(ctx *gin.Context) {
	var req struct {
		Plugin  string `json:"plugin"`
		Version string `json:"version"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}
	if req.Plugin == "" {
		utils.BadRequest(ctx, "参数 plugin 不能为空")
		return
	}
	if err := c.service.UnsetGlobal(req.Plugin, req.Version); err != nil {
		utils.ServerError(ctx, "取消全局版本失败: "+err.Error())
		return
	}
	utils.Success(ctx, nil)
}

// Envs 获取全局环境变量
func (c *MiseController) Envs(ctx *gin.Context) {
	envs, err := c.service.Envs()
	if err != nil {
		utils.ServerError(ctx, "获取全局环境变量失败: "+err.Error())
		return
	}
	utils.Success(ctx, envs)
}

// SetEnv 设置全局环境变量
func (c *MiseController) SetEnv(ctx *gin.Context) {
	var req struct {
		Key   string `json:"key"`
		Value string `json:"value"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}
	if req.Key == "" {
		utils.BadRequest(ctx, "参数 key 不能为空")
		return
	}
	if err := c.service.SetEnv(req.Key, req.Value); err != nil {
		utils.ServerError(ctx, "设置环境变量失败: "+err.Error())
		return
	}
	utils.Success(ctx, nil)
}

// UnsetEnv 取消全局环境变量
func (c *MiseController) UnsetEnv(ctx *gin.Context) {
	key := ctx.Query("key")
	if key == "" {
		utils.BadRequest(ctx, "参数 key 不能为空")
		return
	}
	if err := c.service.UnsetEnv(key); err != nil {
		utils.ServerError(ctx, "取消环境变量失败: "+err.Error())
		return
	}
	utils.Success(ctx, nil)
}