mlogclub
281 lines
8.8 KiB
Go
281 lines
8.8 KiB
Go
package console
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"strings"
|
|
"time"
|
|
|
|
"cs-agent/internal/builders"
|
|
"cs-agent/internal/models"
|
|
"cs-agent/internal/pkg/constants"
|
|
"cs-agent/internal/pkg/dto/request"
|
|
"cs-agent/internal/pkg/dto/response"
|
|
"cs-agent/internal/pkg/enums"
|
|
"cs-agent/internal/pkg/errorsx"
|
|
"cs-agent/internal/pkg/utils"
|
|
"cs-agent/internal/services"
|
|
|
|
"github.com/kataras/iris/v12"
|
|
"github.com/mlogclub/simple/web"
|
|
"github.com/mlogclub/simple/web/params"
|
|
)
|
|
|
|
type SkillDefinitionController struct {
|
|
Ctx iris.Context
|
|
}
|
|
|
|
func (c *SkillDefinitionController) AnyList() *web.JsonResult {
|
|
if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionView); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
cnd := params.NewPagedSqlCnd(c.Ctx,
|
|
params.QueryFilter{ParamName: "status"},
|
|
params.QueryFilter{ParamName: "name", Op: params.Like},
|
|
params.QueryFilter{ParamName: "code", Op: params.Like},
|
|
).Asc("priority").Desc("id")
|
|
list, paging := services.SkillDefinitionService.FindPageByCnd(cnd)
|
|
results := make([]response.SkillDefinitionResponse, 0, len(list))
|
|
for _, item := range list {
|
|
results = append(results, builders.BuildSkillDefinitionResponse(&item))
|
|
}
|
|
return web.JsonData(&web.PageResult{Results: results, Page: paging})
|
|
}
|
|
|
|
func (c *SkillDefinitionController) GetList_all() *web.JsonResult {
|
|
if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionView); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
list := services.SkillDefinitionService.Find(params.NewSqlCnd(c.Ctx,
|
|
params.QueryFilter{ParamName: "status"},
|
|
).Asc("priority").Desc("id"))
|
|
results := make([]response.SkillDefinitionResponse, 0, len(list))
|
|
for _, item := range list {
|
|
results = append(results, builders.BuildSkillDefinitionResponse(&item))
|
|
}
|
|
return web.JsonData(results)
|
|
}
|
|
|
|
func (c *SkillDefinitionController) GetBy(id int64) *web.JsonResult {
|
|
if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionView); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
item := services.SkillDefinitionService.Get(id)
|
|
if item == nil {
|
|
return web.JsonErrorMsg("Skill 不存在")
|
|
}
|
|
return web.JsonData(builders.BuildSkillDefinitionResponse(item))
|
|
}
|
|
|
|
func (c *SkillDefinitionController) PostCreate() *web.JsonResult {
|
|
operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionCreate)
|
|
if err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
req := request.CreateSkillDefinitionRequest{}
|
|
if err := params.ReadJSON(c.Ctx, &req); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
if err := validateSkillDefinitionRequest(req); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
if services.SkillDefinitionService.Take("code = ?", strings.TrimSpace(req.Code)) != nil {
|
|
return web.JsonErrorMsg("Skill 编码已存在")
|
|
}
|
|
|
|
item := &models.SkillDefinition{
|
|
Code: strings.TrimSpace(req.Code),
|
|
Name: strings.TrimSpace(req.Name),
|
|
Description: strings.TrimSpace(req.Description),
|
|
Prompt: strings.TrimSpace(req.Prompt),
|
|
ExecutionMode: normalizeExecutionMode(req.ExecutionMode),
|
|
ExecutionConfig: normalizeExecutionConfig(req.ExecutionConfig),
|
|
Priority: 0,
|
|
Status: enums.StatusOk,
|
|
Remark: strings.TrimSpace(req.Remark),
|
|
AuditFields: utils.BuildAuditFields(operator),
|
|
}
|
|
if err := services.SkillDefinitionService.Create(item); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
return web.JsonData(builders.BuildSkillDefinitionResponse(item))
|
|
}
|
|
|
|
func (c *SkillDefinitionController) PostUpdate() *web.JsonResult {
|
|
operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionUpdate)
|
|
if err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
req := request.UpdateSkillDefinitionRequest{}
|
|
if err := params.ReadJSON(c.Ctx, &req); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
if req.ID <= 0 {
|
|
return web.JsonErrorMsg("Skill ID 不合法")
|
|
}
|
|
if err := validateSkillDefinitionRequest(req.CreateSkillDefinitionRequest); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
item := services.SkillDefinitionService.Get(req.ID)
|
|
if item == nil {
|
|
return web.JsonErrorMsg("Skill 不存在")
|
|
}
|
|
exists := services.SkillDefinitionService.Take("code = ? AND id <> ?", strings.TrimSpace(req.Code), req.ID)
|
|
if exists != nil {
|
|
return web.JsonErrorMsg("Skill 编码已存在")
|
|
}
|
|
|
|
if err := services.SkillDefinitionService.Updates(req.ID, map[string]any{
|
|
"code": strings.TrimSpace(req.Code),
|
|
"name": strings.TrimSpace(req.Name),
|
|
"description": strings.TrimSpace(req.Description),
|
|
"prompt": strings.TrimSpace(req.Prompt),
|
|
"execution_mode": normalizeExecutionMode(req.ExecutionMode),
|
|
"execution_config": normalizeExecutionConfig(req.ExecutionConfig),
|
|
"remark": strings.TrimSpace(req.Remark),
|
|
"update_user_id": operator.UserID,
|
|
"update_user_name": operator.Username,
|
|
"updated_at": time.Now(),
|
|
}); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
return web.JsonSuccess()
|
|
}
|
|
|
|
func (c *SkillDefinitionController) PostUpdate_status() *web.JsonResult {
|
|
operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionUpdate)
|
|
if err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
req := request.UpdateSkillDefinitionStatusRequest{}
|
|
if err := params.ReadJSON(c.Ctx, &req); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
if req.ID <= 0 {
|
|
return web.JsonErrorMsg("Skill ID 不合法")
|
|
}
|
|
if !enums.IsValidStatus(req.Status) {
|
|
return web.JsonErrorMsg("状态值不合法")
|
|
}
|
|
if services.SkillDefinitionService.Get(req.ID) == nil {
|
|
return web.JsonErrorMsg("Skill 不存在")
|
|
}
|
|
|
|
if err := services.SkillDefinitionService.Updates(req.ID, map[string]any{
|
|
"status": req.Status,
|
|
"update_user_id": operator.UserID,
|
|
"update_user_name": operator.Username,
|
|
"updated_at": time.Now(),
|
|
}); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
return web.JsonSuccess()
|
|
}
|
|
|
|
func (c *SkillDefinitionController) PostDelete() *web.JsonResult {
|
|
operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionDelete)
|
|
if err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
req := request.DeleteSkillDefinitionRequest{}
|
|
if err := params.ReadJSON(c.Ctx, &req); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
if req.ID <= 0 {
|
|
return web.JsonErrorMsg("Skill ID 不合法")
|
|
}
|
|
if services.SkillDefinitionService.Get(req.ID) == nil {
|
|
return web.JsonErrorMsg("Skill 不存在")
|
|
}
|
|
if err := services.SkillDefinitionService.Updates(req.ID, map[string]any{
|
|
"status": enums.StatusDeleted,
|
|
"update_user_id": operator.UserID,
|
|
"update_user_name": operator.Username,
|
|
"updated_at": time.Now(),
|
|
}); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
return web.JsonSuccess()
|
|
}
|
|
|
|
func (c *SkillDefinitionController) PostUpdate_priority() *web.JsonResult {
|
|
if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionUpdate); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
var ids []int64
|
|
if err := c.Ctx.ReadJSON(&ids); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
if err := services.SkillDefinitionService.UpdatePriority(ids); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
return web.JsonSuccess()
|
|
}
|
|
|
|
func (c *SkillDefinitionController) PostDebug_run() *web.JsonResult {
|
|
if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionView); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
|
|
req := request.SkillDebugRunRequest{}
|
|
if err := params.ReadJSON(c.Ctx, &req); err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
resp, err := services.SkillRuntimeService.DebugRun(context.Background(), req)
|
|
if err != nil {
|
|
return web.JsonError(err)
|
|
}
|
|
return web.JsonData(resp)
|
|
}
|
|
|
|
func validateSkillDefinitionRequest(req request.CreateSkillDefinitionRequest) error {
|
|
code := strings.TrimSpace(req.Code)
|
|
name := strings.TrimSpace(req.Name)
|
|
prompt := strings.TrimSpace(req.Prompt)
|
|
if code == "" {
|
|
return errorsx.InvalidParam("Skill 编码不能为空")
|
|
}
|
|
if name == "" {
|
|
return errorsx.InvalidParam("Skill 名称不能为空")
|
|
}
|
|
mode := normalizeExecutionMode(req.ExecutionMode)
|
|
if prompt == "" {
|
|
return errorsx.InvalidParam("Prompt 不能为空")
|
|
}
|
|
switch mode {
|
|
case enums.SkillExecutionModePromptOnly:
|
|
case enums.SkillExecutionModeMCPTool:
|
|
configText := strings.TrimSpace(req.ExecutionConfig)
|
|
if configText == "" {
|
|
return errorsx.InvalidParam("MCP工具模式必须填写ExecutionConfig")
|
|
}
|
|
var payload map[string]any
|
|
if err := json.Unmarshal([]byte(configText), &payload); err != nil {
|
|
return errorsx.InvalidParam("ExecutionConfig 必须是合法JSON")
|
|
}
|
|
default:
|
|
return errorsx.InvalidParam("Skill 执行模式不合法")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func normalizeExecutionMode(mode enums.SkillExecutionMode) enums.SkillExecutionMode {
|
|
if mode == "" {
|
|
return enums.SkillExecutionModePromptOnly
|
|
}
|
|
return mode
|
|
}
|
|
|
|
func normalizeExecutionConfig(raw string) string {
|
|
return strings.TrimSpace(raw)
|
|
}
|